def test_document_person_resolve(mock_resolver_get, mock_listener_get,
es_clear, db, document_ref,
mef_person_response_data):
"""Test document person resolve"""
mock_resolver_get.return_value = mock_response(
json_data=mef_person_response_data
)
mock_listener_get.return_value = mock_response(
json_data=mef_person_response_data
)
assert document_ref.replace_refs()[
'authors'
][0]['pid'] == mef_person_response_data['id']
count = MefPersonsSearch().filter(
'match',
id=mef_person_response_data['id']
).execute().hits.total
assert count == 1
document_ref.update(document_ref)
document_ref.delete()
count = MefPersonsSearch().filter(
'match',
id=mef_person_response_data['id']
).execute().hits.total
assert count == 0
def test_replace_idby_subjects(mock_contributions_mef_get, app, document_data,
contribution_person_response_data):
"""Test replace identifiedBy in subjects."""
assert replace_idby_subjects() == (0, 0, 0, 0, 0)
doc = Document.create(data=document_data, dbcommit=True, reindex=True)
DocumentsSearch.flush_and_refresh()
replace = ReplaceMefIdentifiedBySubjects()
replace.process()
assert replace.counts_len == (0, 0, 0, 0, 1)
without_idref_gnd = deepcopy(contribution_person_response_data)
without_idref_gnd['hits']['hits'][0]['metadata'].pop('idref')
without_idref_gnd['hits']['hits'][0]['metadata'].pop('gnd')
mock_contributions_mef_get.return_value = mock_response(
json_data=without_idref_gnd)
assert replace_idby_subjects() == (0, 0, 0, 1, 0)
without_idref_gnd = deepcopy(contribution_person_response_data)
without_idref_gnd['hits']['hits'][0]['metadata']['deleted'] = '2022'
mock_contributions_mef_get.return_value = mock_response(
json_data=without_idref_gnd)
assert replace_idby_subjects() == (0, 0, 1, 0, 0)
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
assert replace_idby_subjects() == (1, 0, 0, 0, 0)
# clean up
doc.delete(dbcommit=True, delindex=True, force=True)
for id in Contribution.get_all_ids():
cont = Contribution.get_record_by_id(id)
cont.delete(dbcommit=True, delindex=True, force=True)
def test_get_mef_person_link(mock_get, capsys):
"""Test get mef person link"""
mock_get.return_value = mock_response(
json_data={'hits': {
'hits': [{
'links': {
'self': 'mocked_url'
}
}]
}})
mef_url = get_mef_person_link(id='(RERO)A003945843',
key='100..',
value={'0': '(RERO)A003945843'})
assert mef_url == 'mocked_url'
os.environ['RERO_ILS_MEF_HOST'] = 'mefdev.test.rero.ch'
mef_url = get_mef_person_link(id='(RERO)A003945843',
key='100..',
value={'0': '(RERO)A003945843'})
assert mef_url == 'mocked_url'
mock_get.return_value = mock_response(status=400)
mef_url = get_mef_person_link(id='(RERO)AXXXXXXXXX',
key='100..',
value={'0': '(RERO)AAXXXXXXXXX'})
assert not mef_url
out, err = capsys.readouterr()
assert err == 'ERROR: MEF request ' +\
'https://mefdev.test.rero.ch/api/mef/?q=rero.pid:AXXXXXXXXX 400\n'
def document_ref(mock_resolver_get, mock_listener_get, app, document_data_ref,
mef_person_response_data):
"""Load document with mef records reference."""
mock_resolver_get.return_value = mock_response(
json_data=mef_person_response_data)
mock_listener_get.return_value = mock_response(
json_data=mef_person_response_data)
doc = Document.create(data=document_data_ref,
delete_pid=False,
dbcommit=True,
reindex=True)
flush_index(DocumentsSearch.Meta.index)
return doc
def test_get_remote_cover(mock_get_cover, app):
"""Test get remote cover."""
mock_get_cover.return_value = mock_response(status=400)
assert get_remote_cover('YYYYYYYYY') is None
mock_get_cover.return_value = mock_response(
content='thumb({'
' "success": true,'
' "image": "https://i.test.com/images/P/XXXXXXXXXX_.jpg"'
'})')
cover = get_remote_cover('XXXXXXXXXX')
assert cover == {
'success': True,
'image': 'https://i.test.com/images/P/XXXXXXXXXX_.jpg'
}
def test_crawler_list_parse():
request = ListRequest(
session_id='somesession',
url='mocked',
city_code='sfbay',
)
items = crawler.extract_items(
mock_response(
'data/list.html',
request_instance=request,
),
)
next_list_requests = []
for item in items:
assert item.city_code == request.city_code
assert item.session_id == request.session_id
if isinstance(item, ListRequest):
next_list_requests.append(item)
else:
assert isinstance(item, ItemRequest)
assert len(next_list_requests) == 1
assert next_list_requests[0].page_number == 1
def test_create(mock_contributions_mef_get, app, script_info,
contribution_person_response_data):
"""Test create cli."""
json_file_name = join(dirname(__file__), '../data/documents.json')
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
runner = CliRunner()
result = runner.invoke(create, [
json_file_name, '--pid_type', 'doc', '--append', '--reindex',
'--dbcommit', '--verbose', '--debug', '--lazy', '--dont-stop'
],
obj=script_info)
# assert result.exit_code == 0
assert result.output.strip().split('\n')[1:] == [
'DB commit: 2', 'Append fixtures new identifiers: 2',
'DB commit append: 2'
]
runner = CliRunner()
result = runner.invoke(create, [
json_file_name, '--pid_type', 'doc', '--append', '--reindex',
'--dbcommit', '--verbose', '--debug', '--lazy', '--dont-stop',
'--create_or_update'
],
obj=script_info)
# assert result.exit_code == 0
assert result.output.strip().split('\n')[1:] == [
'DB commit: 2', 'Append fixtures new identifiers: 0',
'DB commit append: 0'
]
def test_mef_persons_detailed_view(mock_get, client, mef_person_data):
"""."""
json_data = {'metadata': mef_person_data}
mock_get.return_value = mock_response(json_data=json_data)
# check redirection
res = client.get(url_for('mef_persons.persons_detailed_view', pid='pers1'))
assert res.status_code == 200
def test_crawler_list_parse():
request = ListRequest(
session_id='somesession',
url='mocked',
city_code='sfbay',
)
items = crawler.extract_items(
mock_response(
'data/list.html',
request_instance=request,
), )
next_list_requests = []
for item in items:
assert item.city_code == request.city_code
assert item.session_id == request.session_id
if isinstance(item, ListRequest):
next_list_requests.append(item)
else:
assert isinstance(item, ItemRequest)
assert len(next_list_requests) == 1
assert next_list_requests[0].page_number == 1
def test_document_es_mapping(mock_contributions_mef_get, es, db, org_martigny,
document_data_ref, item_lib_martigny,
contribution_person_response_data):
"""Test document elasticsearch mapping."""
search = DocumentsSearch()
mapping = get_mapping(search.Meta.index)
assert mapping
data = deepcopy(document_data_ref)
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
Document.create(data, dbcommit=True, reindex=True, delete_pid=True)
assert mapping == get_mapping(search.Meta.index)
def test_api_source(mock_get, app, capsys):
"""Test api source creation update."""
msg = api_source(name='test', url='http://test.com')
assert msg == 'Added'
mock_get.return_value = mock_response(
json_data={
'hits': {
'hits': [{
'metadata': {
'pid': 'test1',
'data': 'test data 1'
}
}, {
'metadata': {
'pid': 'test2',
'data': 'test data 2'
}
}],
'total': {
'value': 2
},
'links': {
'self': 'http:/test.com'
}
}
})
harvest_records(name='test',
url='http://test.com',
signals=False,
size=1000,
max=1000)
out, err = capsys.readouterr()
assert out.strip() == 'API records found: 2'
msg = api_source(name='test', url='http://test.com', size=1000)
assert msg == 'Not Updated'
msg = api_source(name='test',
url='http://test.com',
mimetype='mimetype',
size=1000,
comment='comment',
update=True)
assert msg == ('Updated: url:http://test.com, mimetype:mimetype,'
' size:1000, comment:comment')
def test_get_all_mef_records(mock_contributions_mef_get, app, script_info,
contribution_person_response_data):
"""Test get_all_mef_records cli."""
json_file_name = join(dirname(__file__), '../data/documents.json')
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
runner = CliRunner()
result = runner.invoke(get_all_mef_records, [json_file_name, '-v'],
obj=script_info)
assert result.exit_code == 0
assert result.output.strip().split('\n')[1:] == [
'1 ref: https://mef.rero.ch/api/idref/074755978\t'
'contribution pid: cont_pers True',
'1 ref: https://mef.rero.ch/api/rero/A003683610\t'
'contribution pid: cont_pers False',
'Count refs: 2',
]
def test_person_mef_create(mock_persons_mef_get, app, person_data_tmp,
person_response_data):
"""Test MEF person creation."""
count = Person.count()
mock_persons_mef_get.return_value = mock_response(
json_data=person_response_data
)
pers_mef = Person.get_record_by_ref(
'https://mef.rero.ch/api/rero/A017671081')
flush_index(PersonsSearch.Meta.index)
assert pers_mef == person_data_tmp
assert Person.count() == count + 1
pers_mef.pop('rero')
pers_mef.pop('gnd')
pers_mef['sources'] = ['bnf']
pers_mef.replace(pers_mef, dbcommit=True)
pers_db = Person.get_record_by_ref(
'https://mef.rero.ch/api/gnd/172759757')
assert pers_db['sources'] == ['bnf']
def test_crawler_item_parse():
request = ItemRequest(
session_id='somesession',
url='mocked',
city_code='sfbay',
)
items = crawler.extract_items(
mock_response(
'data/item.html',
request_instance=request,
), )
for item in items:
print('item:', dict(item))
assert isinstance(item, CraigsListItem)
assert item.url == request.url
assert item.city_code == request.city_code
assert item.title == 'kid bike'
def test_contribution_mef_create(mock_contributions_mef_get, app,
contribution_person_data_tmp,
contribution_person_response_data):
"""Test MEF contribution creation."""
count = Contribution.count()
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
pers_mef, online = Contribution.get_record_by_ref(
'https://mef.rero.ch/api/rero/A017671081')
flush_index(ContributionsSearch.Meta.index)
assert pers_mef == contribution_person_data_tmp
assert online
assert Contribution.count() == count + 1
pers_mef.pop('idref')
pers_mef['sources'] = ['gnd']
pers_mef.replace(pers_mef, dbcommit=True)
pers_db, online = Contribution.get_record_by_ref(
'https://mef.rero.ch/api/gnd/13343771X')
assert pers_db['sources'] == ['gnd']
assert not online
def test_crawler_item_parse():
request = ItemRequest(
session_id='somesession',
url='mocked',
city_code='sfbay',
)
items = crawler.extract_items(
mock_response(
'data/item.html',
request_instance=request,
),
)
for item in items:
print('item:', dict(item))
assert isinstance(item, CraigsListItem)
assert item.url == request.url
assert item.city_code == request.city_code
assert item.title == 'kid bike'
def test_document_referenced_subject(mock_contributions_mef_get,
contribution_person_response_data,
contribution_person):
"""Test referenced document subjects."""
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
# REFERENCED SUBJECTS - SUCCESS
data = {
'$ref': get_ref_for_pid(Contribution, contribution_person.pid),
'type': DocumentSubjectType.PERSON
}
subject = SubjectFactory.create_subject(data)
assert subject.render(language='ger') == 'Loy, Georg, 1885-19..'
assert subject.render(language='dummy') == 'Loy, Georg, 1885-19..'
assert subject.render() == 'Loy, Georg, 1885-19..'
# REFERENCED SUBJECTS - ERRORS
data = {
'$dummy_ref': get_ref_for_pid(Contribution, contribution_person.pid),
'type': DocumentSubjectType.PERSON
}
with pytest.raises(AttributeError):
SubjectFactory.create_subject(data).render()
def test_documents_resolve(mock_contributions_mef_get, client,
loc_public_martigny, document_ref,
contribution_person_response_data):
"""Test document detailed view with items filter."""
res = client.get(url_for('invenio_records_rest.doc_item',
pid_value='doc2'))
assert res.json['metadata']['contribution'] == [{
'agent': {
'$ref': 'https://mef.rero.ch/api/rero/A017671081',
'type': 'bf:Person'
},
'role': ['aut']
}]
assert res.status_code == 200
mock_contributions_mef_get.return_value = mock_response(
json_data=contribution_person_response_data)
res = client.get(
url_for('invenio_records_rest.doc_item', pid_value='doc2',
resolve='1'))
assert res.json['metadata']['contribution'][0]['agent']['sources'] == [
'gnd', 'idref', 'rero'
]
assert res.status_code == 200
def test_documents_import_dnb_isbn(mock_get, client, dnb_isbn_123,
dnb_isbn_9783862729852,
dnb_isbn_3858818526,
dnb_samuelson,
dnb_recordid_1214325203):
"""Test document import from DNB."""
mock_get.return_value = mock_response(
content=dnb_isbn_123
)
res = client.get(url_for(
'api_imports.import_dnb',
q='123',
no_cache=1
))
assert res.status_code == 200
data = get_json(res)
assert not data.get('metadata')
mock_get.return_value = mock_response(
content=dnb_isbn_3858818526
)
res = client.get(url_for(
'api_imports.import_dnb',
q='3858818526',
no_cache=1
))
assert res.status_code == 200
res_j = get_json(res)
data = res_j.get('hits').get('hits')[0].get('metadata')
data.update({
"$schema": "https://bib.rero.ch/schemas/documents/document-v0.0.1.json"
})
assert Document.create(data)
marc21_link = res_j.get('hits').get('hits')[0].get('links').get('marc21')
res = client.get(marc21_link)
data = get_json(res)
assert data[0][0] == 'leader'
res = client.get(url_for(
'api_imports.import_dnb',
q='',
no_cache=1
))
assert res.status_code == 200
assert get_json(res) == {
'aggregations': {},
'hits': {
'hits': [],
'remote_total': 0,
'total': 0
}
}
mock_get.return_value = mock_response(
content=dnb_samuelson
)
res = client.get(url_for(
'api_imports.import_dnb',
q='samuelson, paul',
no_cache=1
))
assert res.status_code == 200
unfiltered_total = get_json(res)['hits']['remote_total']
assert get_json(res)
res = client.get(url_for(
'api_imports.import_dnb',
q='samuelson, paul',
year=2019
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_dnb',
q='samuelson, paul',
author='Samuelson, Paul A.'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_dnb',
q='samuelson, paul',
document_type='docmaintype_book'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
mock_get.return_value = mock_response(
content=dnb_recordid_1214325203
)
res = client.get(url_for(
'api_imports.import_dnb_record',
id='1214325203',
no_cache=1
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('identifiedBy')
def test_documents_import_ugent_isbn(mock_get, client, ugent_anywhere_123,
ugent_isbn_9781108422925,
ugent_book_without_26X,
ugent_isbn_9780415773867,
ugent_samuelson,
ugent_recordid_001247835):
"""Test document import from ugent."""
mock_get.return_value = mock_response(
content=ugent_anywhere_123
)
res = client.get(url_for(
'api_imports.import_ugent',
q='123',
no_cache=1
))
assert res.status_code == 200
data = get_json(res)
assert not data.get('metadata')
mock_get.return_value = mock_response(
content=ugent_isbn_9781108422925
)
res = client.get(url_for(
'api_imports.import_ugent',
q='isbn:all:9781108422925',
no_cache=1
))
assert res.status_code == 200
data = get_json(res).get('hits').get('hits')[0].get('metadata')
assert data['pid'] == '002487518'
assert Document.create(data)
mock_get.return_value = mock_response(
content=ugent_book_without_26X
)
res = client.get(url_for(
'api_imports.import_ugent',
q='isbn:all:9782717725650',
no_cache=1
))
assert res.status_code == 200
data = get_json(res).get('hits').get('hits')[0].get('metadata')
assert data['pid'] == '002762516'
assert Document.create(data)
res = client.get(url_for(
'api_imports.import_ugent',
q='',
no_cache=1
))
assert res.status_code == 200
assert get_json(res) == {
'aggregations': {},
'hits': {
'hits': [],
'remote_total': 0,
'total': 0
}
}
mock_get.return_value = mock_response(
content=ugent_samuelson
)
res = client.get(url_for(
'api_imports.import_ugent',
q='samuelson',
no_cache=1
))
assert res.status_code == 200
unfiltered_total = get_json(res)['hits']['remote_total']
assert get_json(res)
res = client.get(url_for(
'api_imports.import_ugent',
q='samuelson',
year=2019,
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_ugent',
q='samuelson',
author='samuelson',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
mock_get.return_value = mock_response(
content=ugent_recordid_001247835
)
res = client.get(url_for(
'api_imports.import_ugent_record',
id='recordid:all:001247835',
no_cache=1
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('identifiedBy')
def test_documents_import_kul_isbn(mock_get, client, kul_anywhere_123,
kul_isbn_9782265089419,
kul_book_without_26X,
kul_isbn_2804600068,
kul_samuelson,
kul_recordid_9992876296301471):
"""Test document import from kul."""
mock_get.return_value = mock_response(
content=kul_anywhere_123
)
res = client.get(url_for(
'api_imports.import_kul',
q='123',
no_cache=1
))
assert res.status_code == 200
data = get_json(res)
assert not data.get('metadata')
mock_get.return_value = mock_response(
content=kul_isbn_9782265089419
)
res = client.get(url_for(
'api_imports.import_kul',
q='isbn:all:9782265089419',
no_cache=1
))
assert res.status_code == 200
data = get_json(res).get('hits').get('hits')[0].get('metadata')
assert data['pid'] == '9983115060101471'
mock_get.return_value = mock_response(
content=kul_isbn_2804600068
)
res = client.get(url_for(
'api_imports.import_kul',
q='isbn:all:2804600068',
no_cache=1
))
assert res.status_code == 200
res_j = get_json(res)
data = res_j.get('hits').get('hits')[0].get('metadata')
data.update({
"$schema": "https://bib.rero.ch/schemas/documents/document-v0.0.1.json"
})
assert Document.create(data)
marc21_link = res_j.get('hits').get('hits')[0].get('links').get('marc21')
res = client.get(marc21_link)
data = get_json(res)
assert data[0][0] == 'leader'
res = client.get(url_for(
'api_imports.import_kul',
q='',
no_cache=1
))
assert res.status_code == 200
assert get_json(res) == {
'aggregations': {},
'hits': {
'hits': [],
'remote_total': 0,
'total': 0
}
}
mock_get.return_value = mock_response(
content=kul_samuelson
)
res = client.get(url_for(
'api_imports.import_kul',
q='samuelson',
no_cache=1
))
assert res.status_code == 200
unfiltered_total = get_json(res)['hits']['remote_total']
assert get_json(res)
res = client.get(url_for(
'api_imports.import_kul',
q='samuelson',
year=2019,
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_kul',
q='samuelson',
author='samuelson',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_kul',
q='samuelson',
document_type='docmaintype_book',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
mock_get.return_value = mock_response(
content=kul_recordid_9992876296301471
)
res = client.get(url_for(
'api_imports.import_kul_record',
id='recordid:all:9992876296301471',
no_cache=1
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('identifiedBy')
res = client.get(url_for(
'api_imports.import_kul_record',
id='recordid:all:9992876296301471',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('ui_title_text')
def test_documents_import_bnf_ean(mock_get, client, bnf_ean_any_123,
bnf_ean_any_9782070541270,
bnf_ean_any_9782072862014,
bnf_anywhere_all_peter,
bnf_recordid_all_FRBNF370903960000006):
"""Test document import from bnf."""
mock_get.return_value = mock_response(content=bnf_ean_any_123)
res = client.get(
url_for('api_imports.import_bnf', q='ean:any:123', no_cache=1))
assert res.status_code == 200
data = get_json(res)
assert not data.get('metadata')
mock_get.return_value = mock_response(content=bnf_ean_any_9782070541270)
res = client.get(
url_for('api_imports.import_bnf',
q='ean:any:9782070541270',
no_cache=1))
assert res.status_code == 200
data = get_json(res).get('hits').get('hits')[0].get('metadata')
assert data['pid'] == 'FRBNF370903960000006'
assert Document.create(data)
mock_get.return_value = mock_response(content=bnf_ean_any_9782072862014)
res = client.get(
url_for('api_imports.import_bnf',
q='ean:any:9782072862014',
no_cache=1))
assert res.status_code == 200
res_j = get_json(res)
data = res_j.get('hits').get('hits')[0].get('metadata')
data.update({
"$schema":
"https://ils.rero.ch/schemas/documents/document-v0.0.1.json"
})
assert Document.create(data)
marc21_link = res_j.get('hits').get('hits')[0].get('links').get('marc21')
res = client.get(marc21_link)
data = get_json(res)
assert data[0][0] == 'leader'
res = client.get(url_for('api_imports.import_bnf', q='', no_cache=1))
assert res.status_code == 200
assert get_json(res) == {
'aggregations': {},
'hits': {
'hits': [],
'remote_total': 0,
'total': 0
}
}
mock_get.return_value = mock_response(content=bnf_anywhere_all_peter)
res = client.get(url_for('api_imports.import_bnf', q='peter', no_cache=1))
assert res.status_code == 200
unfiltered_total = get_json(res)['hits']['remote_total']
assert get_json(res)
res = client.get(
url_for('api_imports.import_bnf',
q='peter',
year=2000,
format='rerojson'))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(
url_for('api_imports.import_bnf',
q='peter',
author='Peter Owen',
format='rerojson'))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(
url_for('api_imports.import_bnf',
q='peter',
document_type='docmaintype_book',
document_subtype='docsubtype_other_book',
format='rerojson'))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
mock_get.return_value = mock_response(
content=bnf_recordid_all_FRBNF370903960000006)
res = client.get(
url_for('api_imports.import_bnf_record',
id='FRBNF370903960000006',
no_cache=1))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('identifiedBy')
res = client.get(
url_for('api_imports.import_bnf_record',
id='FRBNF370903960000006',
format='rerojson'))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('ui_title_text')
res = client.get(
url_for('api_imports.import_bnf_record',
id='FRBNF370903960000006',
format='marc'))
assert res.status_code == 200
assert get_json(res)[1][1] == 'FRBNF370903960000006'
def test_get_records(mock_get, app, capsys):
"""Test finding a circulation policy."""
mock_get.return_value = mock_response(
json_data={
'hits': {
'hits': [{
'metadata': {
'pid': 'test1',
'data': 'test data 1'
}
}, {
'metadata': {
'pid': 'test2',
'data': 'test data 2'
}
}],
'total':
2,
'links': {
'self': 'http:/test.com'
}
}
})
for next_url, data in get_records(url='http://test.com',
name='test',
signals=False):
assert next_url
assert data == [{
'data': 'test data 1',
'pid': 'test1'
}, {
'data': 'test data 2',
'pid': 'test2'
}]
out, err = capsys.readouterr()
assert out.strip() == 'API records found: 2'
mock_get.return_value = mock_response(
json_data={
'hits': {
'hits': [{
'metadata': {
'pid': 'test3',
'data': 'test data 3'
}
}, {
'metadata': {
'pid': 'test4',
'data': 'test data 4'
}
}],
'total':
2,
'links': {
'self': 'http:/test.com'
}
}
})
for next_url, data in get_records(url='http://test.com',
name='test',
from_date='1970-01-01',
signals=False):
assert next_url
assert data == [{
'data': 'test data 3',
'pid': 'test3'
}, {
'data': 'test data 4',
'pid': 'test4'
}]
out, err = capsys.readouterr()
assert out.strip() == 'API records found: 2'
def test_documents_import_loc_isbn(mock_get, client, loc_isbn_all_123,
loc_isbn_all_9781604689808,
loc_isbn_all_9780821417478,
loc_anywhere_all_samuelson,
loc_recordid_all_2014043016):
"""Test document import from LoC."""
mock_get.return_value = mock_response(
content=loc_isbn_all_123
)
res = client.get(url_for(
'api_imports.import_loc',
q='isbn:all:123',
no_cache=1
))
assert res.status_code == 200
data = get_json(res)
assert not data.get('metadata')
mock_get.return_value = mock_response(
content=loc_isbn_all_9781604689808
)
res = client.get(url_for(
'api_imports.import_loc',
q='isbn:all:9781604689808',
no_cache=1
))
assert res.status_code == 200
data = get_json(res).get('hits').get('hits')[0].get('metadata')
assert data['pid'] == '2018032710'
assert Document.create(data)
mock_get.return_value = mock_response(
content=loc_isbn_all_9780821417478
)
res = client.get(url_for(
'api_imports.import_loc',
q='isbn:all:9780821417478',
no_cache=1
))
assert res.status_code == 200
res_j = get_json(res)
data = res_j.get('hits').get('hits')[0].get('metadata')
data.update({
"$schema": "https://bib.rero.ch/schemas/documents/document-v0.0.1.json"
})
assert Document.create(data)
marc21_link = res_j.get('hits').get('hits')[0].get('links').get('marc21')
res = client.get(marc21_link)
data = get_json(res)
assert data[0][0] == 'leader'
res = client.get(url_for(
'api_imports.import_loc',
q='',
no_cache=1
))
assert res.status_code == 200
assert get_json(res) == {
'aggregations': {},
'hits': {
'hits': [],
'remote_total': 0,
'total': 0
}
}
mock_get.return_value = mock_response(
content=loc_anywhere_all_samuelson
)
res = client.get(url_for(
'api_imports.import_loc',
q='samuelson',
no_cache=1
))
assert res.status_code == 200
unfiltered_total = get_json(res)['hits']['remote_total']
assert get_json(res)
res = client.get(url_for(
'api_imports.import_loc',
q='samuelson',
year=2019,
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_loc',
q='samuelson',
author='Samuelson, Paul',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_loc',
q='samuelson',
document_type='docmaintype_book',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
mock_get.return_value = mock_response(
content=loc_recordid_all_2014043016
)
res = client.get(url_for(
'api_imports.import_loc_record',
id='2014043016',
no_cache=1
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('identifiedBy')
res = client.get(url_for(
'api_imports.import_loc_record',
id='2014043016',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('ui_title_text')
def test_documents_import_slsp_isbn(mock_get, client, slsp_anywhere_123,
slsp_isbn_9782296076648,
slsp_isbn_3908497272,
slsp_samuelson,
slsp_recordid_9910137):
"""Test document import from slsp."""
mock_get.return_value = mock_response(
content=slsp_anywhere_123
)
res = client.get(url_for(
'api_imports.import_slsp',
q='123',
no_cache=1
))
assert res.status_code == 200
data = get_json(res)
assert not data.get('metadata')
mock_get.return_value = mock_response(
content=slsp_isbn_9782296076648
)
res = client.get(url_for(
'api_imports.import_slsp',
q='isbn:all:9782296076648',
no_cache=1
))
assert res.status_code == 200
data = get_json(res).get('hits').get('hits')[0].get('metadata')
assert data['pid'] == '991079993319705501'
assert Document.create(data)
mock_get.return_value = mock_response(
content=slsp_isbn_3908497272
)
res = client.get(url_for(
'api_imports.import_slsp',
q='isbn:all:3908497272',
no_cache=1
))
assert res.status_code == 200
res_j = get_json(res)
data = res_j.get('hits').get('hits')[0].get('metadata')
data.update({
"$schema": "https://bib.rero.ch/schemas/documents/document-v0.0.1.json"
})
assert Document.create(data)
marc21_link = res_j.get('hits').get('hits')[0].get('links').get('marc21')
res = client.get(marc21_link)
data = get_json(res)
assert data[0][0] == 'leader'
res = client.get(url_for(
'api_imports.import_slsp',
q='',
no_cache=1
))
assert res.status_code == 200
assert get_json(res) == {
'aggregations': {},
'hits': {
'hits': [],
'remote_total': 0,
'total': 0
}
}
mock_get.return_value = mock_response(
content=slsp_samuelson
)
res = client.get(url_for(
'api_imports.import_slsp',
q='samuelson',
no_cache=1
))
assert res.status_code == 200
unfiltered_total = get_json(res)['hits']['remote_total']
assert get_json(res)
res = client.get(url_for(
'api_imports.import_slsp',
q='samuelson',
year=2019,
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_slsp',
q='samuelson',
author='samuelson',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
res = client.get(url_for(
'api_imports.import_slsp',
q='samuelson',
document_type='docmaintype_book',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res)['hits']['total'] < unfiltered_total
mock_get.return_value = mock_response(
content=slsp_recordid_9910137
)
res = client.get(url_for(
'api_imports.import_slsp_record',
id='recordid:all:991013724759705501',
no_cache=1
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('identifiedBy')
res = client.get(url_for(
'api_imports.import_slsp_record',
id='recordid:all:991013724759705501',
format='rerojson'
))
assert res.status_code == 200
assert get_json(res).get('metadata', {}).get('ui_title_text')
