526caaa1-66b8-4cc2-904f-4910c5de2373

Committed 25 Sep 2025 04:52PM UTC coverage: 90.509% (+0.9%) from 89.659%

Build # 526caaa1-66b8-4cc2-904f-4910c5de2373

Build Type

circleci

Committed by Ryan Laddusaw

Commit Message

Update config load json

Pull Request Pull Request #2941: Update solr for CI and local deveopment to solr 9.9

Run Details

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

use super::ephemera_folder::coverage::Coverage;
use super::ephemera_folder::format::Format;
use super::ephemera_folder::origin_place::OriginPlace;
use super::ephemera_folder::VecSafe;
use super::ephemera_folder::{EphemeraFolder, Thumbnail};
use crate::ephemera;
use crate::ephemera::ephemera_folder::language::Language;
use crate::ephemera::ephemera_folder::{self};
use crate::ephemera_folder::subject::Subject;
use crate::solr::ElectronicAccess;

#[derive(Default)]
pub struct EphemeraFolderBuilder {
    alternative: Option<Vec<String>>,
    creator: Option<Vec<String>>,
    contributor: Option<Vec<String>>,
    coverage: Option<Vec<Coverage>>,
    date_created: Option<Vec<String>>,
    description: Option<Vec<String>>,
    electronic_access: Option<Vec<ElectronicAccess>>,
    format: Option<Vec<Format>>,
    id: Option<String>,
    language: Option<Vec<Language>>,
    origin_place: Option<Vec<OriginPlace>>,
    page_count: Option<String>,
    provenance: Option<String>,
    publisher: Option<Vec<String>>,
    subject: Option<Vec<Subject>>,
    sort_title: Option<Vec<String>>,
    title: Option<Vec<String>>,
    thumbnail: Option<ephemera_folder::Thumbnail>,
    transliterated_title: Option<Vec<String>>,
}

impl EphemeraFolderBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn alternative(mut self, alternative: Vec<String>) -> Self {
        self.alternative = Some(alternative);
        self
    }
    pub fn id(mut self, id: String) -> Self {
        self.id = Some(id);
        self
    }
    pub fn contributor(mut self, contributor: Vec<String>) -> Self {
        self.contributor = Some(contributor);
        self
    }
    pub fn coverage(mut self, country: Vec<Coverage>) -> Self {
        self.coverage = Some(country);
        self
    }
    pub fn creator(mut self, creator: Vec<String>) -> Self {
        self.creator = Some(creator);
        self
    }
    pub fn date_created(mut self, date_created: Vec<String>) -> Self {
        self.date_created = Some(date_created);
        self
    }
    pub fn description(mut self, description: Vec<String>) -> Self {
        self.description = Some(description);
        self
    }
    pub fn electronic_access(mut self, electronic_access: Vec<ElectronicAccess>) -> Self {
        self.electronic_access = Some(electronic_access);
        self
    }
    pub fn format(mut self, format: Vec<Format>) -> Self {
        self.format = Some(format);
        self
    }
    pub fn language(mut self, language: Vec<Language>) -> Self {
        self.language = Some(language);
        self
    }
    pub fn origin_place(mut self, origin: Vec<OriginPlace>) -> Self {
        self.origin_place = Some(origin);
        self
    }
    pub fn page_count(mut self, page_count: String) -> Self {
        self.page_count = Some(page_count);
        self
    }
    pub fn provenance(mut self, provenance: String) -> Self {
        self.provenance = Some(provenance);
        self
    }
    pub fn publisher(mut self, publisher: Vec<String>) -> Self {
        self.publisher = Some(publisher);
        self
    }
    pub fn subject(mut self, subject: Vec<Subject>) -> Self {
        self.subject = Some(subject);
        self
    }

    pub fn subjects(mut self, subjects: Vec<Subject>) -> Self {
        self.subject = Some(subjects);
        self
    }
    pub fn sort_title(mut self, sort_title: Vec<String>) -> Self {
        self.sort_title = Some(sort_title);
        self
    }
    pub fn thumbnail(mut self, thumbnail: Thumbnail) -> Self {
        self.thumbnail = Some(thumbnail);
        self
    }

    pub fn title(mut self, title: Vec<String>) -> Self {
        self.title = Some(title);
        self
    }

    pub fn transliterated_title(mut self, transliterated_title: Vec<String>) -> Self {
        self.transliterated_title = Some(transliterated_title);
        self
    }

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

        Ok(EphemeraFolder {
            alternative: self.alternative,
            creator: self.creator,
            contributor: self.contributor,
            coverage: self.coverage,
            date_created: self.date_created,
            description: self.description,
            electronic_access: self.electronic_access,
            format: self.format,
            id,
            language: self.language,
            origin: self.origin_place.map(|v| VecSafe(v)),
            page_count: self.page_count,
            provenance: self.provenance,
            publisher: self.publisher,
            sort_title: self.sort_title,
            subject: self.subject.map(|v| VecSafe::from(VecSafe(v))),
            title,
            thumbnail: self.thumbnail,
            transliterated_title: self.transliterated_title,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_builder_success() {
        let item = EphemeraFolderBuilder::new()
            .id("test-id".to_string())
            .title(vec!["test title".to_string()])
            .alternative(vec!["alt title".to_string()])
            .creator(vec!["jessy".to_string()])
            .provenance("Test name".to_string())
            .publisher(vec!["Princeton Press".to_string()])
            .build();

        assert!(item.is_ok());
        let item = item.unwrap();
        assert_eq!(item.id, "test-id");
        assert_eq!(item.title, vec!["test title"]);
        assert_eq!(item.alternative, Some(vec!["alt title".to_string()]));
        assert_eq!(item.creator, Some(vec!["jessy".to_string()]));
        assert_eq!(item.provenance, Some("Test name".to_string()));
        assert_eq!(item.publisher, Some(vec!["Princeton Press".to_string()]));
    }

    #[test]
    fn test_builder_missing_required_fields() {
        let item = EphemeraFolderBuilder::new()
            .id("test-id".to_string())
            .build();

        assert!(item.is_err());
        assert_eq!(item.unwrap_err(), "title is required");
    }

    #[test]
    fn it_has_a_contributor() {
        let item = EphemeraFolderBuilder::new()
            .id("test-id".to_string())
            .title(vec!["test title".to_string()])
            .contributor(vec!["Eric".to_string()])
            .build();

        assert!(item.is_ok());
        let item = item.unwrap();
        assert_eq!(item.id, "test-id");
        assert_eq!(item.title, vec!["test title"]);
        assert_eq!(item.contributor, Some(vec!["Eric".to_string()]));
    }
}

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	}

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

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

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