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