def test_02_classification_required(self):
# Check we can mark an application 'completed' with a subject classification present
in_progress_application = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
in_progress_application.set_application_status(constants.APPLICATION_STATUS_IN_PROGRESS)
fc = formcontext.ApplicationFormFactory.get_form_context(role='associate_editor', source=in_progress_application)
# Make changes to the application status via the form, check it validates
fc.form.application_status.data = constants.APPLICATION_STATUS_COMPLETED
assert fc.validate()
# Without a subject classification, we should not be able to set the status to 'completed'
no_class_application = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
del no_class_application.data['bibjson']['subject']
fc = formcontext.ApplicationFormFactory.get_form_context(role='associate_editor', source=no_class_application)
# Make changes to the application status via the form
assert fc.source.bibjson().subjects() == []
fc.form.application_status.data = constants.APPLICATION_STATUS_COMPLETED
assert not fc.validate()
# However, we should be able to set it to a different status rather than 'completed'
fc.form.application_status.data = constants.APPLICATION_STATUS_PENDING
assert fc.validate()
def test_31_application_latest_by_current_journal(self):
j = models.Journal()
j.set_id(j.makeid())
app1 = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
app1.set_id(app1.makeid())
app1.set_current_journal(j.id)
app1.set_created("1970-01-01T00:00:00Z")
app1.save()
app2 = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
app2.set_id(app2.makeid())
app2.set_current_journal(j.id)
app2.set_created("1971-01-01T00:00:00Z")
app2.save(blocking=True)
# check that we find the right application when we search
app3 = models.Suggestion.find_latest_by_current_journal(j.id)
assert app3 is not None
assert app3.id == app2.id
# make sure we get a None response when there's no application
app0 = models.Suggestion.find_latest_by_current_journal("whatever")
assert app0 is None
def test_03_classification_required(self):
# Check we can accept an application with a subject classification present
ready_application = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
ready_application.set_application_status(constants.APPLICATION_STATUS_READY)
fc = formcontext.ApplicationFormFactory.get_form_context(role='admin', source=ready_application)
# Make changes to the application status via the form, check it validates
fc.form.application_status.data = constants.APPLICATION_STATUS_ACCEPTED
assert fc.validate()
# Without a subject classification, we should not be able to set the status to 'accepted'
no_class_application = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
del no_class_application.data['bibjson']['subject']
fc = formcontext.ApplicationFormFactory.get_form_context(role='admin', source=no_class_application)
# Make changes to the application status via the form
assert fc.source.bibjson().subjects() == []
fc.form.application_status.data = constants.APPLICATION_STATUS_ACCEPTED
assert not fc.validate()
# However, we should be able to set it to a different status rather than 'accepted'
fc.form.application_status.data = constants.APPLICATION_STATUS_IN_PROGRESS
assert fc.validate()
def test_02_classification_required(self):
# Check we can mark an application 'completed' with a subject classification present
in_progress_application = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
in_progress_application.set_application_status(
constants.APPLICATION_STATUS_IN_PROGRESS)
fc = formcontext.ApplicationFormFactory.get_form_context(
role='associate_editor', source=in_progress_application)
# Make changes to the application status via the form, check it validates
fc.form.application_status.data = constants.APPLICATION_STATUS_COMPLETED
assert fc.validate()
# Without a subject classification, we should not be able to set the status to 'completed'
no_class_application = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
del no_class_application.data['bibjson']['subject']
fc = formcontext.ApplicationFormFactory.get_form_context(
role='associate_editor', source=no_class_application)
# Make changes to the application status via the form
assert fc.source.bibjson().subjects() == []
fc.form.application_status.data = constants.APPLICATION_STATUS_COMPLETED
assert not fc.validate()
# However, we should be able to set it to a different status rather than 'completed'
fc.form.application_status.data = constants.APPLICATION_STATUS_PENDING
assert fc.validate()
def test_08_publisher_result_filter(self):
apsrc_admin = ApplicationFixtureFactory.make_application_source()['admin']
# Not all of these properties are applicable to applications, but these test objects are not applications:
# they are made-up admin sections designed solely to test whether the filter lets the right keys through.
# We just use applications as a base to construct them.
apsrc_admin['ticked'] = True
apsrc_admin['in_doaj'] = True
apsrc_admin['related_applications'] = [1,2,3]
apsrc_admin['current_application'] = 'abcde'
allowed = ["ticked", "seal", "in_doaj", "related_applications", "current_application", "current_journal", "application_status"]
forbidden = ['notes', 'contact', 'editor_group', 'editor', 'related_journal']
res = {
"hits": {
"hits": [
{ "_type": "article", "_source": { "admin": deepcopy(apsrc_admin), "bibjson": {}}},
{ "_type": "article", "_source": { "admin": deepcopy(apsrc_admin), "bibjson": {}}},
{ "_type": "article", "_source": { "admin": deepcopy(apsrc_admin), "bibjson": {}}}
],
"total": 3
}
}
newres = query_filters.publisher_result_filter(res)
for n, r in enumerate(newres['hits']['hits']):
for allowed_k in allowed:
assert allowed_k in r['_source']['admin'], \
'{} key not found in result {}, but it is allowed and should have been left intact by the filter'.format(allowed_k, n)
for forbidden_k in forbidden:
assert forbidden_k not in r['_source']['admin'], \
'{} key was found in result {}, but it is forbidden and should have been stripped out by the filter'.format(forbidden_k, n)
def test_06_make_journal(self):
s = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
j = s.make_journal()
assert j.id != s.id
assert "suggestion" not in j.data
assert j.data.get("bibjson", {}).get("active")
def create_edit_cases():
application_source = ApplicationFixtureFactory.make_application_source()
account_source = AccountFixtureFactory.make_publisher_source()
editable_application = Suggestion(**application_source)
editable_application.set_application_status(constants.APPLICATION_STATUS_UPDATE_REQUEST)
non_editable_application = Suggestion(**application_source)
non_editable_application.set_application_status(constants.APPLICATION_STATUS_READY)
owner_account = Account(**deepcopy(account_source))
owner_account.set_id(editable_application.owner)
non_owner_publisher = Account(**deepcopy(account_source))
non_publisher = Account(**deepcopy(account_source))
non_publisher.remove_role("publisher")
admin = Account(**deepcopy(account_source))
admin.add_role("admin")
return [
param("no_app_no_account", None, None, raises=exceptions.ArgumentException),
param("no_app_with_account", None, owner_account, raises=exceptions.ArgumentException),
param("app_no_account", editable_application, None, raises=exceptions.ArgumentException),
param("editable_app_owning_account", editable_application, owner_account, expected=True),
param("editable_app_nonowning_account", editable_application, non_owner_publisher, raises=exceptions.AuthoriseException),
param("editable_app_non_publisher_account", editable_application, non_publisher, raises=exceptions.AuthoriseException),
param("editable_app_admin_account", editable_application, admin, expected=True),
param("non_editable_app_owning_account", non_editable_application, owner_account, raises=exceptions.AuthoriseException),
param("non_editable_app_nonowning_account", non_editable_application, non_owner_publisher, raises=exceptions.AuthoriseException),
param("non_editable_app_non_publisher_account", non_editable_application, non_publisher, raises=exceptions.AuthoriseException),
param("non_editable_app_admin_account", non_editable_application, admin, expected=True)
]
def test_09_publisher_result_filter_unpacked(self):
apsrc_admin = ApplicationFixtureFactory.make_application_source(
)['admin']
# Not all of these properties are applicable to applications, but these test objects are not applications:
# they are made-up admin sections designed solely to test whether the filter lets the right keys through.
# We just use applications as a base to construct them.
apsrc_admin['ticked'] = True
apsrc_admin['in_doaj'] = True
apsrc_admin['related_applications'] = [1, 2, 3]
apsrc_admin['current_application'] = 'abcde'
allowed = [
"ticked", "seal", "in_doaj", "related_applications",
"current_application", "current_journal", "application_status"
]
forbidden = [
'notes', 'contact', 'editor_group', 'editor', 'related_journal'
]
res = {"admin": deepcopy(apsrc_admin), "bibjson": {}}
newres = query_filters.publisher_result_filter(res, unpacked=True)
for allowed_k in allowed:
assert allowed_k in newres['admin'], \
'{} key not found in result {}, but it is allowed and should have been left intact by the filter'.format(allowed_k, newres)
for forbidden_k in forbidden:
assert forbidden_k not in newres['admin'], \
'{} key was found in result {}, but it is forbidden and should have been stripped out by the filter'.format(forbidden_k, newres)
def test_09_anonymise_suggestion(self):
asug = anon_export.anonymise_suggestion(
ApplicationFixtureFactory.make_application_source())
assert asug['suggestion']['suggester']['name'] == 'Jon Cole', asug[
'suggestion']['suggester']['name']
assert asug['suggestion']['suggester'][
'email'] == '*****@*****.**', asug[
'suggestion']['suggester']['email']
def test_14_make_journal_from_reapp(self):
# with history
j = models.Journal()
j.set_id("1234567")
j.set_created("2001-01-01T00:00:00Z")
j.add_history({"title" : "old title"})
j.save()
s = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
s.set_current_journal("1234567")
time.sleep(1)
j = s.make_journal()
j.save()
assert j.id == "1234567"
assert "suggestion" not in j.data
assert j.last_reapplication is not None
assert j.data.get("bibjson", {}).get("active")
assert j.current_application is None
assert j.data.get("admin", {}).get("current_journal") is None
assert j.created_date == "2001-01-01T00:00:00Z"
assert j.get_history_raw()[0].get("bibjson", {}).get("title") == "old title"
# without history
j = models.Journal()
j.set_id("1234567")
j.set_created("2001-01-01T00:00:00Z")
j.save()
s = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
s.set_current_journal("1234567")
time.sleep(1)
j = s.make_journal()
j.save()
assert j.id == "1234567"
assert "suggestion" not in j.data
assert j.last_reapplication is not None
assert j.data.get("bibjson", {}).get("active")
assert j.current_application is None
assert j.data.get("admin", {}).get("current_journal") is None
assert j.created_date == "2001-01-01T00:00:00Z"
assert len(j.history()) == 0
def test_32_application_all_by_related_journal(self):
j = models.Journal()
j.set_id(j.makeid())
app1 = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
app1.set_id(app1.makeid())
app1.set_related_journal(j.id)
app1.set_created("1970-01-01T00:00:00Z")
app1.save()
app2 = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
app2.set_id(app2.makeid())
app2.set_related_journal(j.id)
app2.set_created("1971-01-01T00:00:00Z")
app2.save(blocking=True)
# check that we find all the applications when we search, and that they're in the right order
all = models.Suggestion.find_all_by_related_journal(j.id)
assert len(all) == 2
assert all[0].id == app1.id
assert all[1].id == app2.id
def test_03_view_application(self,
name,
account_type,
role,
owner,
application_type,
raises=None,
returns=None,
auth_reason=None):
# set up the objects
application = None
if application_type == "exists":
application = Suggestion(
**ApplicationFixtureFactory.make_application_source())
account = None
if account_type == "exists":
if role == "none":
account = Account(
**AccountFixtureFactory.make_publisher_source())
account.remove_role("publisher")
elif role == "publisher":
account = Account(
**AccountFixtureFactory.make_publisher_source())
elif role == "admin":
account = Account(
**AccountFixtureFactory.make_managing_editor_source())
if owner == "yes":
application.set_owner(account.id)
svc = DOAJ.authorisationService()
if raises is not None and raises != "":
exception = None
with self.assertRaises(EXCEPTIONS[raises]):
try:
svc.can_view_application(account, application)
except Exception as e:
exception = e
raise e
if raises == "AuthoriseException":
if auth_reason == "not_owner":
assert exception.reason == exception.NOT_OWNER
elif auth_reason == "wrong_role":
assert exception.reason == exception.WRONG_ROLE
elif returns is not None:
expected = returns == "true"
assert svc.can_view_application(account, application) is expected
else:
assert False, "Specify either raises or returns"
def test_08_sync_owners(self):
# suggestion with no current_journal
s = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
s.save()
models.Suggestion.refresh()
s = models.Suggestion.pull(s.id)
assert s is not None
# journal with no current_application
j = models.Journal(**JournalFixtureFactory.make_journal_source())
j.save()
models.Journal.refresh()
j = models.Journal.pull(j.id)
assert j is not None
# suggestion with erroneous current_journal
s.set_current_journal("asdklfjsadjhflasdfoasf")
s.save()
models.Suggestion.refresh()
s = models.Suggestion.pull(s.id)
assert s is not None
# journal with erroneous current_application
j.set_current_application("kjwfuiwqhu220952gw")
j.save()
models.Journal.refresh()
j = models.Journal.pull(j.id)
assert j is not None
# suggestion with journal
s.set_owner("my_new_owner")
s.set_current_journal(j.id)
s.save()
models.Journal.refresh()
j = models.Journal.pull(j.id)
assert j.owner == "my_new_owner"
# journal with suggestion
j.set_owner("another_new_owner")
j.set_current_application(s.id)
j.save()
models.Suggestion.refresh()
s = models.Suggestion.pull(s.id)
assert s.owner == "another_new_owner"
def test_08_sync_owners(self):
# suggestion with no current_journal
s = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
s.save()
models.Suggestion.refresh()
s = models.Suggestion.pull(s.id)
assert s is not None
# journal with no current_application
j = models.Journal(**JournalFixtureFactory.make_journal_source())
j.save()
models.Journal.refresh()
j = models.Journal.pull(j.id)
assert j is not None
# suggestion with erroneous current_journal
s.set_current_journal("asdklfjsadjhflasdfoasf")
s.save()
models.Suggestion.refresh()
s = models.Suggestion.pull(s.id)
assert s is not None
# journal with erroneous current_application
j.set_current_application("kjwfuiwqhu220952gw")
j.save()
models.Journal.refresh()
j = models.Journal.pull(j.id)
assert j is not None
# suggestion with journal
s.set_owner("my_new_owner")
s.set_current_journal(j.id)
s.save()
models.Journal.refresh()
j = models.Journal.pull(j.id)
assert j.owner == "my_new_owner"
# journal with suggestion
j.set_owner("another_new_owner")
j.set_current_application(s.id)
j.save()
models.Suggestion.refresh()
s = models.Suggestion.pull(s.id)
assert s.owner == "another_new_owner"
def test_32_application_all_by_related_journal(self):
j = models.Journal()
j.set_id(j.makeid())
app1 = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
app1.set_id(app1.makeid())
app1.set_related_journal(j.id)
app1.set_created("1970-01-01T00:00:00Z")
app1.save()
app2 = models.Suggestion(
**ApplicationFixtureFactory.make_application_source())
app2.set_id(app2.makeid())
app2.set_related_journal(j.id)
app2.set_created("1971-01-01T00:00:00Z")
app2.save(blocking=True)
# check that we find all the applications when we search, and that they're in the right order
all = models.Suggestion.find_all_by_related_journal(j.id)
assert len(all) == 2
assert all[0].id == app1.id
assert all[1].id == app2.id
def test_31_application_latest_by_current_journal(self):
j = models.Journal()
j.set_id(j.makeid())
app1 = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
app1.set_id(app1.makeid())
app1.set_current_journal(j.id)
app1.set_created("1970-01-01T00:00:00Z")
app1.save()
app2 = models.Suggestion(**ApplicationFixtureFactory.make_application_source())
app2.set_id(app2.makeid())
app2.set_current_journal(j.id)
app2.set_created("1971-01-01T00:00:00Z")
app2.save(blocking=True)
# check that we find the right application when we search
app3 = models.Suggestion.find_latest_by_current_journal(j.id)
assert app3 is not None
assert app3.id == app2.id
# make sure we get a None response when there's no application
app0 = models.Suggestion.find_latest_by_current_journal("whatever")
assert app0 is None
def load_application_cases():
account = Account(**AccountFixtureFactory.make_publisher_source())
account.set_id(account.makeid())
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
application.makeid()
wrong_id = uuid.uuid4()
return [
param("a_id_acc_lock", application, application.id, account, True, raises=lock.Locked),
param("a_id_acc_nolock", application, application.id, account, False),
param("a_id_noacc_nolock", application, application.id, None, False),
param("a_noid_noacc_nolock", application, None, None, False, raises=exceptions.ArgumentException),
param("a_wid_noacc_nolock", application, wrong_id, None, False),
param("noa_id_noacc_nolock", None, application.id, None, False),
param("noa_noid_noacc_nolock", None, None, None, False, raises=exceptions.ArgumentException)
]
def test_06_retrieve_application_success(self):
# set up all the bits we need
data = ApplicationFixtureFactory.make_application_source()
ap = models.Suggestion(**data)
ap.save()
time.sleep(2)
account = models.Account()
account.set_id(ap.owner)
account.set_name("Tester")
account.set_email("*****@*****.**")
# call retrieve on the object
a = ApplicationsCrudApi.retrieve(ap.id, account)
# check that we got back the object we expected
assert isinstance(a, OutgoingApplication)
assert a.id == ap.id
def test_06_retrieve_application_success(self):
# set up all the bits we need
data = ApplicationFixtureFactory.make_application_source()
ap = models.Suggestion(**data)
ap.save()
time.sleep(2)
account = models.Account()
account.set_id(ap.owner)
account.set_name("Tester")
account.set_email("*****@*****.**")
# call retrieve on the object
a = ApplicationsCrudApi.retrieve(ap.id, account)
# check that we got back the object we expected
assert isinstance(a, OutgoingApplication)
assert a.id == ap.id
def test_05_outgoing_application_do(self):
# make a blank one
oa = OutgoingApplication()
# make one from an incoming application model fixture
data = ApplicationFixtureFactory.make_application_source()
ap = models.Suggestion(**data)
oa = OutgoingApplication.from_model(ap)
# check that it does not contain information that it shouldn't
assert oa.data.get("index") is None
assert oa.data.get("history") is None
assert oa.data.get("admin", {}).get("notes") is None
assert oa.data.get("admin", {}).get("editor_group") is None
assert oa.data.get("admin", {}).get("editor") is None
assert oa.data.get("admin", {}).get("seal") is None
assert oa.data.get("admin", {}).get("related_journal") is None
# check that it does contain admin information that it should
assert oa.data.get("admin", {}).get("current_journal") is not None
def test_05_outgoing_application_do(self):
# make a blank one
oa = OutgoingApplication()
# make one from an incoming application model fixture
data = ApplicationFixtureFactory.make_application_source()
ap = models.Suggestion(**data)
oa = OutgoingApplication.from_model(ap)
# check that it does not contain information that it shouldn't
assert oa.data.get("index") is None
assert oa.data.get("history") is None
assert oa.data.get("admin", {}).get("notes") is None
assert oa.data.get("admin", {}).get("editor_group") is None
assert oa.data.get("admin", {}).get("editor") is None
assert oa.data.get("admin", {}).get("seal") is None
assert oa.data.get("admin", {}).get("related_journal") is None
# check that it does contain admin information that it should
assert oa.data.get("admin", {}).get("current_journal") is not None
def test_04_maned_review_continuations(self):
# construct it from form data (with a known source)
fc = formcontext.ApplicationFormFactory.get_form_context(
role='admin',
form_data=MultiDict(APPLICATION_FORM),
source=models.Suggestion(**ApplicationFixtureFactory.make_application_source()))
# check the form has the continuations data
assert fc.form.replaces.data == ["1111-1111"]
assert fc.form.is_replaced_by.data == ["2222-2222"]
assert fc.form.discontinued_date.data == "2001-01-01"
# run the crosswalk, don't test it at all in this test
fc.form2target()
# patch the target with data from the source
fc.patch_target()
# ensure the model has the continuations data
assert fc.target.bibjson().replaces == ["1111-1111"]
assert fc.target.bibjson().is_replaced_by == ["2222-2222"]
assert fc.target.bibjson().discontinued_date == "2001-01-01"
def test_03_view_application(self, name, account_type, role, owner, application_type, raises=None, returns=None, auth_reason=None):
# set up the objects
application = None
if application_type == "exists":
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
account = None
if account_type == "exists":
if role == "none":
account = Account(**AccountFixtureFactory.make_publisher_source())
account.remove_role("publisher")
elif role == "publisher":
account = Account(**AccountFixtureFactory.make_publisher_source())
elif role == "admin":
account = Account(**AccountFixtureFactory.make_managing_editor_source())
if owner == "yes":
application.set_owner(account.id)
svc = DOAJ.authorisationService()
if raises is not None and raises != "":
exception = None
with self.assertRaises(EXCEPTIONS[raises]):
try:
svc.can_view_application(account, application)
except Exception as e:
exception = e
raise e
if raises == "AuthoriseException":
if auth_reason == "not_owner":
assert exception.reason == exception.NOT_OWNER
elif auth_reason == "wrong_role":
assert exception.reason == exception.WRONG_ROLE
elif returns is not None:
expected = returns == "true"
assert svc.can_view_application(account, application) is expected
else:
assert False, "Specify either raises or returns"
def test_07_retrieve_application_fail(self):
# set up all the bits we need
data = ApplicationFixtureFactory.make_application_source()
ap = models.Suggestion(**data)
ap.save()
time.sleep(2)
# no user
with self.assertRaises(Api401Error):
a = ApplicationsCrudApi.retrieve(ap.id, None)
# wrong user
account = models.Account()
account.set_id("asdklfjaioefwe")
with self.assertRaises(Api404Error):
a = ApplicationsCrudApi.retrieve(ap.id, account)
# non-existant application
account = models.Account()
account.set_id(ap.id)
with self.assertRaises(Api404Error):
a = ApplicationsCrudApi.retrieve("ijsidfawefwefw", account)
def test_07_retrieve_application_fail(self):
# set up all the bits we need
data = ApplicationFixtureFactory.make_application_source()
ap = models.Suggestion(**data)
ap.save()
time.sleep(2)
# no user
with self.assertRaises(Api401Error):
a = ApplicationsCrudApi.retrieve(ap.id, None)
# wrong user
account = models.Account()
account.set_id("asdklfjaioefwe")
with self.assertRaises(Api404Error):
a = ApplicationsCrudApi.retrieve(ap.id, account)
# non-existant application
account = models.Account()
account.set_id(ap.id)
with self.assertRaises(Api404Error):
a = ApplicationsCrudApi.retrieve("ijsidfawefwefw", account)
def test_09_anonymise_suggestion(self):
asug = anon_export.anonymise_suggestion(ApplicationFixtureFactory.make_application_source())
assert asug['suggestion']['suggester']['name'] == 'Jon Cole', asug['suggestion']['suggester']['name']
assert asug['suggestion']['suggester']['email'] == '*****@*****.**', asug['suggestion']['suggester']['email']
def create_edit_cases():
application_source = ApplicationFixtureFactory.make_application_source()
account_source = AccountFixtureFactory.make_publisher_source()
editable_application = Suggestion(**application_source)
editable_application.set_application_status(
constants.APPLICATION_STATUS_UPDATE_REQUEST)
non_editable_application = Suggestion(**application_source)
non_editable_application.set_application_status(
constants.APPLICATION_STATUS_READY)
owner_account = Account(**deepcopy(account_source))
owner_account.set_id(editable_application.owner)
non_owner_publisher = Account(**deepcopy(account_source))
non_publisher = Account(**deepcopy(account_source))
non_publisher.remove_role("publisher")
admin = Account(**deepcopy(account_source))
admin.add_role("admin")
return [
param("no_app_no_account",
None,
None,
raises=exceptions.ArgumentException),
param("no_app_with_account",
None,
owner_account,
raises=exceptions.ArgumentException),
param("app_no_account",
editable_application,
None,
raises=exceptions.ArgumentException),
param("editable_app_owning_account",
editable_application,
owner_account,
expected=True),
param("editable_app_nonowning_account",
editable_application,
non_owner_publisher,
raises=exceptions.AuthoriseException),
param("editable_app_non_publisher_account",
editable_application,
non_publisher,
raises=exceptions.AuthoriseException),
param("editable_app_admin_account",
editable_application,
admin,
expected=True),
param("non_editable_app_owning_account",
non_editable_application,
owner_account,
raises=exceptions.AuthoriseException),
param("non_editable_app_nonowning_account",
non_editable_application,
non_owner_publisher,
raises=exceptions.AuthoriseException),
param("non_editable_app_non_publisher_account",
non_editable_application,
non_publisher,
raises=exceptions.AuthoriseException),
param("non_editable_app_admin_account",
non_editable_application,
admin,
expected=True)
]
import re
from copy import deepcopy
from werkzeug.datastructures import MultiDict
from portality import constants
from doajtest.fixtures import JournalFixtureFactory, ApplicationFixtureFactory
from doajtest.helpers import DoajTestCase
from portality import models
from portality.formcontext import formcontext
#####################################################################
# Source objects to be used for testing
#####################################################################
UPDATE_REQUEST_SOURCE = ApplicationFixtureFactory.make_application_source()
UPDATE_REQUEST_SOURCE["admin"]["application_status"] = constants.APPLICATION_STATUS_UPDATE_REQUEST
UPDATE_REQUEST_FORM = ApplicationFixtureFactory.make_application_form(role="publisher")
######################################################
# Main test class
######################################################
class TestPublisherUpdateRequestFormContext(DoajTestCase):
def setUp(self):
super(TestPublisherUpdateRequestFormContext, self).setUp()
def tearDown(self):
super(TestPublisherUpdateRequestFormContext, self).tearDown()
eg.set_associates(["associate", "assan"])
eg.set_name("Test Editor Group")
return eg
mock_lcc_choices = [(u'H', u'Social Sciences'),
(u'HB1-3840', u'--Economic theory. Demography')]
def mock_lookup_code(code):
if code == "H": return "Social Sciences"
if code == "HB1-3840": return "Economic theory. Demography"
return None
APPLICATION_SOURCE = ApplicationFixtureFactory.make_application_source()
APPLICATION_FORM = ApplicationFixtureFactory.make_application_form(
role="assed")
######################################################
# Main test class
######################################################
class TestAssedAppReview(DoajTestCase):
def setUp(self):
super(TestAssedAppReview, self).setUp()
self.editor_group_pull = models.EditorGroup.pull_by_key
models.EditorGroup.pull_by_key = editor_group_pull
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_reject_application(self, name, application, application_status, account, prov, current_journal, note, save, raises=None):
#######################################
## set up
if save == "fail":
Suggestion.save = mock_save_fail
ap = None
journal = None
if application == "exists":
ap = Suggestion(**ApplicationFixtureFactory.make_application_source())
ap.set_application_status(application_status)
ap.set_id(ap.makeid())
ap.remove_notes()
if current_journal == "yes":
journal = Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
journal.set_id(journal.makeid())
journal.set_current_application(ap.id)
journal.save(blocking=True)
ap.set_current_journal(journal.id)
else:
ap.remove_current_journal()
acc = None
if account == "publisher":
acc = Account(**AccountFixtureFactory.make_publisher_source())
elif account == "admin":
acc = Account(**AccountFixtureFactory.make_managing_editor_source())
provenance = None
if prov != "none":
provenance = prov == "true"
thenote = None
if note == "yes":
thenote = "abcdefg"
########################################
## execute
svc = DOAJ.applicationService()
if raises is not None and raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.reject_application(ap, acc, provenance, note=thenote)
else:
svc.reject_application(ap, acc, provenance, note=thenote)
time.sleep(1)
#######################################
## Check
ap2 = Suggestion.pull(ap.id)
assert ap2 is not None
assert ap2.application_status == constants.APPLICATION_STATUS_REJECTED
assert ap2.current_journal is None
# check the updated and manually updated date are essentially the same (they can theoretically differ
# by a small amount just based on when they are set)
updated_spread = abs((ap2.last_updated_timestamp - ap2.last_manual_update_timestamp).total_seconds())
assert updated_spread <= 1.0
if current_journal == "yes" and journal is not None:
j2 = Journal.pull(journal.id)
assert j2 is not None
assert j2.current_application is None
assert ap2.related_journal == j2.id
if prov == "true":
pr = Provenance.get_latest_by_resource_id(ap.id)
assert pr is not None
if note == "yes":
assert len(ap2.notes) == 1
assert ap2.notes[0].get("note") == "abcdefg"
elif note == "no":
assert len(ap2.notes) == 0
import logging import re from StringIO import StringIO from copy import deepcopy from portality import constants from doajtest.fixtures import EditorGroupFixtureFactory, AccountFixtureFactory, ApplicationFixtureFactory, JournalFixtureFactory from doajtest.helpers import DoajTestCase from portality import models from portality.formcontext import formcontext APPLICATION_SOURCE_TEST_1 = ApplicationFixtureFactory.make_application_source() APPLICATION_SOURCE_TEST_2 = ApplicationFixtureFactory.make_application_source() APPLICATION_SOURCE_TEST_3 = ApplicationFixtureFactory.make_application_source() APPLICATION_FORM = ApplicationFixtureFactory.make_application_form() JOURNAL_SOURCE_TEST_1 = JournalFixtureFactory.make_journal_source() JOURNAL_SOURCE_TEST_2 = JournalFixtureFactory.make_journal_source() EDITOR_GROUP_SOURCE = EditorGroupFixtureFactory.make_editor_group_source() EDITOR_SOURCE = AccountFixtureFactory.make_editor_source() ASSED1_SOURCE = AccountFixtureFactory.make_assed1_source() ASSED2_SOURCE = AccountFixtureFactory.make_assed2_source() ASSED3_SOURCE = AccountFixtureFactory.make_assed3_source() ##################################################################### # Mocks required to make some of the lookups work ##################################################################### @classmethod def editor_group_pull_by_key(cls, field, value):
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"
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
import logging import re from StringIO import StringIO from copy import deepcopy from portality import constants from doajtest.fixtures import EditorGroupFixtureFactory, AccountFixtureFactory, ApplicationFixtureFactory, JournalFixtureFactory from doajtest.helpers import DoajTestCase from portality import models from portality.formcontext import formcontext APPLICATION_SOURCE_TEST_1 = ApplicationFixtureFactory.make_application_source() APPLICATION_SOURCE_TEST_2 = ApplicationFixtureFactory.make_application_source() APPLICATION_SOURCE_TEST_3 = ApplicationFixtureFactory.make_application_source() APPLICATION_FORM = ApplicationFixtureFactory.make_application_form() JOURNAL_SOURCE_TEST_1 = JournalFixtureFactory.make_journal_source() JOURNAL_SOURCE_TEST_2 = JournalFixtureFactory.make_journal_source() EDITOR_GROUP_SOURCE = EditorGroupFixtureFactory.make_editor_group_source() EDITOR_SOURCE = AccountFixtureFactory.make_editor_source() ASSED1_SOURCE = AccountFixtureFactory.make_assed1_source() ASSED2_SOURCE = AccountFixtureFactory.make_assed2_source() ASSED3_SOURCE = AccountFixtureFactory.make_assed3_source() ##################################################################### # Mocks required to make some of the lookups work ##################################################################### @classmethod
def test_02_application_2_journal(self, name, application_type, manual_update_arg, app_key_properties, current_journal, raises):
# set up for the test
#########################################
cj = None
has_seal = bool(randint(0, 1))
application = None
if application_type == "present":
application = Suggestion(**ApplicationFixtureFactory.make_application_source())
application.set_id(application.makeid())
application.remove_contacts()
application.remove_editor_group()
application.remove_editor()
application.remove_owner()
application.remove_current_journal()
application.remove_notes()
if app_key_properties == "yes":
application.add_contact("Application", "*****@*****.**")
application.set_editor_group("appeditorgroup")
application.set_editor("appeditor")
application.set_owner("appowner")
application.set_seal(has_seal)
application.add_note("Application Note")
if current_journal == "present":
journal = Journal(**JournalFixtureFactory.make_journal_source())
journal.remove_contacts()
journal.add_contact("Journal", "*****@*****.**")
journal.set_editor_group("journaleditorgroup")
journal.set_editor("journaleditor")
journal.set_owner("journalowner")
journal.remove_current_application()
journal.remove_notes()
journal.add_note("Journal Note")
journal.save(blocking=True)
application.set_current_journal(journal.id)
cj = journal
elif current_journal == "missing":
application.set_current_journal("123456789987654321")
manual_update = None
if manual_update_arg == "true":
manual_update = True
elif manual_update_arg == "false":
manual_update = False
# execute the test
########################################
svc = DOAJ.applicationService()
if raises is not None and raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.application_2_journal(application, manual_update)
else:
journal = svc.application_2_journal(application, manual_update)
# check the result
######################################
assert journal is not None
assert isinstance(journal, Journal)
assert journal.is_in_doaj() is True
jbj = journal.bibjson().data
del jbj["active"]
assert jbj == application.bibjson().data
if current_journal == "present":
assert len(journal.related_applications) == 3
else:
assert len(journal.related_applications) == 1
related = journal.related_application_record(application.id)
assert related is not None
if manual_update_arg == "true":
assert journal.last_manual_update is not None and journal.last_manual_update != "1970-01-01T00:00:00Z"
if app_key_properties == "yes":
contacts = journal.contacts()
assert len(contacts) == 1
assert contacts[0].get("name") == "Application"
assert contacts[0].get("email") == "*****@*****.**"
assert journal.editor_group == "appeditorgroup"
assert journal.editor == "appeditor"
assert journal.owner == "appowner"
assert journal.has_seal() == has_seal
if current_journal == "present":
assert len(journal.notes) == 2
else:
assert len(journal.notes) == 1
elif app_key_properties == "no":
if current_journal == "present":
contacts = journal.contacts()
assert len(contacts) == 1
assert contacts[0].get("name") == "Journal"
assert contacts[0].get("email") == "*****@*****.**"
assert journal.editor_group == "journaleditorgroup"
assert journal.editor == "journaleditor"
assert journal.owner == "journalowner"
assert journal.has_seal() == has_seal
assert len(journal.notes) == 2
elif current_journal == "none" or current_journal == "missing":
contacts = journal.contacts()
assert len(contacts) == 0
assert journal.editor_group is None
assert journal.editor is None
assert journal.owner is None
assert journal.has_seal() == has_seal
assert len(journal.notes) == 1
if current_journal == "present":
assert cj.id == journal.id
assert cj.created_date == journal.created_date
eg.set_name("Test Editor Group")
return eg
mock_lcc_choices = [
(u'H', u'Social Sciences'),
(u'HB1-3840', u'--Economic theory. Demography')
]
def mock_lookup_code(code):
if code == "H": return "Social Sciences"
if code == "HB1-3840": return "Economic theory. Demography"
return None
APPLICATION_SOURCE = ApplicationFixtureFactory.make_application_source()
APPLICATION_FORM = ApplicationFixtureFactory.make_application_form(role="assed")
######################################################
# Main test class
######################################################
class TestAssedAppReview(DoajTestCase):
def setUp(self):
super(TestAssedAppReview, self).setUp()
self.editor_group_pull = models.EditorGroup.pull_by_key
models.EditorGroup.pull_by_key = editor_group_pull
self.old_lcc_choices = lcc.lcc_choices
def test_02_application_2_journal(self, name, application_type,
manual_update_arg, app_key_properties,
current_journal, raises):
# set up for the test
#########################################
cj = None
has_seal = bool(randint(0, 1))
application = None
if application_type == "present":
application = Suggestion(
**ApplicationFixtureFactory.make_application_source())
application.set_id(application.makeid())
application.remove_contacts()
application.remove_editor_group()
application.remove_editor()
application.remove_owner()
application.remove_current_journal()
application.remove_notes()
if app_key_properties == "yes":
application.add_contact("Application",
"*****@*****.**")
application.set_editor_group("appeditorgroup")
application.set_editor("appeditor")
application.set_owner("appowner")
application.set_seal(has_seal)
application.add_note("Application Note")
if current_journal == "present":
journal = Journal(
**JournalFixtureFactory.make_journal_source())
journal.remove_contacts()
journal.add_contact("Journal", "*****@*****.**")
journal.set_editor_group("journaleditorgroup")
journal.set_editor("journaleditor")
journal.set_owner("journalowner")
journal.remove_current_application()
journal.remove_notes()
journal.add_note("Journal Note")
journal.save(blocking=True)
application.set_current_journal(journal.id)
cj = journal
elif current_journal == "missing":
application.set_current_journal("123456789987654321")
manual_update = None
if manual_update_arg == "true":
manual_update = True
elif manual_update_arg == "false":
manual_update = False
# execute the test
########################################
svc = DOAJ.applicationService()
if raises is not None and raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.application_2_journal(application, manual_update)
else:
journal = svc.application_2_journal(application, manual_update)
# check the result
######################################
assert journal is not None
assert isinstance(journal, Journal)
assert journal.is_in_doaj() is True
jbj = journal.bibjson().data
del jbj["active"]
assert jbj == application.bibjson().data
if current_journal == "present":
assert len(journal.related_applications) == 3
else:
assert len(journal.related_applications) == 1
related = journal.related_application_record(application.id)
assert related is not None
if manual_update_arg == "true":
assert journal.last_manual_update is not None and journal.last_manual_update != "1970-01-01T00:00:00Z"
if app_key_properties == "yes":
contacts = journal.contacts()
assert len(contacts) == 1
assert contacts[0].get("name") == "Application"
assert contacts[0].get("email") == "*****@*****.**"
assert journal.editor_group == "appeditorgroup"
assert journal.editor == "appeditor"
assert journal.owner == "appowner"
assert journal.has_seal() == has_seal
if current_journal == "present":
assert len(journal.notes) == 2
else:
assert len(journal.notes) == 1
elif app_key_properties == "no":
if current_journal == "present":
contacts = journal.contacts()
assert len(contacts) == 1
assert contacts[0].get("name") == "Journal"
assert contacts[0].get("email") == "*****@*****.**"
assert journal.editor_group == "journaleditorgroup"
assert journal.editor == "journaleditor"
assert journal.owner == "journalowner"
assert journal.has_seal() == has_seal
assert len(journal.notes) == 2
elif current_journal == "none" or current_journal == "missing":
contacts = journal.contacts()
assert len(contacts) == 0
assert journal.editor_group is None
assert journal.editor is None
assert journal.owner is None
assert journal.has_seal() == has_seal
assert len(journal.notes) == 1
if current_journal == "present":
assert cj.id == journal.id
assert cj.created_date == journal.created_date
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
def test_01_reject_application(self,
name,
application,
application_status,
account,
prov,
current_journal,
note,
save,
raises=None):
#######################################
## set up
if save == "fail":
Suggestion.save = mock_save_fail
ap = None
journal = None
if application == "exists":
ap = Suggestion(
**ApplicationFixtureFactory.make_application_source())
ap.set_application_status(application_status)
ap.set_id(ap.makeid())
ap.remove_notes()
if current_journal == "yes":
journal = Journal(**JournalFixtureFactory.make_journal_source(
in_doaj=True))
journal.set_id(journal.makeid())
journal.set_current_application(ap.id)
journal.save(blocking=True)
ap.set_current_journal(journal.id)
else:
ap.remove_current_journal()
acc = None
if account == "publisher":
acc = Account(**AccountFixtureFactory.make_publisher_source())
elif account == "admin":
acc = Account(
**AccountFixtureFactory.make_managing_editor_source())
provenance = None
if prov != "none":
provenance = prov == "true"
thenote = None
if note == "yes":
thenote = "abcdefg"
########################################
## execute
svc = DOAJ.applicationService()
if raises is not None and raises != "":
with self.assertRaises(EXCEPTIONS[raises]):
svc.reject_application(ap, acc, provenance, note=thenote)
else:
svc.reject_application(ap, acc, provenance, note=thenote)
time.sleep(1)
#######################################
## Check
ap2 = Suggestion.pull(ap.id)
assert ap2 is not None
assert ap2.application_status == constants.APPLICATION_STATUS_REJECTED
assert ap2.current_journal is None
# check the updated and manually updated date are essentially the same (they can theoretically differ
# by a small amount just based on when they are set)
updated_spread = abs(
(ap2.last_updated_timestamp -
ap2.last_manual_update_timestamp).total_seconds())
assert updated_spread <= 1.0
if current_journal == "yes" and journal is not None:
j2 = Journal.pull(journal.id)
assert j2 is not None
assert j2.current_application is None
assert ap2.related_journal == j2.id
if prov == "true":
pr = Provenance.get_latest_by_resource_id(ap.id)
assert pr is not None
if note == "yes":
assert len(ap2.notes) == 1
assert ap2.notes[0].get("note") == "abcdefg"
elif note == "no":
assert len(ap2.notes) == 0
