def test_jobs_json_author_can_edit_but_random_user_cant(
mock_current_user, inspire_app, datadir
):
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
user_orcid = "0000-0002-9127-1687"
current_oauthclient.signup_handlers["orcid"] = {"view": True}
jobs_author = create_user(role="user", orcid=user_orcid, allow_push=True)
mock_current_user.return_value = jobs_author
data = json.loads((datadir / "955427.json").read_text())
record = create_record("job", data=data)
record_control_number = record["control_number"]
expected_status_code = 200
expected_result = deepcopy(record)
expected_result["can_edit"] = True
with inspire_app.test_client() as client:
response = client.get(f"/jobs/{record_control_number}", headers=headers)
response_status_code = response.status_code
response_data_metadata = json.loads(response.data)["metadata"]
assert expected_status_code == response_status_code
assert expected_result == response_data_metadata
random_user = create_user(email="*****@*****.**", orcid="not_valid")
mock_current_user.return_value = random_user
response = client.get(f"/jobs/{record_control_number}", headers=headers)
response_data_metadata = json.loads(response.data)["metadata"]
assert not response_data_metadata["can_edit"]
def test_jobs_json_author_can_edit_but_random_user_cant(inspire_app, datadir):
headers = {"Accept": "application/json"}
data = json.loads((datadir / "955427.json").read_text())
record = create_record("job", data=data)
record_control_number = record["control_number"]
expected_status_code = 200
expected_result = deepcopy(record)
expected_result["can_edit"] = True
jobs_author = create_user(email="*****@*****.**")
with inspire_app.test_client() as client:
login_user_via_session(client, email=jobs_author.email)
response = client.get(f"/jobs/{record_control_number}",
headers=headers)
response_status_code = response.status_code
response_data_metadata = json.loads(response.data)["metadata"]
assert expected_status_code == response_status_code
assert expected_result == response_data_metadata
logout(client)
random_user = create_user(email="*****@*****.**")
login_user_via_session(client, email=random_user.email)
response = client.get(f"/jobs/{record_control_number}",
headers=headers)
response_data_metadata = json.loads(response.data)["metadata"]
assert "can_edit" not in response_data_metadata
def test_get_current_user_data_for_user_with_profile(mock_current_user, inspire_app):
orcid = "0000-0001-8829-5461"
user = create_user(
email="*****@*****.**",
role="avengers",
orcid=orcid,
allow_push=True,
)
author_profile = create_record(
"aut",
data={
"name": {"value": "Jessica Jones"},
"ids": [{"schema": "ORCID", "value": orcid}],
},
)
mock_current_user.return_value = user
expected_data = {
"data": {
"email": "*****@*****.**",
"roles": ["avengers"],
"orcid": "0000-0001-8829-5461",
"profile_control_number": str(author_profile["control_number"]),
"allow_orcid_push": True,
"recid": str(author_profile["control_number"]),
}
}
result_data = get_current_user_data()
assert expected_data == result_data
def test_literature_cataloger_facets(inspire_app):
user = create_user(role=Roles.cataloger.value)
create_record("lit")
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get("/literature/facets")
response_data = orjson.loads(response.data)
response_status_code = response.status_code
response_data_facet_keys = list(response_data.get("aggregations").keys())
expected_status_code = 200
expected_facet_keys = sorted([
"arxiv_categories",
"author",
"author_count",
"doc_type",
"earliest_date",
"subject",
"collaboration",
"collection",
"curation_collection",
"rpp",
])
response_data_facet_keys.sort()
assert expected_status_code == response_status_code
assert expected_facet_keys == response_data_facet_keys
assert len(response_data["hits"]["hits"]) == 0
def test_assign_conference_view_missing_parameters(inspire_app):
cataloger = create_user(role=Roles.cataloger.value)
literature1 = create_record("lit")
literature2 = create_record("lit")
conference = create_record("con", data={"cnum": "C20-03-01"})
expected_status_code = 422
with inspire_app.test_client() as client:
login_user_via_session(client, email=cataloger.email)
response = client.post(
"/assign/conference",
data=orjson.dumps({
"literature_recids": [
literature1.control_number,
literature2.control_number,
],
}),
content_type="application/json",
)
assert response.status_code == expected_status_code
response = client.post(
"/assign/conference",
data=orjson.dumps({
"conference_recid": conference.control_number,
}),
content_type="application/json",
)
assert response.status_code == expected_status_code
def test_seminars_json_with_logged_in_cataloger(inspire_app, datadir):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = json.loads((datadir / "1.json").read_text())
record = create_record("sem", data=data)
record_control_number = record["control_number"]
expected_metadata = SeminarsAdminSchema().dump(record).data
expected_created = utils.isoformat(record.created)
expected_updated = utils.isoformat(record.updated)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/seminars/{record_control_number}",
headers=headers)
response_data = json.loads(response.data)
response_data_metadata = response_data["metadata"]
response_created = response_data["created"]
response_updated = response_data["updated"]
assert expected_metadata == response_data_metadata
assert expected_created == response_created
assert expected_updated == response_updated
def test_refextract_text_dedupe_references(mock_refs, inspire_app):
schema = load_schema("hep")
subschema = schema["properties"]["references"]
user = create_user(role=Roles.cataloger.value)
data = {
"journal_title": {
"title": "Journal of Testing"
},
"short_title": "J.Testing",
}
create_record("jou", data=data)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.post(
"api/editor/refextract/text",
content_type="application/json",
data=orjson.dumps(
{"text": "John Smith, Journal of Testing 42 (2020) 1234"}),
)
references = orjson.loads(response.data)
assert response.status_code == 200
assert validate(references, subschema) is None
assert len(references) == 1
def test_create_rt_ticket_returns_500_on_error(mock_tickets, inspire_app):
mock_tickets.create_ticket.return_value = -1
mock_tickets.get_rt_link_for_ticket.return_value = "http://rt_address"
user = create_user(role=Roles.cataloger.value)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.post(
"api/editor/literature/1497201/rt/tickets/create",
content_type="application/json",
data=orjson.dumps({
"description": "description",
"owner": "owner",
"queue": "queue",
"recid": "4328",
"subject": "subject",
}),
)
assert response.status_code == 500
expected = {"success": False}
result = orjson.loads(response.data)
assert expected == result
def test_experiments_json_with_loggedin_cataloger(inspire_app, datadir):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = orjson.loads((datadir / "1108739.json").read_text())
record = create_record_factory("exp", data=data)
record_control_number = record.json["control_number"]
expected_metadata = deepcopy(record.json)
expected_metadata["number_of_papers"] = 0
expected_created = utils.isoformat(record.created)
expected_updated = utils.isoformat(record.updated)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/experiments/{record_control_number}",
headers=headers)
response_data = orjson.loads(response.data)
response_data_metadata = response_data["metadata"]
response_created = response_data["created"]
response_updated = response_data["updated"]
assert expected_metadata == response_data_metadata
assert expected_created == response_created
assert expected_updated == response_updated
def test_jobs_json_author_cannot_edit_if_is_closed_and_more_than_30_days_after_deadline(
mock_current_user, inspire_app, datadir
):
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
data = json.loads((datadir / "955427.json").read_text())
data["deadline_date"] = "2019-06-01"
data["status"] = "closed"
record = create_record("job", data=data)
record_control_number = record["control_number"]
expected_status_code = 200
expected_result = deepcopy(record)
expected_result["can_edit"] = False
user_orcid = "0000-0002-9127-1687"
current_oauthclient.signup_handlers["orcid"] = {"view": True}
jobs_author = create_user(role="user", orcid=user_orcid, allow_push=True)
mock_current_user.return_value = jobs_author
with inspire_app.test_client() as client:
response = client.get(f"/jobs/{record_control_number}", headers=headers)
response_status_code = response.status_code
response_data_metadata = json.loads(response.data)["metadata"]
assert expected_status_code == response_status_code
assert expected_result == response_data_metadata
def test_jobs_json_author_can_edit_if_closed_and_less_than_30_days_after_deadline(
inspire_app, datadir
):
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
data = json.loads((datadir / "955427.json").read_text())
data["deadline_date"] = "2020-01-15"
data["status"] = "closed"
record = create_record("job", data=data)
record_control_number = record["control_number"]
expected_status_code = 200
expected_result = deepcopy(record)
expected_result["can_edit"] = True
jobs_author = create_user(email="*****@*****.**", orcid="0000-0002-9127-1687")
with inspire_app.test_client() as client:
login_user_via_session(client, email=jobs_author.email)
response = client.get(f"/jobs/{record_control_number}", headers=headers)
response_status_code = response.status_code
response_data_metadata = json.loads(response.data)["metadata"]
assert expected_status_code == response_status_code
assert expected_result == response_data_metadata
def test_jobs_search_json_can_edit(inspire_app):
headers = {"Accept": "application/json"}
user = create_user(email="*****@*****.**")
create_record("job",
data={
"status": "open",
"acquisition_source": {
"email": "*****@*****.**"
}
})
create_record("job",
data={
"status": "open",
"acquisition_source": {
"email": "*****@*****.**"
}
})
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get("/jobs", headers=headers)
hits = response.json["hits"]["hits"]
own_job_metadata = next(
hit["metadata"] for hit in hits
if hit["metadata"]["acquisition_source"]["email"] == user.email)
another_job_metadata = next(
hit["metadata"] for hit in hits
if hit["metadata"]["acquisition_source"]["email"] != user.email)
assert "can_edit" not in another_job_metadata
assert own_job_metadata["can_edit"]
def test_jobs_json_author_cannot_edit_if_is_closed_and_more_than_30_days_after_deadline(
inspire_app, datadir):
headers = {"Accept": "application/json"}
data = json.loads((datadir / "955427.json").read_text())
data["deadline_date"] = "2019-06-01"
data["status"] = "closed"
record = create_record("job", data=data)
record_control_number = record["control_number"]
expected_status_code = 200
expected_result = deepcopy(record)
jobs_author = create_user(email="*****@*****.**")
with inspire_app.test_client() as client:
login_user_via_session(client, email=jobs_author.email)
response = client.get(f"/jobs/{record_control_number}",
headers=headers)
response_status_code = response.status_code
response_data_metadata = json.loads(response.data)["metadata"]
assert expected_status_code == response_status_code
assert expected_result == response_data_metadata
assert "can_edit" not in response_data_metadata
def test_author_detail_page_contains_acquisition_source_for_curator(
inspire_app):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = {
"$schema": "https://inspire/schemas/records/authors.json",
"_collections": ["Authors"],
"_private_notes": [{
"value": "A private note"
}],
"acquisition_source": {
"orcid": "0000-0000-0000-0000",
"email": "*****@*****.**"
},
"name": {
"value": "Urhan, Harun"
},
"deleted": False,
}
record = create_record("aut", data=data)
record_control_number = record["control_number"]
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/authors/{record_control_number}",
headers=headers)
assert response.status_code == 200
assert "acquisition_source" in response.json["metadata"]
def test_get_linked_refs_bad_request(inspire_app):
user = create_user()
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get("api/matcher/linked_references/")
assert response.status_code == 405
def test_add_keyword_returns_validation_error(inspire_app):
user = create_user(role=Roles.cataloger.value)
record = create_record(
"lit",
data={
"_desy_bookkeeping": [
{"date": "2017-10-16", "expert": "3", "status": "printed"}
]
},
)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.put(
f"/curation/literature/{record['control_number']}/keywords",
content_type="application/json",
data=orjson.dumps(
{
"_desy_bookkeeping": {
"date": "2017-10-16",
"expert": "3",
"status": "printed",
}
}
),
)
assert response.status_code == 400
assert "has non-unique elements" in response.json["message"]
def test_add_keywords_updated_desy_bookkeeping(inspire_app):
user = create_user(role=Roles.cataloger.value)
record = create_record(
"lit",
data={
"_desy_bookkeeping": [
{"date": "2017-10-16", "expert": "3", "status": "printed"}
]
},
)
expected_desy_bookkeeping_value = [
{"date": "2017-10-16", "expert": "3", "status": "printed"},
{"identifier": "DA17-kp43aa"},
]
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.put(
f"/curation/literature/{record['control_number']}/keywords",
content_type="application/json",
data=orjson.dumps({"_desy_bookkeeping": {"identifier": "DA17-kp43aa"}}),
)
updated_record = LiteratureRecord.get_record_by_pid_value(record["control_number"])
assert response.status_code == 200
assert updated_record["_desy_bookkeeping"] == expected_desy_bookkeeping_value
def test_jobs_search_json_can_edit(mock_current_user, inspire_app):
headers = {"Accept": "application/vnd+inspire.record.ui+json"}
user_orcid = "0000-0002-9127-1687"
create_record(
"job", data={"status": "open", "acquisition_source": {"orcid": user_orcid}}
)
create_record(
"job",
data={"status": "open", "acquisition_source": {"orcid": "0100-0002-9127-1687"}},
)
user_orcid = "0000-0002-9127-1687"
current_oauthclient.signup_handlers["orcid"] = {"view": True}
jobs_author = create_user(role="user", orcid=user_orcid, allow_push=True)
mock_current_user.return_value = jobs_author
with inspire_app.test_client() as client:
response = client.get(f"/jobs/", headers=headers)
hits = response.json["hits"]["hits"]
own_job_metadata = next(
hit["metadata"]
for hit in hits
if hit["metadata"]["acquisition_source"]["orcid"] == user_orcid
)
another_job_metadata = next(
hit["metadata"]
for hit in hits
if hit["metadata"]["acquisition_source"]["orcid"] != user_orcid
)
assert not another_job_metadata["can_edit"]
assert own_job_metadata["can_edit"]
def test_refextract_text(inspire_app):
schema = load_schema("hep")
subschema = schema["properties"]["references"]
user = create_user(role=Roles.cataloger.value)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.post(
"api/editor/refextract/text",
content_type="application/json",
data=json.dumps({
"text":
("J. M. Maldacena. “The Large N Limit of Superconformal Field "
"Theories and Supergravity”. Adv. Theor. Math. Phys. 2 (1998), "
"pp. 231–252."),
}),
)
references = json.loads(response.data)
assert response.status_code == 200
assert validate(references, subschema) is None
assert get_value(
{"references": references},
"references.reference.publication_info.journal_title",
)
def test_literature_workflows_record_source_get_record_happy_flow(inspire_app):
superuser = create_user(role="superuser")
record = create_record("lit")
source = "arxiv"
with inspire_app.test_client() as client:
login_user_via_session(client, email=superuser.email)
data = {
"record_uuid": str(record.id),
"source": source,
"json": dict(record)
}
response = client.post(
"/api/literature/workflows_record_sources",
content_type="application/json",
data=orjson.dumps(data),
)
assert response.status_code == 200
assert len(WorkflowsRecordSources.query.all()) == 1
# get record
response = client.get(
"/api/literature/workflows_record_sources",
content_type="application/json",
data=orjson.dumps({
"record_uuid": str(record.id),
"source": source,
}),
)
assert response.status_code == 200
assert "workflow_sources" in response.json
assert len(response.json["workflow_sources"]) == 1
assert "created" in response.json["workflow_sources"][0]
assert "updated" in response.json["workflow_sources"][0]
def test_authorlist_text_exception(inspire_app):
user = create_user(role=Roles.cataloger.value)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.post(
"/editor/authorlist/text",
content_type="application/json",
data=orjson.dumps({
"text": ("F. Lastname1, F.M. Otherlastname1,2\n"
"\n"
"CERN\n"
"2 Otheraffiliation")
}),
)
assert response.status_code == 400
expected = {
"message":
"Cannot identify type of affiliations, found IDs: ['C', '2']",
"status": 400,
}
result = orjson.loads(response.data)
assert expected == result
def test_does_not_update_stale(inspire_app):
cataloger = create_user(role="cataloger")
record = create_record("con")
record_control_number = record["control_number"]
with inspire_app.test_client() as client:
login_user_via_session(client, email=cataloger.email)
get_response = client.get(f"/conferences/{record_control_number}")
etag = get_response.headers["ETag"]
first_put_response = client.put(
"/conferences/{}".format(record_control_number),
content_type="application/json",
data=orjson.dumps(
faker.record("con",
data={"control_number": record_control_number})),
headers={"If-Match": etag},
)
assert first_put_response.status_code == 200
stale_put_response = client.put(
f"/conferences/{record_control_number}",
content_type="application/json",
data=orjson.dumps(
faker.record("con",
data={"control_number": record_control_number})),
headers={"If-Match": etag},
)
assert stale_put_response.status_code == 412
def test_seminars_logged_in_search_json(inspire_app, datadir):
with inspire_app.test_client() as client:
user = create_user(role=Roles.cataloger.value)
login_user_via_session(client, email=user.email)
headers = {"Accept": "application/json"}
data = json.loads((datadir / "1.json").read_text())
record = create_record("sem", data=data)
expected_result = SeminarsAdminSchema().dump(record).data
expected_created = utils.isoformat(record.created)
expected_updated = utils.isoformat(record.updated)
response = client.get("/seminars", headers=headers)
response_data_hit = response.json["hits"]["hits"][0]
response_created = response_data_hit["created"]
response_updated = response_data_hit["updated"]
response_metadata = response_data_hit["metadata"]
assert expected_result == response_metadata
assert expected_created == response_created
assert expected_updated == response_updated
def test_get_returns_the_records_in_descending_order_by_last_updated(
inspire_app, datadir):
user = create_user(role=Roles.cataloger.value)
data = (datadir / "1674997.xml").read_bytes()
LegacyRecordsMirrorFactory(
recid=1674997,
_marcxml=data,
collection="HEP",
_errors="Error: Least recent error.",
valid=False,
)
data = (datadir / "1674989.xml").read_bytes()
LegacyRecordsMirrorFactory(
recid=1674989,
_marcxml=data,
collection="HEP",
_errors="Error: Middle error.",
valid=False,
)
data = (datadir / "1674987.xml").read_bytes()
LegacyRecordsMirrorFactory(
_marcxml=data,
recid=1674987,
collection="HEP",
_errors="Error: Most recent error.",
valid=False,
)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get("/migrator/errors",
content_type="application/json")
expected_data = {
"data": [
{
"recid": 1674987,
"collection": "HEP",
"valid": False,
"error": "Error: Most recent error.",
},
{
"recid": 1674989,
"collection": "HEP",
"valid": False,
"error": "Error: Middle error.",
},
{
"recid": 1674997,
"collection": "HEP",
"valid": False,
"error": "Error: Least recent error.",
},
]
}
response_data = json.loads(response.data)
assert response.status_code == 200
assert expected_data == response_data
def test_institutions_json_with_logged_in_cataloger(inspire_app, datadir):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = json.loads((datadir / "903324.json").read_text())
record = create_record("ins", data=data)
record_control_number = record["control_number"]
expected_metadata = deepcopy(record)
expected_metadata["addresses"][0]["country"] = "Austria"
expected_metadata["number_of_papers"] = 0
expected_created = utils.isoformat(record.created)
expected_updated = utils.isoformat(record.updated)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/institutions/{record_control_number}",
headers=headers)
response_data = json.loads(response.data)
response_data_metadata = response_data["metadata"]
response_created = response_data["created"]
response_updated = response_data["updated"]
assert expected_metadata == response_data_metadata
assert expected_created == response_created
assert expected_updated == response_updated
def test_sign_up_user_success(mock_current_user, inspire_app):
"""It's mocking current user because invenio handlers need a lot of things to
setup in order to make it properly work and we don't want to test this functinality."""
def return_true():
return True
previous_current_oauthclient_signup_handlers = current_oauthclient.signup_handlers
current_oauthclient.signup_handlers["orcid"] = {"view": return_true}
user = create_user(role="user",
orcid="0000-0001-8829-5461",
allow_push=True)
mock_current_user.return_value = user
with inspire_app.test_client() as client:
response = client.post(
"/accounts/signup",
data=orjson.dumps({"email": user.email}),
content_type="application/json",
)
current_oauthclient.signup_handlers = previous_current_oauthclient_signup_handlers
expected_data = {
"data": {
"email": user.email,
"roles": ["user"],
"orcid": "0000-0001-8829-5461",
"profile_control_number": None,
"allow_orcid_push": True,
}
}
expected_status = 200
assert expected_status == response.status_code
assert expected_data == response.json
def test_literature_export_to_cds_view(inspire_app):
cataloger = create_user(role=Roles.cataloger.value)
literature1 = create_record("lit")
literature2 = create_record(
"lit", data={"_export_to": {
"CDS": False,
"HAL": False
}})
expected_status_code = 200
with inspire_app.test_client() as client:
login_user_via_session(client, email=cataloger.email)
response = client.post(
"/assign/export-to-cds",
data=orjson.dumps({
"literature_recids": [
literature1.control_number,
literature2.control_number,
]
}),
content_type="application/json",
)
response_status_code = response.status_code
assert response_status_code == expected_status_code
literature1 = LiteratureRecord.get_record_by_pid_value(
literature1.control_number)
literature2 = LiteratureRecord.get_record_by_pid_value(
literature2.control_number)
assert literature1["_export_to"] == {"CDS": True}
assert literature2["_export_to"] == {"CDS": True, "HAL": False}
def test_add_keywords_raise_error_when_desy_bookkeeping_in_wrong_format(inspire_app):
user = create_user(role=Roles.cataloger.value)
record = create_record("lit")
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.put(
f"/curation/literature/{record['control_number']}/keywords",
content_type="application/json",
data=orjson.dumps(
{"_desy_bookkeeping": [{"value": "Test", "source": "curation"}]}
),
)
assert response.status_code == 400
assert (
response.json["message"] == "Incorrect input type for fields: _desy_bookkeeping"
)
def test_add_keywords_raise_error_when_energy_ranges_in_wrong_format(inspire_app):
user = create_user(role=Roles.cataloger.value)
record = create_record("lit")
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.put(
f"/curation/literature/{record['control_number']}/keywords",
content_type="application/json",
data=orjson.dumps(
{"energy_ranges": [{"value": "Test", "source": "curation"}]}
),
)
assert response.status_code == 400
assert (
response.json["message"] == "Incorrect input type for fields: energy_ranges"
)
def test_literature_search_permissions(inspire_app):
create_record("lit", data={"_collections": ["Fermilab"]})
rec_literature = create_record("lit",
data={"_collections": ["Literature"]})
with inspire_app.test_client() as client:
response = client.get("/literature")
response_data = orjson.loads(response.data)
assert response_data["hits"]["total"] == 1
assert (response_data["hits"]["hits"][0]["metadata"]["control_number"] ==
rec_literature["control_number"])
user = create_user(role=Roles.cataloger.value)
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get("/literature")
response_data = orjson.loads(response.data)
assert response_data["hits"]["total"] == 2
logout(client)
response = client.get("/literature")
response_data = orjson.loads(response.data)
assert response_data["hits"]["total"] == 1
assert (response_data["hits"]["hits"][0]["metadata"]["control_number"] ==
rec_literature["control_number"])
def test_conferences_json_with_logged_in_cataloger(inspire_app):
user = create_user(role=Roles.cataloger.value)
headers = {"Accept": "application/json"}
data = {
"$schema": "https://inspire/schemas/records/conferences.json",
"_collections": ["Conferences"],
"_private_notes": [{"value": "A private note"}],
"titles": [{"title": "Great conference for HEP"}],
"control_number": 1,
}
record = create_record("con", data=data)
record_control_number = record["control_number"]
expected_metadata = {
"$schema": "https://inspire/schemas/records/conferences.json",
"_collections": ["Conferences"],
"_private_notes": [{"value": "A private note"}],
"control_number": 1,
"titles": [{"title": "Great conference for HEP"}],
"number_of_contributions": 0,
"self": {"$ref": "http://localhost:5000/api/conferences/1"},
}
with inspire_app.test_client() as client:
login_user_via_session(client, email=user.email)
response = client.get(f"/conferences/{record_control_number}", headers=headers)
response_data = json.loads(response.data)
response_data_metadata = response_data["metadata"]
assert expected_metadata == response_data_metadata
