• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

pulibrary / bibdata / 526caaa1-66b8-4cc2-904f-4910c5de2373

25 Sep 2025 04:52PM UTC coverage: 90.509% (+0.9%) from 89.659%
526caaa1-66b8-4cc2-904f-4910c5de2373

Pull #2941

circleci

Ryan Laddusaw
Update config load json
Pull Request #2941: Update solr for CI and local deveopment to solr 9.9

7801 of 8619 relevant lines covered (90.51%)

393.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.41
/lib/bibdata_rs/src/ephemera/ephemera_folder_builder.rs
1
use super::ephemera_folder::coverage::Coverage;
2
use super::ephemera_folder::format::Format;
3
use super::ephemera_folder::origin_place::OriginPlace;
4
use super::ephemera_folder::VecSafe;
5
use super::ephemera_folder::{EphemeraFolder, Thumbnail};
6
use crate::ephemera;
7
use crate::ephemera::ephemera_folder::language::Language;
8
use crate::ephemera::ephemera_folder::{self};
9
use crate::ephemera_folder::subject::Subject;
10
use crate::solr::ElectronicAccess;
11

12
#[derive(Default)]
13
pub struct EphemeraFolderBuilder {
14
    alternative: Option<Vec<String>>,
15
    creator: Option<Vec<String>>,
16
    contributor: Option<Vec<String>>,
17
    coverage: Option<Vec<Coverage>>,
18
    date_created: Option<Vec<String>>,
19
    description: Option<Vec<String>>,
20
    electronic_access: Option<Vec<ElectronicAccess>>,
21
    format: Option<Vec<Format>>,
22
    id: Option<String>,
23
    language: Option<Vec<Language>>,
24
    origin_place: Option<Vec<OriginPlace>>,
25
    page_count: Option<String>,
26
    provenance: Option<String>,
27
    publisher: Option<Vec<String>>,
28
    subject: Option<Vec<Subject>>,
29
    sort_title: Option<Vec<String>>,
30
    title: Option<Vec<String>>,
31
    thumbnail: Option<ephemera_folder::Thumbnail>,
32
    transliterated_title: Option<Vec<String>>,
33
}
34

35
impl EphemeraFolderBuilder {
36
    pub fn new() -> Self {
29✔
37
        Self::default()
29✔
38
    }
29✔
39

40
    pub fn alternative(mut self, alternative: Vec<String>) -> Self {
3✔
41
        self.alternative = Some(alternative);
3✔
42
        self
3✔
43
    }
3✔
44
    pub fn id(mut self, id: String) -> Self {
29✔
45
        self.id = Some(id);
29✔
46
        self
29✔
47
    }
29✔
48
    pub fn contributor(mut self, contributor: Vec<String>) -> Self {
5✔
49
        self.contributor = Some(contributor);
5✔
50
        self
5✔
51
    }
5✔
52
    pub fn coverage(mut self, country: Vec<Coverage>) -> Self {
2✔
53
        self.coverage = Some(country);
2✔
54
        self
2✔
55
    }
2✔
56
    pub fn creator(mut self, creator: Vec<String>) -> Self {
4✔
57
        self.creator = Some(creator);
4✔
58
        self
4✔
59
    }
4✔
60
    pub fn date_created(mut self, date_created: Vec<String>) -> Self {
3✔
61
        self.date_created = Some(date_created);
3✔
62
        self
3✔
63
    }
3✔
64
    pub fn description(mut self, description: Vec<String>) -> Self {
1✔
65
        self.description = Some(description);
1✔
66
        self
1✔
67
    }
1✔
68
    pub fn electronic_access(mut self, electronic_access: Vec<ElectronicAccess>) -> Self {
1✔
69
        self.electronic_access = Some(electronic_access);
1✔
70
        self
1✔
71
    }
1✔
72
    pub fn format(mut self, format: Vec<Format>) -> Self {
1✔
73
        self.format = Some(format);
1✔
74
        self
1✔
75
    }
1✔
76
    pub fn language(mut self, language: Vec<Language>) -> Self {
×
77
        self.language = Some(language);
×
78
        self
×
79
    }
×
80
    pub fn origin_place(mut self, origin: Vec<OriginPlace>) -> Self {
2✔
81
        self.origin_place = Some(origin);
2✔
82
        self
2✔
83
    }
2✔
84
    pub fn page_count(mut self, page_count: String) -> Self {
1✔
85
        self.page_count = Some(page_count);
1✔
86
        self
1✔
87
    }
1✔
88
    pub fn provenance(mut self, provenance: String) -> Self {
2✔
89
        self.provenance = Some(provenance);
2✔
90
        self
2✔
91
    }
2✔
92
    pub fn publisher(mut self, publisher: Vec<String>) -> Self {
4✔
93
        self.publisher = Some(publisher);
4✔
94
        self
4✔
95
    }
4✔
96
    pub fn subject(mut self, subject: Vec<Subject>) -> Self {
3✔
97
        self.subject = Some(subject);
3✔
98
        self
3✔
99
    }
3✔
100

101
    pub fn subjects(mut self, subjects: Vec<Subject>) -> Self {
×
102
        self.subject = Some(subjects);
×
103
        self
×
104
    }
×
105
    pub fn sort_title(mut self, sort_title: Vec<String>) -> Self {
1✔
106
        self.sort_title = Some(sort_title);
1✔
107
        self
1✔
108
    }
1✔
109
    pub fn thumbnail(mut self, thumbnail: Thumbnail) -> Self {
1✔
110
        self.thumbnail = Some(thumbnail);
1✔
111
        self
1✔
112
    }
1✔
113

114
    pub fn title(mut self, title: Vec<String>) -> Self {
28✔
115
        self.title = Some(title);
28✔
116
        self
28✔
117
    }
28✔
118

119
    pub fn transliterated_title(mut self, transliterated_title: Vec<String>) -> Self {
2✔
120
        self.transliterated_title = Some(transliterated_title);
2✔
121
        self
2✔
122
    }
2✔
123

124
    pub fn build(self) -> Result<EphemeraFolder, &'static str> {
29✔
125
        let id = self.id.ok_or("id is required")?;
29✔
126
        let title = self.title.ok_or("title is required")?;
29✔
127

128
        Ok(EphemeraFolder {
129
            alternative: self.alternative,
28✔
130
            creator: self.creator,
28✔
131
            contributor: self.contributor,
28✔
132
            coverage: self.coverage,
28✔
133
            date_created: self.date_created,
28✔
134
            description: self.description,
28✔
135
            electronic_access: self.electronic_access,
28✔
136
            format: self.format,
28✔
137
            id,
28✔
138
            language: self.language,
28✔
139
            origin: self.origin_place.map(|v| VecSafe(v)),
28✔
140
            page_count: self.page_count,
28✔
141
            provenance: self.provenance,
28✔
142
            publisher: self.publisher,
28✔
143
            sort_title: self.sort_title,
28✔
144
            subject: self.subject.map(|v| VecSafe::from(VecSafe(v))),
28✔
145
            title,
28✔
146
            thumbnail: self.thumbnail,
28✔
147
            transliterated_title: self.transliterated_title,
28✔
148
        })
149
    }
29✔
150
}
151

152
#[cfg(test)]
153
mod tests {
154
    use super::*;
155

156
    #[test]
157
    fn test_builder_success() {
1✔
158
        let item = EphemeraFolderBuilder::new()
1✔
159
            .id("test-id".to_string())
1✔
160
            .title(vec!["test title".to_string()])
1✔
161
            .alternative(vec!["alt title".to_string()])
1✔
162
            .creator(vec!["jessy".to_string()])
1✔
163
            .provenance("Test name".to_string())
1✔
164
            .publisher(vec!["Princeton Press".to_string()])
1✔
165
            .build();
1✔
166

167
        assert!(item.is_ok());
1✔
168
        let item = item.unwrap();
1✔
169
        assert_eq!(item.id, "test-id");
1✔
170
        assert_eq!(item.title, vec!["test title"]);
1✔
171
        assert_eq!(item.alternative, Some(vec!["alt title".to_string()]));
1✔
172
        assert_eq!(item.creator, Some(vec!["jessy".to_string()]));
1✔
173
        assert_eq!(item.provenance, Some("Test name".to_string()));
1✔
174
        assert_eq!(item.publisher, Some(vec!["Princeton Press".to_string()]));
1✔
175
    }
1✔
176

177
    #[test]
178
    fn test_builder_missing_required_fields() {
1✔
179
        let item = EphemeraFolderBuilder::new()
1✔
180
            .id("test-id".to_string())
1✔
181
            .build();
1✔
182

183
        assert!(item.is_err());
1✔
184
        assert_eq!(item.unwrap_err(), "title is required");
1✔
185
    }
1✔
186

187
    #[test]
188
    fn it_has_a_contributor() {
1✔
189
        let item = EphemeraFolderBuilder::new()
1✔
190
            .id("test-id".to_string())
1✔
191
            .title(vec!["test title".to_string()])
1✔
192
            .contributor(vec!["Eric".to_string()])
1✔
193
            .build();
1✔
194

195
        assert!(item.is_ok());
1✔
196
        let item = item.unwrap();
1✔
197
        assert_eq!(item.id, "test-id");
1✔
198
        assert_eq!(item.title, vec!["test title"]);
1✔
199
        assert_eq!(item.contributor, Some(vec!["Eric".to_string()]));
1✔
200
    }
1✔
201
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2025 Coveralls, Inc