def test_03_retrieve_public_journal_success(self): # set up all the bits we need data = JournalFixtureFactory.make_journal_source( in_doaj=True, include_obsolete_fields=True) j = models.Journal(**data) j.save() time.sleep(2) a = JournalsCrudApi.retrieve(j.id, account=None) # check that we got back the object we expected assert isinstance(a, OutgoingJournal) assert a.id == j.id # it should also work if we're logged in with the owner or another user # owner first account = models.Account() account.set_id(j.owner) account.set_name("Tester") account.set_email("*****@*****.**") a = JournalsCrudApi.retrieve(j.id, account) assert isinstance(a, OutgoingJournal) assert a.id == j.id # try with another account not_owner = models.Account() not_owner.set_id("asdklfjaioefwe") a = JournalsCrudApi.retrieve(j.id, not_owner) assert isinstance(a, OutgoingJournal) assert a.id == j.id
def test_07_retrieve_article_fail(self): # set up all the bits we need # add a journal to the account account = models.Account() account.set_id('test') account.set_name("Tester") account.set_email("*****@*****.**") journal = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True)) journal.set_owner(account.id) journal.save() time.sleep(1) data = ArticleFixtureFactory.make_article_source() data['admin']['in_doaj'] = False ap = models.Article(**data) ap.save() time.sleep(1) # should fail when no user and in_doaj is False with self.assertRaises(Api401Error): a = ArticlesCrudApi.retrieve(ap.id, None) # wrong user account = models.Account() account.set_id("asdklfjaioefwe") with self.assertRaises(Api404Error): a = ArticlesCrudApi.retrieve(ap.id, account) # non-existant article account = models.Account() account.set_id(ap.id) with self.assertRaises(Api404Error): a = ArticlesCrudApi.retrieve("ijsidfawefwefw", account)
def setUp(self): super(TestTaskJournalBulkEdit, self).setUp() self.default_eg = EditorGroupFixtureFactory.setup_editor_group_with_editors( ) acc = models.Account() acc.set_id("0987654321") acc.set_email("*****@*****.**") acc.save() egs = EditorGroupFixtureFactory.make_editor_group_source( "1234567890", "0987654321") egm = models.EditorGroup(**egs) egm.save(blocking=True) self.journals = [] for j_src in JournalFixtureFactory.make_many_journal_sources( count=TEST_JOURNAL_COUNT): self.journals.append(models.Journal(**j_src)) self.journals[-1].set_editor_group("1234567890") self.journals[-1].set_editor("0987654321") self.journals[-1].save(blocking=True) self.forbidden_accounts = [ AccountFixtureFactory.make_editor_source()['id'], AccountFixtureFactory.make_assed1_source()['id'], AccountFixtureFactory.make_assed2_source()['id'], AccountFixtureFactory.make_assed3_source()['id'] ] self._make_and_push_test_context(acc=models.Account( **AccountFixtureFactory.make_managing_editor_source()))
def test_05_test_via_endpoint(self): """ Use a request context to test the API via the route """ # set up all the bits we need data = ApplicationFixtureFactory.incoming_application() del data["admin"]["current_journal"] dataset = [data] * 10 # create the main account we're going to work as account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") account.generate_api_key() account.add_role('publisher') account.add_role('api') account.save(blocking=True) # Add another user who doesn't own these articles somebody_else = models.Account() somebody_else.set_id("somebody_else") somebody_else.set_name("Somebody Else") somebody_else.set_email("*****@*****.**") somebody_else.generate_api_key() somebody_else.add_role('publisher') somebody_else.add_role('api') somebody_else.save(blocking=True) assert account.api_key != somebody_else.api_key with self.app_test.test_request_context(): with self.app_test.test_client() as t_client: # Create some new applications resp = t_client.post(url_for('api_v1.bulk_application_create', api_key=account.api_key), data=json.dumps(dataset)) assert resp.status_code == 201 reply = json.loads(resp.data) assert len(reply) == len(dataset) first_apl = reply.pop() assert first_apl['status'] == 'created' # Check we actually created new records time.sleep(1) assert len(models.Suggestion.all()) == len(dataset) # Bulk delete all_but_one = [new_art['id'] for new_art in reply] resp = t_client.delete(url_for( 'api_v1.bulk_application_delete', api_key=account.api_key), data=json.dumps(all_but_one)) assert resp.status_code == 204 time.sleep(1) # we should have deleted all but one of the applications. assert len(models.Suggestion.all()) == 1 # And our other user isn't allowed to delete the remaining one. resp = t_client.delete(url_for( 'api_v1.bulk_application_delete', api_key=somebody_else.api_key), data=json.dumps([first_apl['id']])) assert resp.status_code == 400
def setUp(self): super(TestTaskSuggestionBulkEdit, self).setUp() acc = models.Account() acc.set_id("0987654321") acc.set_email("*****@*****.**") acc.save() egs = EditorGroupFixtureFactory.make_editor_group_source( "1234567890", "0987654321") egm = models.EditorGroup(**egs) egm.save(blocking=True) self.suggestions = [] for app_src in ApplicationFixtureFactory.make_many_application_sources( count=TEST_SUGGESTION_COUNT): self.suggestions.append(models.Suggestion(**app_src)) self.suggestions[-1].set_editor_group("1234567890") self.suggestions[-1].set_editor("0987654321") self.suggestions[-1].save() self.default_eg = EditorGroupFixtureFactory.setup_editor_group_with_editors( ) self.forbidden_accounts = [ AccountFixtureFactory.make_editor_source()['id'], AccountFixtureFactory.make_assed1_source()['id'], AccountFixtureFactory.make_assed2_source()['id'], AccountFixtureFactory.make_assed3_source()['id'] ] self._make_and_push_test_context(acc=models.Account( **AccountFixtureFactory.make_managing_editor_source()))
def test_03_query_svc_get_config(self): qsvc = QueryService() cfg = qsvc._get_config_for_search('query', 'article', account=None) assert cfg == { "auth": False, "role": None, "query_filters": ["only_in_doaj"], "result_filters": ["public_result_filter"], "dao": "portality.models.Article" }, cfg with self.assertRaises(exceptions.AuthoriseException): cfg = qsvc._get_config_for_search('query_nonexistent', 'article', account=None) with self.assertRaises(exceptions.AuthoriseException): cfg = qsvc._get_config_for_search('query', 'article_nonexistent', account=None) with self.assertRaises( exceptions.AuthoriseException ): # because account is None and auth is required cfg = qsvc._get_config_for_search('publisher_query', 'journal', account=None) pub = models.Account(**AccountFixtureFactory.make_publisher_source()) cfg = qsvc._get_config_for_search('publisher_query', 'journal', account=pub) assert cfg == { "auth": True, "role": "publisher", "query_filters": ["owner", "only_in_doaj"], "result_filters": ["publisher_result_filter"], "dao": "portality.models.Journal" } with self.assertRaises( exceptions.AuthoriseException ): # because account is a publisher and an 'admin' role is needed cfg = qsvc._get_config_for_search('admin_query', 'journal', account=pub) maned = models.Account( **AccountFixtureFactory.make_managing_editor_source()) cfg = qsvc._get_config_for_search('admin_query', 'journal', account=maned) assert cfg == { "auth": True, "role": "admin", "dao": "portality.models.Journal" }
def test_01_publishers_with_consent(self): # output file to save csv output_file = os.path.join(self.tmp_dir, 'accounts.csv') # Create accounts with marketing consent not set for i in range(20): pubsource = AccountFixtureFactory.make_publisher_source() pubaccount = models.Account(**pubsource) pubaccount.set_id() pubaccount.save() # Create accounts with marketing consent set to False for i in range(20): pubsource = AccountFixtureFactory.make_publisher_source() pubaccount = models.Account(**pubsource) pubaccount.set_id() pubaccount.set_marketing_consent(False) pubaccount.save() # Create accounts with marketing consent set to True expected_data = [[ u'ID', u'Name', u'Email', u'Created', u'Last Updated', u'Updated Since Create?' ]] for i in range(20): pubsource = AccountFixtureFactory.make_publisher_source() pubaccount = models.Account(**pubsource) pubaccount.set_id() pubaccount.set_marketing_consent(True) if i == 19: pubaccount.save(blocking=True) else: pubaccount.save() expected_data.append([ unicode(pubaccount.id), unicode(pubaccount.name), unicode(pubaccount.email), unicode(pubaccount.created_date), unicode(pubaccount.last_updated), unicode('False') ]) publishers_with_consent(output_file) assert os.path.exists(output_file) table = [] with codecs.open(output_file, "rb", "utf-8") as f: reader = clcsv.UnicodeReader(f) for row in reader: table.append(row) assert len(table) == 21 self.assertItemsEqual(table, expected_data)
def editor_account_pull(self, _id): if _id == 'eddie': return models.Account(**EDITOR_SOURCE) if _id == 'associate': return models.Account(**ASSED1_SOURCE) if _id == 'associate_2': return models.Account(**ASSED2_SOURCE) if _id == 'associate_3': return models.Account(**ASSED3_SOURCE) else: return ACTUAL_ACCOUNT_PULL(_id)
def setup_editor_group_with_editors(cls, group_name=DEFAULT_EDITOR_GROUP_NAME): from portality import models from doajtest.fixtures import AccountFixtureFactory models.Account(**AccountFixtureFactory.make_editor_source()).save() models.Account(**AccountFixtureFactory.make_assed1_source()).save() models.Account(**AccountFixtureFactory.make_assed2_source()).save() models.Account(**AccountFixtureFactory.make_assed3_source()).save() eg = models.EditorGroup(**cls.make_editor_group_source(group_name=group_name, editor="eddie")) eg.save(blocking=True) return eg
def test_05_delete_articles_fail(self): # set up all the bits we need dataset = [] for i in range(10): data = ArticleFixtureFactory.make_incoming_api_article( doi="10.123/test/" + str(i), fulltext="http://example.com/" + str(i)) dataset.append(data) # create the main account we're going to work as article_owner = models.Account() article_owner.set_id("test") article_owner.set_name("Tester") article_owner.set_email("*****@*****.**") # create another account which will own the articles so the one # above will be "another user" trying to delete our precious articles. somebody_else = models.Account() somebody_else.set_id("somebody_else") somebody_else.set_name("Somebody Else") somebody_else.set_email("*****@*****.**") # add a journal to the article owner account to create that link # between account and articles journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_owner(article_owner.id) journal.save() time.sleep(1) # call create on the objects (which will save it to the index) ids = ArticlesBulkApi.create(dataset, article_owner) # let the index catch up time.sleep(2) # call delete on the object in various context that will fail # without an account with self.assertRaises(Api401Error): ArticlesBulkApi.delete(ids, None) # with the wrong account article_owner.set_id("other") with self.assertRaises(Api400Error): ArticlesBulkApi.delete(ids, somebody_else) # on the wrong id ids.append("adfasdfhwefwef") article_owner.set_id("test") with self.assertRaises(Api400Error): ArticlesBulkApi.delete(ids, article_owner) with self.assertRaises(Api400Error): ArticlesBulkApi.delete(ids, article_owner)
def test_01_publishers_with_consent(self): # output file to save csv output_file = os.path.join(self.tmp_dir, 'accounts.csv') # Create accounts with marketing consent not set for i in range(20): pubsource = AccountFixtureFactory.make_publisher_source() pubaccount = models.Account(**pubsource) pubaccount.set_id() pubaccount.save() # Create accounts with marketing consent set to False for i in range(20): pubsource = AccountFixtureFactory.make_publisher_source() pubaccount = models.Account(**pubsource) pubaccount.set_id() pubaccount.set_marketing_consent(False) pubaccount.save() # Create accounts with marketing consent set to True expected_data = [[ 'ID', 'Name', 'Email', 'Created', 'Last Updated', 'Updated Since Create?' ]] for i in range(20): pubsource = AccountFixtureFactory.make_publisher_source() pubaccount = models.Account(**pubsource) pubaccount.set_id() pubaccount.set_marketing_consent(True) if i == 19: pubaccount.save(blocking=True) else: pubaccount.save() expected_data.append([ str(pubaccount.id), str(pubaccount.name), str(pubaccount.email), str(pubaccount.created_date), str(pubaccount.last_updated), str('False') ]) publishers_with_consent(output_file) assert os.path.exists(output_file) table = [] with open(output_file, "r", encoding="utf-8") as f: reader = csv.reader(f) for row in reader: table.append(row) assert len(table) == 21, "expected: 21, received: {}".format( len(table)) self.assertCountEqual(table, expected_data)
def test_03b_create_update_request_fail(self): # update request target not found with self.assertRaises(Api404Error): data = ApplicationFixtureFactory.incoming_application() publisher = models.Account( **AccountFixtureFactory.make_publisher_source()) try: a = ApplicationsCrudApi.create(data, publisher) except Api404Error as e: raise # if a formcontext exception is raised on finalise publisher = models.Account( **AccountFixtureFactory.make_publisher_source()) journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_id(journal.makeid()) journal.set_owner(publisher.id) journal.save(blocking=True) formcontext.FormContext.finalise = mock_finalise_exception with self.assertRaises(Api400Error): data = ApplicationFixtureFactory.incoming_application() data["admin"]["current_journal"] = journal.id try: a = ApplicationsCrudApi.create(data, publisher) except Api400Error as e: assert str(e) == "test exception" raise formcontext.FormContext.finalise = self.old_finalise # validation fails on the formcontext publisher = models.Account( **AccountFixtureFactory.make_publisher_source()) journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_id(journal.makeid()) journal.set_owner(publisher.id) journal.save(blocking=True) IncomingApplication.custom_validate = mock_custom_validate_always_pass with self.assertRaises(Api400Error): data = ApplicationFixtureFactory.incoming_application() # duff submission charges url should trip the validator data["bibjson"]["submission_charges_url"] = "not a url!" data["admin"]["current_journal"] = journal.id try: a = ApplicationsCrudApi.create(data, publisher) except Api400Error as e: raise
def test_11_delete_article_fail(self): # set up all the bits we need account = models.Account() account.set_id('test') account.set_name("Tester") account.set_email("*****@*****.**") journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_owner(account.id) journal.save() time.sleep(1) data = ArticleFixtureFactory.make_article_source() # call create on the object (which will save it to the index) a = ArticlesCrudApi.create(data, account) # let the index catch up time.sleep(1) # call delete on the object in various context that will fail # without an account with self.assertRaises(Api401Error): ArticlesCrudApi.delete(a.id, None) # with the wrong account account.set_id("other") with self.assertRaises(Api404Error): ArticlesCrudApi.delete(a.id, account) # on the wrong id account.set_id("test") with self.assertRaises(Api404Error): ArticlesCrudApi.delete("adfasdfhwefwef", account)
def test_10_delete_article_success(self): # set up all the bits we need account = models.Account() account.set_id('test') account.set_name("Tester") account.set_email("*****@*****.**") journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_owner(account.id) journal.save() time.sleep(1) data = ArticleFixtureFactory.make_article_source() # call create on the object (which will save it to the index) a = ArticlesCrudApi.create(data, account) # let the index catch up time.sleep(1) # now delete it ArticlesCrudApi.delete(a.id, account) # let the index catch up time.sleep(1) ap = models.Article.pull(a.id) assert ap is None
def test_03_delete_application_success(self): # set up all the bits we need data = ApplicationFixtureFactory.incoming_application() del data["admin"]["current_journal"] dataset = [data] * 10 # create the account we're going to work as account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") account.add_role("publisher") # call create on the objects (which will save it to the index) ids = ApplicationsBulkApi.create(dataset, account) # let the index catch up time.sleep(2) # now delete half of them dels = ids[:5] ApplicationsBulkApi.delete(dels, account) # let the index catch up time.sleep(2) for id in dels: ap = models.Suggestion.pull(id) assert ap is None for id in ids[5:]: ap = models.Suggestion.pull(id) assert ap is not None
def test_13_create_application_update_request_success(self): # set up all the bits we need data = ApplicationFixtureFactory.incoming_application() account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") account.add_role("publisher") account.save(blocking=True) journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.bibjson().remove_identifiers() journal.bibjson().add_identifier(journal.bibjson().E_ISSN, "9999-8888") journal.bibjson().add_identifier(journal.bibjson().P_ISSN, "7777-6666") journal.bibjson().title = "not changed" journal.set_id(data["admin"]["current_journal"]) journal.set_owner(account.id) journal.save(blocking=True) # call create on the object (which will save it to the index) a = ApplicationsCrudApi.create(data, account) # check that it got created with the right properties assert isinstance(a, models.Suggestion) assert a.id != "ignore_me" assert a.created_date != "2001-01-01T00:00:00Z" assert a.last_updated != "2001-01-01T00:00:00Z" assert a.suggester.get( "name" ) == "Tester" # The suggester should be the owner of the existing journal assert a.suggester.get("email") == "*****@*****.**" assert a.owner == "test" assert a.suggested_on is not None assert a.bibjson().issns() == [ "9999-8888", "7777-6666" ] or a.bibjson().issns() == ["7777-6666", "9999-8888"] assert a.bibjson().title == "not changed" # also, because it's a special case, check the archiving_policy archiving_policy = a.bibjson().archiving_policy assert len(archiving_policy.get("policy")) == 4 lcount = 0 scount = 0 for ap in archiving_policy.get("policy"): if isinstance(ap, list): lcount += 1 assert ap[0] in ["A national library", "Other"] assert ap[1] in ["Trinity", "A safe place"] else: scount += 1 assert lcount == 2 assert scount == 2 assert "CLOCKSS" in archiving_policy.get("policy") assert "LOCKSS" in archiving_policy.get("policy") time.sleep(2) s = models.Suggestion.pull(a.id) assert s is not None
def test_14_create_application_update_request_fail(self): data = ApplicationFixtureFactory.incoming_application() journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.bibjson().remove_identifiers() journal.bibjson().add_identifier(journal.bibjson().E_ISSN, "9999-8888") journal.bibjson().add_identifier(journal.bibjson().P_ISSN, "7777-6666") journal.bibjson().title = "not changed" journal.set_id(data["admin"]["current_journal"]) journal.set_owner("test") journal.save(blocking=True) # if the account is dud with self.assertRaises(Api401Error): a = ApplicationsCrudApi.create(data, None) # if the data is bust with self.assertRaises(Api400Error): account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") data = {"some": {"junk": "data"}} a = ApplicationsCrudApi.create(data, account)
def test_01_maned_review_success(self): """Give the editor's application form a full workout""" acc = models.Account() acc.set_id("richard") acc.add_role("admin") ctx = self._make_and_push_test_context(acc=acc) # we start by constructing it from source fc = formcontext.ApplicationFormFactory.get_form_context(role="admin", source=models.Suggestion(**APPLICATION_SOURCE)) assert isinstance(fc, formcontext.ManEdApplicationReview) assert fc.form is not None assert fc.source is not None assert fc.form_data is None assert fc.template is not None # no need to check form rendering - there are no disabled fields # now 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(**APPLICATION_SOURCE)) assert isinstance(fc, formcontext.ManEdApplicationReview) assert fc.form is not None assert fc.source is not None assert fc.form_data is not None # test each of the workflow components individually ... # pre-validate and ensure that the disabled fields get re-set fc.pre_validate() # no disabled fields, so just test the function runs # run the validation itself fc.form.subject.choices = mock_lcc_choices # set the choices allowed for the subject manually (part of the test) assert fc.validate(), fc.form.errors # run the crosswalk (no need to look in detail, xwalks are tested elsewhere) fc.form2target() assert fc.target is not None # patch the target with data from the source fc.patch_target() assert fc.target.created_date == "2000-01-01T00:00:00Z" assert fc.target.id == "abcdefghijk" assert fc.target.current_journal == "123456789987654321" assert fc.target.related_journal == "987654321123456789" # everything else is overridden by the form, so no need to check it has patched # now do finalise (which will also re-run all of the steps above) fc.finalise() time.sleep(2) # now check that a provenance record was recorded prov = models.Provenance.get_latest_by_resource_id(fc.target.id) assert prov is not None ctx.pop()
def test_05_maned_review_accept(self): """Give the editor's application form a full workout""" acc = models.Account() acc.set_id("richard") acc.add_role("admin") ctx = self._make_and_push_test_context(acc=acc) # construct a context from a form submission source = deepcopy(APPLICATION_FORM) source["application_status"] = constants.APPLICATION_STATUS_ACCEPTED fd = MultiDict(source) fc = formcontext.ApplicationFormFactory.get_form_context( role="admin", form_data=fd, source=models.Suggestion(**APPLICATION_SOURCE)) fc.finalise() time.sleep(2) # now check that a provenance record was recorded count = 0 for prov in models.Provenance.iterall(): if prov.action == "edit": count += 1 if prov.action == "status:accepted": count += 10 assert count == 11 ctx.pop()
def test_15_create_application_update_request_dryrun(self): # set up all the bits we need data = ApplicationFixtureFactory.incoming_application() account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") account.add_role("publisher") journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.bibjson().remove_identifiers() journal.bibjson().add_identifier(journal.bibjson().E_ISSN, "9999-8888") journal.bibjson().add_identifier(journal.bibjson().P_ISSN, "7777-6666") journal.bibjson().title = "not changed" journal.set_id(data["admin"]["current_journal"]) journal.set_owner(account.id) journal.save(blocking=True) # call create on the object, with the dry_run flag set a = ApplicationsCrudApi.create(data, account, dry_run=True) time.sleep(2) # now check that the application index remains empty ss = [x for x in models.Suggestion.iterall()] assert len(ss) == 0
def test_03_create_articles_fail(self): # if the account is dud with self.assertRaises(Api401Error): data = ArticleFixtureFactory.make_incoming_api_article() dataset = [data] * 10 ids = ArticlesBulkApi.create(dataset, None) # check that the index is empty, as none of them should have been made all = [x for x in models.Article.iterall()] assert len(all) == 0 # if the data is bust with self.assertRaises(Api400Error): account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") # add a journal to the account journal = models.Journal( **JournalFixtureFactory.make_journal_source(in_doaj=True)) journal.set_owner(account.id) journal.save() time.sleep(1) dataset = dataset[:5] + [{"some": {"junk": "data"}}] + dataset[5:] ids = ArticlesBulkApi.create(dataset, account) # check that the index is empty, as none of them should have been made all = [x for x in models.Article.iterall()] assert len(all) == 0
def test_01_create_applications_success(self): # set up all the bits we need - 10 applications data = ApplicationFixtureFactory.incoming_application() del data["admin"]["current_journal"] dataset = [data] * 10 # create an account that we'll do the create as account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") # call create on the object (which will save it to the index) ids = ApplicationsBulkApi.create(dataset, account) # check that we got the right number of ids back assert len(ids) == 10 # let the index catch up time.sleep(2) # check that each id was actually created for id in ids: s = models.Suggestion.pull(id) assert s is not None
def anonymise_account(record): try: a = models.Account(**record) except DataStructureException: return record return _anonymise_email(a).data
def setUp(self): super(TestTaskJournalBulkDelete, self).setUp() self.journals = [] self.articles = [] for j_src in JournalFixtureFactory.make_many_journal_sources( count=TEST_JOURNAL_COUNT): j = models.Journal(**j_src) self.journals.append(j) j.save() for i in range(0, TEST_ARTICLES_PER_JOURNAL): a = models.Article(**ArticleFixtureFactory.make_article_source( with_id=False, eissn=j.bibjson().first_eissn, pissn=j.bibjson().first_pissn)) a.save() self.articles.append(a) sleep(2) self.forbidden_accounts = [ AccountFixtureFactory.make_editor_source()['id'], AccountFixtureFactory.make_assed1_source()['id'], AccountFixtureFactory.make_assed2_source()['id'], AccountFixtureFactory.make_assed3_source()['id'] ] self._make_and_push_test_context(acc=models.Account( **AccountFixtureFactory.make_managing_editor_source()))
def test_02_create_duplicate_articles(self): # set up all the bits we need - 10 articles data = ArticleFixtureFactory.make_incoming_api_article() dataset = [data] * 10 # create an account that we'll do the create as account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") # add a journal to the account journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_owner(account.id) journal.save() time.sleep(2) # call create on the object (which will save it to the index) with self.assertRaises(Api400Error): ids = ArticlesBulkApi.create(dataset, account) time.sleep(2) with self.assertRaises(ESMappingMissingError): all_articles = models.Article.all()
def test_01_create_articles_success(self): def find_dict_in_list(lst, key, value): for i, dic in enumerate(lst): if dic[key] == value: return i return -1 # set up all the bits we need - 10 articles dataset = [] for i in range(1, 11): data = ArticleFixtureFactory.make_incoming_api_article() # change the DOI and fulltext URLs to escape duplicate detection # and try with multiple articles doi_ix = find_dict_in_list(data['bibjson']['identifier'], 'type', 'doi') if doi_ix == -1: data['bibjson']['identifier'].append({"type": "doi"}) data['bibjson']['identifier'][doi_ix][ 'id'] = '10.0000/SOME.IDENTIFIER.{0}'.format(i) fulltext_url_ix = find_dict_in_list(data['bibjson']['link'], 'type', 'fulltext') if fulltext_url_ix == -1: data['bibjson']['link'].append({"type": "fulltext"}) data['bibjson']['link'][fulltext_url_ix][ 'url'] = 'http://www.example.com/article_{0}'.format(i) dataset.append(deepcopy(data)) # create an account that we'll do the create as account = models.Account() account.set_id("test") account.set_name("Tester") account.set_email("*****@*****.**") # add a journal to the account journal = models.Journal(**JournalFixtureFactory.make_journal_source( in_doaj=True)) journal.set_owner(account.id) journal.save() time.sleep(2) # call create on the object (which will save it to the index) ids = ArticlesBulkApi.create(dataset, account) # check that we got the right number of ids back assert len(ids) == 10 assert len(list(set(ids))) == 10, len(list( set(ids))) # are they actually 10 unique IDs? # let the index catch up time.sleep(2) # check that each id was actually created for id in ids: s = models.Article.pull(id) assert s is not None
def test_05_editor_revert_to_in_progress(self): """ Check that editors are permitted to revert applications from 'completed' to 'in progress' """ acc = models.Account() acc.set_id("contextuser") acc.add_role("editor") ctx = self._make_and_push_test_context(acc=acc) # There should be an associate editor to receive an email when the status is changed associate_account = models.Account( **AccountFixtureFactory.make_assed1_source()) associate_account.save(blocking=True) # Check that an editor can change from 'completed' to 'in progress' after a failed review completed_source = APPLICATION_SOURCE.copy() completed_source['admin'][ 'application_status'] = constants.APPLICATION_STATUS_COMPLETED in_progress_form = APPLICATION_FORM.copy() in_progress_form[ 'application_status'] = constants.APPLICATION_STATUS_IN_PROGRESS # Construct the formcontext from form data (with a known source) fc = formcontext.ApplicationFormFactory.get_form_context( role="editor", form_data=MultiDict(in_progress_form), source=models.Suggestion(**completed_source)) assert isinstance(fc, formcontext.EditorApplicationReview) assert fc.form is not None assert fc.source is not None assert fc.form_data is not None # Finalise the formcontext. This should raise an exception because the application has already been accepted. fc.finalise() time.sleep(1.5) # now check that a provenance record was recorded prov = models.Provenance.get_latest_by_resource_id(fc.target.id) assert prov is not None ctx.pop()
def test_03_associate_review_complete(self): """Give the editor's application form a full workout""" acc = models.Account() acc.set_id("contextuser") acc.add_role("associate_editor") ctx = self._make_and_push_test_context(acc=acc) editor = models.Account() editor.set_id("editor") editor.set_email("*****@*****.**") editor.save() eg = models.EditorGroup() eg.set_name(APPLICATION_SOURCE["admin"]["editor_group"]) eg.set_editor("editor") eg.add_associate("contextuser") eg.save() time.sleep(2) # construct a context from a form submission source = deepcopy(APPLICATION_FORM) source["application_status"] = constants.APPLICATION_STATUS_COMPLETED fd = MultiDict(source) fc = formcontext.ApplicationFormFactory.get_form_context( role="associate_editor", form_data=fd, source=models.Suggestion(**APPLICATION_SOURCE)) fc.finalise() time.sleep(2) # now check that a provenance record was recorded count = 0 for prov in models.Provenance.iterall(): if prov.action == "edit": count += 1 if prov.action == "status:completed": count += 10 assert count == 11 ctx.pop()
def publishers_with_journals(): """ Get accounts for all publishers with journals in the DOAJ """ for acc in esprit.tasks.scroll(conn, 'account', q=MISSING_PASSWORD, page_size=100, keepalive='1m'): publisher_account = models.Account(**acc) journal_ids = publisher_account.journal if journal_ids is not None: for j in journal_ids: journal = models.Journal.pull(j) if journal is not None and journal.is_in_doaj(): yield publisher_account break
def anonymise_account(record): try: a = models.Account(**record) except DataStructureException: return record a = _anonymise_email(a) a = _reset_api_key(a) a = _reset_password(a) return a.data