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_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_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