def test_search_references(client, fragmentarium, bibliography, user):
bib_entry_1 = BibliographyEntryFactory.build(id="RN.0", pages="254")
bib_entry_2 = BibliographyEntryFactory.build(id="RN.1")
bibliography.create(bib_entry_1, user)
bibliography.create(bib_entry_2, user)
fragment = FragmentFactory.build(references=(
ReferenceFactory.build(id="RN.0", pages="254"),
ReferenceFactory.build(id="RN.1"),
))
fragmentarium.create(fragment)
result = client.simulate_get(
"/fragments",
params={
"id": fragment.references[0].id,
"pages": fragment.references[0].pages
},
)
assert result.status == falcon.HTTP_OK
fragment_expected = fragment.set_references([
fragment.references[0].set_document(bib_entry_1),
fragment.references[1].set_document(bib_entry_2),
])
assert result.json == ApiFragmentInfoSchema(many=True).dump(
[FragmentInfo.of(fragment_expected)])
assert "Cache-Control" not in result.headers
def test_inject_document_in_fragment_infos(fragment_finder, when,
bibliography):
bibliography_entry = BibliographyEntryFactory.build()
fragment_1 = FragmentInfo.of(
FragmentFactory.build(
number="K.1", references=(ReferenceFactory.build(id="RN.0"), )))
fragment_2 = FragmentInfo.of(
FragmentFactory.build(
number="K.2",
references=(
ReferenceFactory.build(id="RN.1"),
ReferenceFactory.build(id="RN.2"),
),
))
fragment_expected_1 = fragment_1.set_references(
[fragment_1.references[0].set_document(bibliography_entry)])
fragment_expected_2 = fragment_2.set_references([
fragment_2.references[0].set_document(bibliography_entry),
fragment_2.references[1].set_document(bibliography_entry),
])
(when(fragment_finder).search_references("id", "pages").thenReturn(
[fragment_1, fragment_2]))
(when(bibliography).find("RN.0").thenReturn(bibliography_entry))
(when(bibliography).find("RN.1").thenReturn(bibliography_entry))
(when(bibliography).find("RN.2").thenReturn(bibliography_entry))
assert fragment_finder.search_references_in_fragment_infos(
"id", "pages") == [
fragment_expected_1,
fragment_expected_2,
]
def test_create(database, bibliography_repository, create_mongo_bibliography_entry):
bibliography_entry = BibliographyEntryFactory.build()
bibliography_repository.create(bibliography_entry)
assert (
database[COLLECTION].find_one({"_id": bibliography_entry["id"]})
== create_mongo_bibliography_entry()
)
def test_to_dict() -> None:
bibliography_entry = BibliographyEntryFactory.build()
reference_with_document = create_reference_with_document(bibliography_entry)
assert ReferenceSchema().dump(reference_with_document) == {
**SERIALIZED_REFERENCE,
"id": reference_with_document.id,
}
def test_create_entry_invalid(transform, client):
bibliography_entry = BibliographyEntryFactory.build()
invalid_entry = transform(bibliography_entry)
body = json.dumps(invalid_entry)
put_result = client.simulate_post("/bibliography", body=body)
assert put_result.status == falcon.HTTP_BAD_REQUEST
def test_update_entry_not_found(client):
bibliography_entry = BibliographyEntryFactory.build()
id_ = bibliography_entry["id"]
body = json.dumps(bibliography_entry)
post_result = client.simulate_post(f"/bibliography/{id_}", body=body)
assert post_result.status == falcon.HTTP_NOT_FOUND
def test_find(database, bibliography_repository, create_mongo_bibliography_entry):
bibliography_entry = BibliographyEntryFactory.build()
mongo_entry_ = create_mongo_bibliography_entry(bibliography_entry)
database[COLLECTION].insert_one(mongo_entry_)
assert (
bibliography_repository.query_by_id(bibliography_entry["id"])
== bibliography_entry
)
def test_update(bibliography_repository):
bibliography_entry = BibliographyEntryFactory.build()
updated_entry = pydash.omit({**bibliography_entry, "title": "New Title"}, "PMID")
bibliography_repository.create(bibliography_entry)
bibliography_repository.update(updated_entry)
assert (
bibliography_repository.query_by_id(bibliography_entry["id"]) == updated_entry
)
def test_reference() -> None:
bibliography_entry = BibliographyEntryFactory.build()
reference_with_document = create_reference_with_document(bibliography_entry)
assert reference_with_document.id == bibliography_entry["id"]
assert reference_with_document.type == TYPE
assert reference_with_document.pages == PAGES
assert reference_with_document.notes == NOTES
assert reference_with_document.lines_cited == LINES_CITED
assert reference_with_document.document == bibliography_entry
def test_search_author_title_year(bibliography, bibliography_repository, when):
bibliography_entry = BibliographyEntryFactory.build()
author = bibliography_entry["author"][0]["family"]
year = bibliography_entry["issued"]["date-parts"][0][0]
title = bibliography_entry["title"]
query = f"{author} {year} {title}"
(when(bibliography_repository).query_by_author_year_and_title(
author, year, title).thenReturn([bibliography_entry]))
(verify(bibliography_repository,
0).query_by_container_title_and_collection_number(
author, str(year)))
assert [bibliography_entry] == bibliography.search(query)
def test_from_dict_with_document() -> None:
bibliography_entry = BibliographyEntryFactory.build()
reference_with_document = create_reference_with_document(bibliography_entry)
result = ReferenceSchema().load(
{
**SERIALIZED_REFERENCE,
"id": reference_with_document.id,
"document": bibliography_entry,
}
)
assert result == reference_with_document
def test_create_entry(client):
bibliography_entry = BibliographyEntryFactory.build()
id_ = bibliography_entry["id"]
body = json.dumps(bibliography_entry)
post_result = client.simulate_post("/bibliography", body=body)
assert post_result.status == falcon.HTTP_CREATED
assert post_result.headers["Location"] == f"/bibliography/{id_}"
assert post_result.json == bibliography_entry
get_result = client.simulate_get(f"/bibliography/{id_}")
assert get_result.json == bibliography_entry
def test_search_container_short_collection_number(bibliography,
bibliography_repository,
when):
bibliography_entry = BibliographyEntryFactory.build()
container_title = bibliography_entry["container-title-short"]
collection_number = bibliography_entry["collection-number"]
query = f"{container_title} {collection_number}"
(when(bibliography_repository).query_by_author_year_and_title(
container_title, int(collection_number), None).thenReturn([]))
(when(bibliography_repository
).query_by_container_title_and_collection_number(
container_title,
collection_number).thenReturn([bibliography_entry]))
assert [bibliography_entry] == bibliography.search(query)
def test_update(
bibliography,
bibliography_repository,
user,
when,
changelog,
create_mongo_bibliography_entry,
):
bibliography_entry = BibliographyEntryFactory.build()
(when(bibliography_repository).query_by_id(
bibliography_entry["id"]).thenReturn(bibliography_entry))
(when(changelog).create(
COLLECTION,
user.profile,
create_mongo_bibliography_entry(),
create_mongo_bibliography_entry(),
).thenReturn())
(when(bibliography_repository).update(bibliography_entry).thenReturn())
bibliography.update(bibliography_entry, user)
def test_create(
bibliography,
bibliography_repository,
user,
changelog,
when,
create_mongo_bibliography_entry,
):
bibliography_entry = BibliographyEntryFactory.build()
(when(changelog).create(
COLLECTION,
user.profile,
{
"_id": bibliography_entry["id"]
},
create_mongo_bibliography_entry(),
).thenReturn())
(when(bibliography_repository).create(bibliography_entry).thenReturn())
bibliography.create(bibliography_entry, user)
def test_create_duplicate(
bibliography,
user,
when,
changelog,
bibliography_repository,
create_mongo_bibliography_entry,
):
bibliography_entry = BibliographyEntryFactory.build()
(when(changelog).create(
COLLECTION,
user.profile,
{
"_id": bibliography_entry["id"]
},
create_mongo_bibliography_entry(),
).thenReturn())
(when(bibliography_repository).create(bibliography_entry).thenRaise(
DuplicateError))
with pytest.raises(DuplicateError):
bibliography.create(bibliography_entry, user)
def test_entry_not_found(bibliography, bibliography_repository, when):
bibliography_entry = BibliographyEntryFactory.build()
(when(bibliography_repository).query_by_id(
bibliography_entry["id"]).thenRaise(NotFoundError))
with pytest.raises(NotFoundError):
bibliography.find(bibliography_entry["id"])
def test_update_not_found(bibliography_repository):
bibliography_entry = BibliographyEntryFactory.build()
with pytest.raises(NotFoundError):
bibliography_repository.update(bibliography_entry)
def _from_bibliography_entry(
bibliography_entry: Union[dict, None] = None) -> dict:
if not bibliography_entry:
bibliography_entry = BibliographyEntryFactory.build()
return pydash.map_keys(bibliography_entry, lambda _, key: "_id"
if key == "id" else key)
def test_create_duplicate(bibliography_repository):
bibliography_entry = BibliographyEntryFactory.build()
bibliography_repository.create(bibliography_entry)
with pytest.raises(DuplicateError):
bibliography_repository.create(bibliography_entry)
def saved_entry(bibliography, user):
bibliography_entry = BibliographyEntryFactory.build()
bibliography.create(bibliography_entry, user)
return bibliography_entry
def test_find(bibliography, bibliography_repository, when):
bibliography_entry = BibliographyEntryFactory.build()
(when(bibliography_repository).query_by_id(
bibliography_entry["id"]).thenReturn(bibliography_entry))
assert bibliography.find(bibliography_entry["id"]) == bibliography_entry