def test_06_public_dao(self):
# Check all the DAO methods on the PublicAPC object
dao = PublicAPC()
source = PublicAPCFixtureFactory.example()
pub = PublicAPC(source)
pub.set_apc_ref("test1", "1111111111")
pub.save(blocking=True)
# first try the straight-forward pull
pub2 = dao.pull(pub.id)
assert pub2 is not None
# now do the successful queries
res = dao.find_by_doi("10.1234/me")
assert len(res) == 1
res = dao.find_by_pmid("87654321")
assert len(res) == 1
res = dao.find_by_pmcid("PMC1234")
assert len(res) == 1
res = dao.find_by_url("http://example.com/whatever")
assert len(res) == 1
# now to check those queries don't always return, make sure we can get 0 results
res = dao.find_by_doi("10.1234/whatever")
assert len(res) == 0
res = dao.find_by_pmid("88888888")
assert len(res) == 0
res = dao.find_by_pmcid("PMC1111")
assert len(res) == 0
res = dao.find_by_url("http://example.com/another")
assert len(res) == 0
gen = dao.list_by_owner("abcdefg")
count = 0
for apc in gen:
count += 1
assert count == 1
def find_public_record_by_identifier(cls, type, id):
"""
Find a single public record which corresponds to the given identifier. If more than one record are present,
this will return the first one encountered, which is essentially random.
:param type: the identifier type (e.g. doi, pmid, pmcid, url)
:param id: the identifier
:return: a PublicAPC record if one is found otherwise None
"""
dao = PublicAPC()
if type == "doi":
pubs = dao.find_by_doi(id)
if len(pubs) > 1:
app.logger.warn(u"Multiple public records found for DOI {x}".format(x=id))
return None
if len(pubs) > 0:
return pubs[0]
if type == "pmid":
pubs = dao.find_by_pmid(id)
if len(pubs) > 1:
app.logger.warn(u"Multiple public records found for PMID {x}".format(x=id))
return None
if len(pubs) > 0:
return pubs[0]
if type == "pmcid":
pubs = dao.find_by_pmcid(id)
if len(pubs) > 1:
app.logger.warn(u"Multiple public records found for PMCID {x}".format(x=id))
return None
if len(pubs) > 0:
return pubs[0]
if type == "url":
pubs = dao.find_by_url(id)
if len(pubs) > 1:
app.logger.warn(u"Multiple public records found for URL {x}".format(x=id))
return None
if len(pubs) > 0:
return pubs[0]
def test_13_process_ehnancements_cycle(self):
# Run through the process of processing an enhancement
source = EnhancementFixtureFactory.example()
if "id" in source:
del source["id"]
pub_dao = PublicAPC()
wfs_dao = WorkflowState()
# first make a public record for us to enhance
first = PublicAPCFixtureFactory.example()
del first["record"]["dc:title"]
pub = PublicAPC(first)
pub.save(blocking=True)
# now create an enhancements on the record
second = deepcopy(source)
second["record"]["dc:title"] = "Update"
second["created_date"] = "2002-01-01T00:00:00Z"
en = Enhancement(second)
en.public_id = pub.id
en.save(blocking=True)
# run the job
WorkflowApi.process_enhancements()
time.sleep(2)
# check that the workflow state was created
wfs = wfs_dao.pull("enhancements")
assert wfs is not None
assert wfs.last_request == en.created_date
assert wfs.already_processed == [en.id]
# check the public record was updated
pubs = pub_dao.find_by_doi("10.1234/me")
assert len(pubs) == 1
assert pubs[0].record.get("dc:title") == "Update"
# now run an update with the same date, to observe the difference in the workflow state
third = deepcopy(source)
third["record"]["dc:title"] = "Update 2"
third["created_date"] = "2002-01-01T00:00:00Z"
en2 = Enhancement(third)
en2.public_id = pub.id
en2.save(blocking=True)
# run the job again
WorkflowApi.process_enhancements()
time.sleep(2)
# check the public record was updated
pubs = pub_dao.find_by_doi("10.1234/me")
assert len(pubs) == 1
assert (
pubs[0].record.get("dc:title") == "Update"
) # should not have been updated, since data was already present
# check that the workflow state was updated
wfs = wfs_dao.pull("enhancements")
assert wfs is not None
assert wfs.last_request == en2.created_date
assert wfs.already_processed == [en.id, en2.id] # processed records should have been appended
def test_11_process_requests_cycle(self):
# Run through the process of processing a Request into a PublicAPC
source = RequestFixtureFactory.example()
if "id" in source:
del source["id"]
pub_dao = PublicAPC()
wfs_dao = WorkflowState()
# first make a record for the first time
first = deepcopy(source)
del first["record"]["dc:title"]
req = Request(first)
req.owner = "test"
req.action = "update"
req.save(blocking=True)
# run the job
WorkflowApi.process_requests()
time.sleep(2)
# first check that a public record was made
pubs = pub_dao.find_by_doi("10.1234/me")
assert len(pubs) == 1
assert pubs[0].record.get("dc:title") is None
# check that the workflow state was created
wfs = wfs_dao.pull("requests")
assert wfs is not None
assert wfs.last_request == req.created_date
assert wfs.already_processed == [req.id]
# now run an update with a different date
second = deepcopy(source)
second["record"]["dc:title"] = "Update"
second["created_date"] = "2002-01-01T00:00:00Z"
req2 = Request(second)
req2.owner = "test"
req2.action = "update"
req2.save(blocking=True)
# run the job again
WorkflowApi.process_requests()
time.sleep(2)
# check the public record was updated
pubs = pub_dao.find_by_doi("10.1234/me")
assert len(pubs) == 1
assert pubs[0].record.get("dc:title") == "Update"
# check that the workflow state was updated
wfs = wfs_dao.pull("requests")
assert wfs is not None
assert wfs.last_request == req2.created_date
assert wfs.already_processed == [req2.id]
# now run an update with the same date, to observe the difference in the workflow state
third = deepcopy(source)
third["record"]["dc:title"] = "Update 2"
third["created_date"] = "2002-01-01T00:00:00Z"
req3 = Request(third)
req3.owner = "test"
req3.action = "update"
req3.save(blocking=True)
# run the job again
WorkflowApi.process_requests()
time.sleep(2)
# check the public record was updated
pubs = pub_dao.find_by_doi("10.1234/me")
assert len(pubs) == 1
assert (
pubs[0].record.get("dc:title") == "Update 2"
) # should have been updated, as there are only apc contributions from one source
# check that the workflow state was updated
wfs = wfs_dao.pull("requests")
assert wfs is not None
assert wfs.last_request == req3.created_date
assert wfs.already_processed == [req2.id, req3.id] # processed records should have been appended
# finally issue a delete request
fourth = deepcopy(source)
fourth["created_date"] = "2003-01-01T00:00:00Z"
req4 = Request(fourth)
req4.owner = "test"
req4.action = "delete"
req4.save(blocking=True)
# run the job again
WorkflowApi.process_requests()
time.sleep(2)
# check the public record was updated
pubs = pub_dao.find_by_doi("10.1234/me")
assert len(pubs) == 0
# check that the workflow state was updated
wfs = wfs_dao.pull("requests")
assert wfs is not None
assert wfs.last_request == req4.created_date
assert wfs.already_processed == [req4.id] # processed records should have been appended
