def migrate_suggestions(source):
# read in the content
f = open(source)
xml = etree.parse(f)
f.close()
suggestions = xml.getroot()
print "migrating", str(len(suggestions)), "suggestion records"
for element in suggestions:
s = Suggestion()
# re-use the journal bibjson crosswalk
cb = _to_journal_bibjson(element)
s.set_bibjson(cb)
# explicitly set the open-access-ness
cb.set_open_access(_is_open_access(element))
# suggestion info
_to_suggestion(element, s)
s.save()
def migrate_suggestions(source):
# read in the content
f = open(source)
xml = etree.parse(f)
f.close()
suggestions = xml.getroot()
print "migrating", str(len(suggestions)), "suggestion records"
for element in suggestions:
s = Suggestion()
# re-use the journal bibjson crosswalk
cb = _to_journal_bibjson(element)
s.set_bibjson(cb)
# explicitly set the open-access-ness
cb.set_open_access(_is_open_access(element))
# suggestion info
_to_suggestion(element, s)
s.save()
writer.writerow(row)
break
else:
row += [
"no",
"last reapplication date earlier than application created date"
]
writer.writerow(row)
else:
row += [
"no",
"no reapplication date, and journal either created before application created, or application not (manually) updated since journal created date"
]
writer.writerow(row)
application.save()
print((counter, application.id))
else:
row = [
application.id, application.created_date,
application.last_updated, application.last_manual_update, "",
",".join(issns), "0", "", "", "", "", "", "", "", "", "", ""
]
writer.writerow(row)
print((counter, application.id))
# let the index catch up
time.sleep(2)
rows = []
# longest_row = 0
def test_01_accept_application(self, name, application_type, account_type, manual_update, provenance, raises, result_provenance, result_manual_update):
###############################################
## set up
# create the application
application = None
if application_type == "save_fail":
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
application.save = mock_save
Journal.save = mock_save
elif application_type == "with_current_journal":
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
application.remove_notes()
application.add_note("unique 1", "2002-01-01T00:00:00Z")
application.add_note("duplicate", "2001-01-01T00:00:00Z")
cj = application.current_journal
journal = Journal(**JournalFixtureFactory.make_journal_source())
journal.set_id(cj)
journal.remove_notes()
journal.add_note("unique 2", "2003-01-01T00:00:00Z")
journal.add_note("duplicate", "2001-01-01T00:00:00Z")
journal.save(blocking=True)
elif application_type == "no_current_journal":
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
application.remove_current_journal()
acc = None
if account_type == "not_allowed":
acc = Account(**AccountFixtureFactory.make_publisher_source())
elif account_type == "allowed":
acc = Account(**AccountFixtureFactory.make_managing_editor_source())
mu = None
if manual_update in ["true", "false"]:
mu = manual_update == "true"
prov = None
if provenance in ["true", "false"]:
prov = provenance == "true"
save = bool(randint(0,1))
###########################################################
# Execution
svc = DOAJ.applicationService()
if raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.accept_application(application, acc, mu, prov)
else:
journal = svc.accept_application(application, acc, mu, prov, save_journal=save, save_application=save)
# we need to sleep, so the index catches up
time.sleep(1)
# check a few common things
assert application.application_status == constants.APPLICATION_STATUS_ACCEPTED
assert application.current_journal is None
assert journal.current_application is None
assert application.related_journal == journal.id
related = journal.related_applications
if application_type == "with_current_journal":
assert len(related) == 3
elif application_type == "no_current_journal":
assert len(related) == 1
assert related[0].get("application_id") == application.id
assert related[0].get("date_accepted") is not None
if result_manual_update == "yes":
assert journal.last_manual_update is not None
assert journal.last_manual_update != "1970-01-01T00:00:00Z"
assert application.last_manual_update is not None
assert application.last_manual_update != "1970-01-01T00:00:00Z"
elif result_manual_update == "no":
assert journal.last_manual_update is None
assert application.last_manual_update is None
if application_type == "with_current_journal":
assert len(journal.notes) == 3
notevals = [note.get("note") for note in journal.notes]
assert "duplicate" in notevals
assert "unique 1" in notevals
assert "unique 2" in notevals
app_prov = Provenance.get_latest_by_resource_id(application.id)
if result_provenance == "yes":
assert app_prov is not None
elif result_provenance == "no":
assert app_prov is None
if save:
pass
def test_01_delete_application(self, name, application_type, account_type,
current_journal, related_journal, raises):
###############################################
## set up
# create the test application (if needed), and the associated current_journal and related_journal in suitable states
application = None
cj = None
rj = None
if application_type == "found" or application_type == "locked":
application = Suggestion(
**ApplicationFixtureFactory.make_application_source())
if current_journal == "none":
application.remove_current_journal()
elif current_journal == "not_found":
application.set_current_journal("123456789987654321")
elif current_journal == "found":
cj = Journal(**JournalFixtureFactory.make_journal_source())
cj.set_id(cj.makeid())
cj.save(blocking=True)
application.set_current_journal(cj.id)
elif current_journal == "locked":
cj = Journal(**JournalFixtureFactory.make_journal_source())
cj.set_id(cj.makeid())
cj.save(blocking=True)
application.set_current_journal(cj.id)
lock.lock(constants.LOCK_JOURNAL, cj.id, "otheruser")
if related_journal == "none":
application.remove_related_journal()
elif related_journal == "not_found":
application.set_related_journal("123456789987654321")
elif related_journal == "found":
rj = Journal(**JournalFixtureFactory.make_journal_source())
rj.set_id(rj.makeid())
rj.save(blocking=True)
application.set_related_journal(rj.id)
elif related_journal == "locked":
rj = Journal(**JournalFixtureFactory.make_journal_source())
rj.set_id(rj.makeid())
rj.save(blocking=True)
application.set_related_journal(rj.id)
lock.lock(constants.LOCK_JOURNAL, rj.id, "otheruser")
acc = None
if account_type != "none":
acc = Account(**AccountFixtureFactory.make_publisher_source())
if account_type == "not_permitted":
acc.remove_role("publisher")
if application_type == "locked":
thelock = lock.lock(constants.LOCK_APPLICATION, application.id,
"otheruser")
# we can't explicitly block on the lock, but we can halt until we confirm it is saved
thelock.blockall([(thelock.id, thelock.last_updated)])
application_id = None
if application is not None:
if acc is not None:
application.set_owner(acc.id)
application.save(blocking=True)
application_id = application.id
elif application_type == "not_found":
application_id = "sdjfasofwefkwflkajdfasjd"
###########################################################
# Execution
svc = DOAJ.applicationService()
if raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.delete_application(application_id, acc)
time.sleep(1)
check_locks(application, cj, rj, acc)
else:
svc.delete_application(application_id, acc)
# we need to sleep, so the index catches up
time.sleep(1)
# check that no locks remain set for this user
check_locks(application, cj, rj, acc)
# check that the application actually is gone
if application is not None:
assert Suggestion.pull(application.id) is None
# check that the current journal no longer has a reference to the application
if cj is not None:
cj = Journal.pull(cj.id)
assert cj.current_application is None
# check that the related journal has a record that the application was deleted
if rj is not None:
rj = Journal.pull(rj.id)
record = rj.related_application_record(application.id)
assert "status" in record
assert record["status"] == "deleted"
lrd = datetime.strptime(lr, "%Y-%m-%dT%H:%M:%SZ")
if lrd > app_created:
application.set_related_journal(journal.id)
row[13] = ""
row[15] = "true"
row += ["yes", "last reapplication date more recent than application created date"]
writer.writerow(row)
break
else:
row += ["no", "last reapplication date earlier than application created date"]
writer.writerow(row)
else:
row += ["no", "no reapplication date, and journal either created before application created, or application not (manually) updated since journal created date"]
writer.writerow(row)
application.save()
print(counter, application.id)
else:
row = [
application.id, application.created_date, application.last_updated, application.last_manual_update, "", ",".join(issns),
"0", "", "", "", "", "", "", "", "", "", ""
]
writer.writerow(row)
print(counter, application.id)
# let the index catch up
time.sleep(2)
rows = []
# longest_row = 0
def test_01_update_request(self, name, journal_id, journal_lock, account,
account_role, account_is_owner,
current_applications, application_lock,
application_status, completed_applications,
raises, return_app, return_jlock, return_alock,
db_jlock, db_alock, db_app):
###############################################
## set up
# create the journal
journal = None
jid = None
if journal_id == "valid":
journal = Journal(**JournalFixtureFactory.make_journal_source(
in_doaj=True))
journal.remove_related_applications()
journal.remove_current_application()
jid = journal.id
elif journal_id == "not_in_doaj":
journal = Journal(**JournalFixtureFactory.make_journal_source(
in_doaj=False))
journal.remove_related_applications()
journal.remove_current_application()
jid = journal.id
elif journal_id == "missing":
jid = uuid.uuid4().hex
acc = None
if account == "yes":
acc = Account(**AccountFixtureFactory.make_publisher_source())
if account_role == "none":
acc.remove_role("publisher")
elif account_role == "admin":
acc.remove_role("publisher")
acc.add_role("admin")
acc.set_id(acc.makeid())
if account_is_owner == "yes":
acc.set_id(journal.owner)
if journal_lock == "yes":
lock.lock("journal", jid, "someoneelse", blocking=True)
latest_app = None
current_app_count = int(current_applications)
for i in range(current_app_count):
app = Suggestion(
**ApplicationFixtureFactory.make_application_source())
app.set_id(app.makeid())
app.set_created("198" + str(i) + "-01-01T00:00:00Z")
app.set_current_journal(jid)
app.save()
latest_app = app
if journal is not None:
journal.set_current_application(app.id)
comp_app_count = int(completed_applications)
for i in range(comp_app_count):
app = Suggestion(
**ApplicationFixtureFactory.make_application_source())
app.set_id(app.makeid())
app.set_created("197" + str(i) + "-01-01T00:00:00Z")
app.set_related_journal(jid)
app.save()
if journal is not None:
journal.add_related_application(app.id,
date_accepted=app.created_date)
if current_app_count == 0 and comp_app_count == 0:
# save at least one record to initialise the index mapping, otherwise tests fail
app = Suggestion(
**ApplicationFixtureFactory.make_application_source())
app.set_id(app.makeid())
app.save()
if application_lock == "yes":
lock.lock("suggestion",
latest_app.id,
"someoneelse",
blocking=True)
if application_status != "n/a":
latest_app.set_application_status(application_status)
latest_app.save(blocking=True)
# finally save the journal record, ensuring we get a blocking save, so everything
# above here should be synchronised with the repo
if journal is not None:
journal.save(blocking=True)
###########################################################
# Execution
svc = DOAJ.applicationService()
if raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.update_request_for_journal(jid, acc)
else:
application, jlock, alock = svc.update_request_for_journal(
jid, acc)
# we need to sleep, so the index catches up
time.sleep(1)
if return_app == "none":
assert application is None
elif return_app == "yes":
assert application is not None
if return_jlock == "none":
assert jlock is None
elif return_jlock == "yes":
assert jlock is not None
if return_alock == "none":
assert alock is None
elif return_alock == "yes":
assert alock is not None
if db_jlock == "no" and acc is not None:
assert not lock.has_lock("journal", jid, acc.id)
elif db_jlock == "yes" and acc is not None:
l = lock.has_lock("journal", jid, acc.id)
assert lock.has_lock("journal", jid, acc.id)
if db_alock == "no" and application.id is not None and acc is not None:
assert not lock.has_lock("suggestion", application.id, acc.id)
elif db_alock == "yes" and application.id is not None and acc is not None:
assert lock.has_lock("suggestion", application.id, acc.id)
if db_app == "no" and application.id is not None:
indb = Suggestion.q2obj(q="id.exact:" + application.id)
assert indb is None
elif db_app == "yes" and application.id is not None:
indb = Suggestion.q2obj(q="id.exact:" + application.id)
assert indb is not None
if current_app_count == 0 and comp_app_count == 0 and application is not None:
assert application.article_metadata is None
assert application.articles_last_year is None
elif application is not None:
assert application.article_metadata is not None
assert application.articles_last_year is not None
def test_01_delete_application(self, name, application_type, account_type, current_journal, related_journal, raises):
###############################################
## set up
# create the test application (if needed), and the associated current_journal and related_journal in suitable states
application = None
cj = None
rj = None
if application_type == "found" or application_type == "locked":
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
if current_journal == "none":
application.remove_current_journal()
elif current_journal == "not_found":
application.set_current_journal("123456789987654321")
elif current_journal == "found":
cj = Journal(**JournalFixtureFactory.make_journal_source())
cj.set_id(cj.makeid())
cj.save(blocking=True)
application.set_current_journal(cj.id)
elif current_journal == "locked":
cj = Journal(**JournalFixtureFactory.make_journal_source())
cj.set_id(cj.makeid())
cj.save(blocking=True)
application.set_current_journal(cj.id)
lock.lock(constants.LOCK_JOURNAL, cj.id, "otheruser")
if related_journal == "none":
application.remove_related_journal()
elif related_journal == "not_found":
application.set_related_journal("123456789987654321")
elif related_journal == "found":
rj = Journal(**JournalFixtureFactory.make_journal_source())
rj.set_id(rj.makeid())
rj.save(blocking=True)
application.set_related_journal(rj.id)
elif related_journal == "locked":
rj = Journal(**JournalFixtureFactory.make_journal_source())
rj.set_id(rj.makeid())
rj.save(blocking=True)
application.set_related_journal(rj.id)
lock.lock(constants.LOCK_JOURNAL, rj.id, "otheruser")
acc = None
if account_type != "none":
acc = Account(**AccountFixtureFactory.make_publisher_source())
if account_type == "not_permitted":
acc.remove_role("publisher")
if application_type == "locked":
thelock = lock.lock(constants.LOCK_APPLICATION, application.id, "otheruser")
# we can't explicitly block on the lock, but we can halt until we confirm it is saved
thelock.blockall([(thelock.id, thelock.last_updated)])
application_id = None
if application is not None:
if acc is not None:
application.set_owner(acc.id)
application.save(blocking=True)
application_id = application.id
elif application_type == "not_found":
application_id = u"sdjfasofwefkwflkajdfasjd"
###########################################################
# Execution
svc = DOAJ.applicationService()
if raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.delete_application(application_id, acc)
time.sleep(1)
check_locks(application, cj, rj, acc)
else:
svc.delete_application(application_id, acc)
# we need to sleep, so the index catches up
time.sleep(1)
# check that no locks remain set for this user
check_locks(application, cj, rj, acc)
# check that the application actually is gone
if application is not None:
assert Suggestion.pull(application.id) is None
# check that the current journal no longer has a reference to the application
if cj is not None:
cj = Journal.pull(cj.id)
assert cj.current_application is None
# check that the related journal has a record that the application was deleted
if rj is not None:
rj = Journal.pull(rj.id)
record = rj.related_application_record(application.id)
assert "status" in record
assert record["status"] == "deleted"
def test_01_update_request(self, name, journal_id, journal_lock,
account, account_role, account_is_owner,
current_applications, application_lock, application_status,
completed_applications, raises,
return_app, return_jlock, return_alock,
db_jlock, db_alock, db_app):
###############################################
## set up
# create the journal
journal = None
jid = None
if journal_id == "valid":
journal = Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
journal.remove_related_applications()
journal.remove_current_application()
jid = journal.id
elif journal_id == "not_in_doaj":
journal = Journal(**JournalFixtureFactory.make_journal_source(in_doaj=False))
journal.remove_related_applications()
journal.remove_current_application()
jid = journal.id
elif journal_id == "missing":
jid = uuid.uuid4().hex
acc = None
if account == "yes":
acc = Account(**AccountFixtureFactory.make_publisher_source())
if account_role == "none":
acc.remove_role("publisher")
elif account_role == "admin":
acc.remove_role("publisher")
acc.add_role("admin")
acc.set_id(acc.makeid())
if account_is_owner == "yes":
acc.set_id(journal.owner)
if journal_lock == "yes":
lock.lock("journal", jid, "someoneelse", blocking=True)
latest_app = None
current_app_count = int(current_applications)
for i in range(current_app_count):
app = Suggestion(**ApplicationFixtureFactory.make_application_source())
app.set_id(app.makeid())
app.set_created("198" + str(i) + "-01-01T00:00:00Z")
app.set_current_journal(jid)
app.save()
latest_app = app
if journal is not None:
journal.set_current_application(app.id)
comp_app_count = int(completed_applications)
for i in range(comp_app_count):
app = Suggestion(**ApplicationFixtureFactory.make_application_source())
app.set_id(app.makeid())
app.set_created("197" + str(i) + "-01-01T00:00:00Z")
app.set_related_journal(jid)
app.save()
if journal is not None:
journal.add_related_application(app.id, date_accepted=app.created_date)
if current_app_count == 0 and comp_app_count == 0:
# save at least one record to initialise the index mapping, otherwise tests fail
app = Suggestion(**ApplicationFixtureFactory.make_application_source())
app.set_id(app.makeid())
app.save()
if application_lock == "yes":
lock.lock("suggestion", latest_app.id, "someoneelse", blocking=True)
if application_status != "n/a":
latest_app.set_application_status(application_status)
latest_app.save(blocking=True)
# finally save the journal record, ensuring we get a blocking save, so everything
# above here should be synchronised with the repo
if journal is not None:
journal.save(blocking=True)
###########################################################
# Execution
svc = DOAJ.applicationService()
if raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.update_request_for_journal(jid, acc)
else:
application, jlock, alock = svc.update_request_for_journal(jid, acc)
# we need to sleep, so the index catches up
time.sleep(1)
if return_app == "none":
assert application is None
elif return_app == "yes":
assert application is not None
if return_jlock == "none":
assert jlock is None
elif return_jlock == "yes":
assert jlock is not None
if return_alock == "none":
assert alock is None
elif return_alock == "yes":
assert alock is not None
if db_jlock == "no" and acc is not None:
assert not lock.has_lock("journal", jid, acc.id)
elif db_jlock == "yes" and acc is not None:
assert lock.has_lock("journal", jid, acc.id)
if db_alock == "no" and application.id is not None and acc is not None:
assert not lock.has_lock("suggestion", application.id, acc.id)
elif db_alock == "yes" and application.id is not None and acc is not None:
assert lock.has_lock("suggestion", application.id, acc.id)
if db_app == "no" and application.id is not None:
indb = Suggestion.q2obj(q="id.exact:" + application.id)
assert indb is None
elif db_app == "yes" and application.id is not None:
indb = Suggestion.q2obj(q="id.exact:" + application.id)
assert indb is not None
if current_app_count == 0 and comp_app_count == 0 and application is not None:
assert application.article_metadata is None
assert application.articles_last_year is None
elif application is not None:
assert application.article_metadata is not None
assert application.articles_last_year is not None
