def setup(self):
author_1 = AuthorFactory.create(lastname='Abc', firstname='Def')
author_2 = AuthorFactory.create(lastname='Def', firstname='ghi')
JournalType.objects.create(code='S')
JournalType.objects.create(code='C')
self.collection_1 = CollectionFactory.create()
self.thesis_1 = ThesisFactory.create(
localidentifier='t1', collection=self.collection_1, author=author_1, title='Thesis A',
publication_year=2014)
self.thesis_2 = ThesisFactory.create(
localidentifier='t2', collection=self.collection_1, author=author_2, title='Thesis B',
publication_year=2011)
author_3 = AuthorFactory.create(lastname='Ghi', firstname='Jkl')
author_4 = AuthorFactory.create(lastname='Jkl', firstname='mno')
self.journal_1 = JournalFactory.create(
collection=self.collection, type=JournalType.objects.get(code='S'))
self.journal_2 = JournalFactory.create(
collection=self.collection, type=JournalType.objects.get(code='C'))
self.issue_1 = IssueFactory.create(journal=self.journal_1, year=2012)
self.issue_2 = IssueFactory.create(journal=self.journal_2, year=2013)
self.article_1 = ArticleFactory.create(title='Title A', issue=self.issue_1)
self.article_2 = ArticleFactory.create(title='Title B', issue=self.issue_1)
self.article_3 = ArticleFactory.create(title='Title C', issue=self.issue_2)
self.article_1.authors.add(author_3)
self.article_2.authors.add(author_4)
self.article_3.authors.add(author_3)
clist = SavedCitationListFactory.create(user=self.user)
clist.documents.add(self.thesis_1)
clist.documents.add(self.thesis_2)
clist.documents.add(self.article_1)
clist.documents.add(self.article_2)
clist.documents.add(self.article_3)
def test_can_return_all_the_articles_associated_with_the_last_issue_of_a_journal(self, mock_erudit_object): # noqa
# Setup
mock_erudit_object.return_value = get_mocked_erudit_object()
issue1 = IssueFactory.create(
journal=self.journal, year=2010, date_published=dt.datetime.now())
article1 = ArticleFactory.create(issue=issue1)
article2 = ArticleFactory.create(issue=issue1)
issue2 = IssueFactory.create(
journal=self.journal, year=2010,
date_published=dt.datetime.now() - dt.timedelta(days=2))
ArticleFactory.create(issue=issue2)
request = self.factory.get('/')
# Run
f = LatestJournalArticlesFeed()
f.get_object(request, self.journal.code)
feed = f.get_feed(None, request)
# Check
self.assertEqual(len(feed.items), 2)
self.assertIn(
reverse('public:journal:article_detail',
args=[
article1.issue.journal.code,
article1.issue.volume_slug,
article1.issue.localidentifier,
article1.localidentifier
]), feed.items[0]['link'])
self.assertIn(
reverse('public:journal:article_detail',
args=[
article2.issue.journal.code,
article2.issue.volume_slug,
article2.issue.localidentifier,
article2.localidentifier
]), feed.items[1]['link'])
def test_returns_only_the_internal_articles(self):
# Setup
issue = IssueFactory.create(journal=self.journal, external_url=None)
article_1 = ArticleFactory.create(issue=issue, external_url=None)
article_2 = ArticleFactory.create(issue=issue, external_url='http://example.com')
# Run
articles = Article.internal_objects.all()
# Check
self.assertTrue(article_1 in articles)
self.assertTrue(article_2 not in articles)
def test_knows_that_it_is_in_open_access_if_its_issue_is_in_open_access(self):
# Setup
j1 = JournalFactory.create(open_access=True)
j2 = JournalFactory.create(open_access=False)
issue_1 = IssueFactory.create(journal=j1)
article_1 = ArticleFactory.create(issue=issue_1)
issue_2 = IssueFactory.create(journal=j2)
article_2 = ArticleFactory.create(issue=issue_2)
# Run 1 check
self.assertTrue(article_1.open_access)
self.assertFalse(article_2.open_access)
def test_can_add_new_articles(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article_1 = ArticleFactory.create(issue=issue)
article_2 = ArticleFactory.create(issue=issue)
request = self.factory.get('/')
middleware = SessionMiddleware()
middleware.process_request(request)
citation_list = SavedCitationList(request)
# Run
citation_list.add(article_1)
citation_list.add(article_2)
# Check
self.assertTrue(article_1 in citation_list)
self.assertTrue(article_2.id in citation_list)
def test_can_retrieve_the_first_page_of_the_pdf_of_existing_articles(self, mock_ds, mock_pdf):
# Setup
with open(os.path.join(FIXTURE_ROOT, 'dummy-multipages.pdf'), 'rb') as f:
mock_pdf.content = io.BytesIO()
mock_pdf.content.write(f.read())
mock_ds = ['ERUDITXSD300', ] # noqa
issue = IssueFactory.create(
journal=self.journal, date_published=dt.datetime.now() - dt.timedelta(days=1000))
article = ArticleFactory.create(issue=issue)
journal_id = self.journal.localidentifier
issue_id = issue.localidentifier
article_id = article.localidentifier
url = reverse('public:journal:article_raw_pdf_firstpage', args=(
journal_id, issue.volume_slug, issue_id, article_id
))
request = self.factory.get(url)
request.user = AnonymousUser()
# Run
response = ArticleRawPdfFirstPageView.as_view()(
request, journal_code=journal_id, issue_slug=issue.volume_slug,
issue_localid=issue_id, localid=article_id)
# Check
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/pdf')
raw_pdf = io.BytesIO()
raw_pdf.write(response.content)
pdf = PdfFileReader(raw_pdf)
self.assertEqual(pdf.numPages, 1)
def test_can_provide_contributors_of_article(self):
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1)
author_1 = AuthorFactory.create(lastname='btest')
author_2 = AuthorFactory.create(lastname='ctest1')
article_1.authors.add(author_1)
article_1.authors.add(author_2)
article_1.save()
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, letter='b')
# Check
self.assertEqual(response.status_code, 200)
authors_dicts = response.context['authors_dicts']
contributors = authors_dicts[0]['articles'][0]['contributors']
assert len(contributors) == 1
assert contributors[0].pk == author_2.pk
def test_inserts_a_dict_with_the_letters_counts_in_the_context(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1)
author_1 = AuthorFactory.create(lastname='btest')
author_2 = AuthorFactory.create(lastname='ctest1')
author_3 = AuthorFactory.create(lastname='ctest2')
article_1.authors.add(author_1)
article_1.authors.add(author_2)
article_1.authors.add(author_3)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url)
# Check
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['letters_exists']), 26)
self.assertEqual(response.context['letters_exists']['B'], 1)
self.assertEqual(response.context['letters_exists']['C'], 2)
for letter in 'adefghijklmnopqrstuvwxyz':
self.assertEqual(
response.context['letters_exists'][letter.upper()], 0)
def test_provides_only_authors_for_the_first_available_letter_by_default(
self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1)
author_1 = AuthorFactory.create(lastname='btest')
author_2 = AuthorFactory.create(lastname='ctest1')
author_3 = AuthorFactory.create(lastname='ctest2')
article_1.authors.add(author_1)
article_1.authors.add(author_2)
article_1.authors.add(author_3)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url)
# Check
self.assertEqual(response.status_code, 200)
self.assertEqual(list(response.context['authors']), [
author_1,
])
def test_inserts_the_current_letter_in_the_context(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1)
author_1 = AuthorFactory.create(lastname='btest')
author_2 = AuthorFactory.create(lastname='ctest1')
author_3 = AuthorFactory.create(lastname='ctest2')
article_1.authors.add(author_1)
article_1.authors.add(author_2)
article_1.authors.add(author_3)
url = reverse('public:journal:journal_authors_list', kwargs={'code': self.journal.code})
# Run
response_1 = self.client.get(url)
response_2 = self.client.get(url, {'letter': 'C'})
response_3 = self.client.get(url, {'letter': 'invalid'})
# Check
self.assertEqual(response_1.status_code, 200)
self.assertEqual(response_2.status_code, 200)
self.assertEqual(response_3.status_code, 200)
self.assertEqual(response_1.context['letter'], 'B')
self.assertEqual(response_2.context['letter'], 'C')
self.assertEqual(response_3.context['letter'], 'B')
def test_can_grant_access_to_an_article_has_no_movable_limitation(self):
# Setup
now_dt = dt.datetime.now()
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal,
year=dt.datetime.now().year - 5,
date_published=dt.date(now_dt.year - 5, 3, 20),
localidentifier="test",
)
article = ArticleFactory.create(issue=issue)
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get("/")
request.user = AnonymousUser()
view = MyView()
view.request = request
# Run # check
self.assertTrue(view.has_access())
def test_cannot_grant_access_to_an_article_if_it_is_associated_to_an_individual_subscription_that_is_not_ongoing(
self
): # noqa
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(), localidentifier="test"
)
article = ArticleFactory.create(issue=issue)
JournalAccessSubscriptionFactory.create(user=self.user, journal=self.journal)
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get("/")
request.user = self.user
request.subscription = None
view = MyView()
view.request = request
# Run # check
self.assertFalse(view.has_access())
def test_can_retrieve_xml_of_existing_articles(self, mock_ds, mock_pdf):
with open(os.path.join(FIXTURE_ROOT, '1023796ar.xml'), 'r') as f:
from eulxml.xmlmap import load_xmlobject_from_file
mock_pdf.content = load_xmlobject_from_file(f)
mock_ds = ['ERUDITXSD300', ] # noqa
issue = IssueFactory.create(
journal=self.journal, year=2010,
date_published=dt.datetime.now() - dt.timedelta(days=1000))
article = ArticleFactory.create(issue=issue)
journal_id = self.journal.localidentifier
issue_id = issue.localidentifier
article_id = article.localidentifier
url = reverse('public:journal:article_raw_xml', args=(
journal_id, issue.volume_slug, issue_id, article_id
))
request = self.factory.get(url)
request.user = AnonymousUser()
request.subscription = None
# Run
response = ArticleXmlView.as_view()(
request, journal_code=journal_id, issue_slug=issue.volume_slug, issue_localid=issue_id,
localid=article_id)
# Check
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/xml')
def test_cannot_grant_access_to_an_article_if_it_is_associated_to_an_institutional_account_that_is_not_not_ongoing(
self
): # noqa
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(), localidentifier="test"
)
article = ArticleFactory.create(issue=issue)
organisation = OrganisationFactory.create()
subscription = JournalAccessSubscriptionFactory.create(journal=self.journal, organisation=organisation)
InstitutionIPAddressRangeFactory.create(subscription=subscription, ip_start="192.168.1.2", ip_end="192.168.1.4")
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get("/")
request.user = AnonymousUser()
# FIXME call middleware
request.subscription = None
parameters = request.META.copy()
parameters["HTTP_X_FORWARDED_FOR"] = "192.168.1.3"
request.META = parameters
view = MyView()
view.request = request
# Run # check
self.assertFalse(view.has_access())
def test_inserts_the_current_letter_in_the_context(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1)
author_1 = AuthorFactory.create(lastname='btest')
author_2 = AuthorFactory.create(lastname='ctest1')
author_3 = AuthorFactory.create(lastname='ctest2')
article_1.authors.add(author_1)
article_1.authors.add(author_2)
article_1.authors.add(author_3)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response_1 = self.client.get(url)
response_2 = self.client.get(url, {'letter': 'C'})
response_3 = self.client.get(url, {'letter': 'invalid'})
# Check
self.assertEqual(response_1.status_code, 200)
self.assertEqual(response_2.status_code, 200)
self.assertEqual(response_3.status_code, 200)
self.assertEqual(response_1.context['letter'], 'B')
self.assertEqual(response_2.context['letter'], 'C')
self.assertEqual(response_3.context['letter'], 'B')
def test_can_grant_access_to_an_article_if_it_is_associated_to_an_individual_subscription(self):
# Setup
self.journal.open_access = False
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, year=dt.datetime.now().year, date_published=dt.datetime.now(), localidentifier="test"
)
article = ArticleFactory.create(issue=issue)
now_dt = dt.datetime.now()
subscription = JournalAccessSubscriptionFactory.create(user=self.user, journal=self.journal)
JournalAccessSubscriptionPeriodFactory.create(
subscription=subscription, start=now_dt - dt.timedelta(days=10), end=now_dt + dt.timedelta(days=8)
)
class MyView(ArticleAccessCheckMixin):
def get_article(self):
return article
request = self.factory.get("/")
request.user = self.user
view = MyView()
view.request = request
middleware.process_request(request)
# Run # check
self.assertTrue(view.has_access())
def test_generates_a_pdf_into_a_bytes_stream_by_default(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
# Run & check
pdf = generate_pdf('public/journal/article_pdf_coverpage.html', context={
'article': article, 'issue': issue, 'journal': issue.journal})
self.assertTrue(isinstance(pdf, io.BytesIO))
def test_can_properly_paginate_a_queryset_using_a_list_of_localidentifiers(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
localidentifiers = []
for i in range(0, 10):
lid = 'lid-{0}'.format(i)
localidentifiers.append(lid)
ArticleFactory.create(issue=issue, localidentifier=lid)
request = Request(self.factory.get('/', data={'page': 1}))
paginator = EruditDocumentPagination()
# Run
object_list = paginator.paginate(10, localidentifiers, Article.objects.all(), request)
# Check
self.assertEqual(
object_list,
list(Article.objects.filter(localidentifier__in=localidentifiers[:10])
.order_by('localidentifier')))
def test_can_redirect_to_article_external_url(self):
issue = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article = ArticleFactory.create(issue=issue,
external_url='http://www.erudit.org')
response = self.client.get(
reverse('public:journal:article_external_redirect',
kwargs={'localidentifier': article.localidentifier}))
assert response.status_code == 302
def test_can_filter_by_article_type(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create( issue=issue_1, type='article')
article_2 = ArticleFactory.create( issue=issue_1, type='compterendu') # noqa
author_1 = AuthorFactory.create(lastname='btest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list', kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, article_type='article')
# Check
self.assertEqual(response.status_code, 200)
authors_dicts = response.context['authors_dicts']
assert len(authors_dicts) == 1
def test_can_return_articles_written_for_a_given_journal(self):
# Setup
other_journal = JournalFactory.create(
publishers=[self.publisher])
other_issue = IssueFactory.create(
journal=other_journal, date_published=dt.datetime.now())
other_article = ArticleFactory.create(issue=other_issue)
issue = IssueFactory.create(
journal=self.journal, date_published=dt.datetime.now())
article = ArticleFactory.create(issue=issue)
author = AuthorFactory.create()
article.authors.add(author)
other_article.authors.add(author)
# Run
self.assertEqual(list(author.articles_in_journal(self.journal)), [article, ])
def test_knows_if_it_is_embargoed(self):
# Setup
now_dt = dt.date.today()
from erudit.conf.settings import SCIENTIFIC_JOURNAL_EMBARGO_IN_MONTHS as ml
self.journal.open_access = False
self.journal.last_publication_year = now_dt.year
self.journal.type = JournalTypeFactory.create(code='S')
self.journal.save()
date_issue_1 = dt.date(now_dt.year, now_dt.month, 1)
date_issue_2 = now_dt - dr.relativedelta(months=ml)
date_issue_3 = dt.date(
now_dt.year,
now_dt.month,
1
) - dr.relativedelta(months=ml)
date_issue_4 = now_dt - dr.relativedelta(months=(ml + 5))
date_issue_5 = now_dt - dr.relativedelta(months=((ml + 5) * 2))
issue_1 = IssueFactory.create(
journal=self.journal, year=date_issue_1.year,
date_published=date_issue_1)
issue_2 = IssueFactory.create(
journal=self.journal, year=date_issue_2.year,
date_published=date_issue_2)
issue_3 = IssueFactory.create(
journal=self.journal, year=date_issue_3.year,
date_published=date_issue_3)
issue_4 = IssueFactory.create(
journal=self.journal, year=date_issue_4.year,
date_published=date_issue_4)
issue_5 = IssueFactory.create(
journal=self.journal, year=date_issue_5.year,
date_published=date_issue_5)
article_1 = ArticleFactory.create(issue=issue_1)
article_2 = ArticleFactory.create(issue=issue_2)
article_3 = ArticleFactory.create(issue=issue_3)
article_4 = ArticleFactory.create(issue=issue_4)
article_5 = ArticleFactory.create(issue=issue_5)
# Run & check
self.assertTrue(article_1.embargoed)
self.assertTrue(article_2.embargoed)
self.assertTrue(article_3.embargoed)
self.assertFalse(article_4.embargoed)
self.assertFalse(article_5.embargoed)
def test_can_provide_valid_pagination_data(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
localidentifiers = []
for i in range(0, 50):
lid = 'lid-{0}'.format(i)
localidentifiers.append(lid)
ArticleFactory.create(issue=issue, localidentifier=lid)
request = Request(self.factory.get('/', data={'page': 2}))
paginator = EruditDocumentPagination()
# Run
paginator.paginate(200, localidentifiers, Article.objects.all(), request)
response = paginator.get_paginated_response({})
# Check
self.assertEqual(response.data['pagination']['count'], 200)
self.assertEqual(response.data['pagination']['num_pages'], 20)
self.assertEqual(response.data['pagination']['current_page'], 2)
self.assertEqual(response.data['pagination']['next_page'], 3)
self.assertEqual(response.data['pagination']['previous_page'], 1)
self.assertEqual(response.data['pagination']['page_size'], 10)
def test_can_return_erudit_documents(self, mock_get_results,
mock_erudit_object):
# Setup
mock_get_results.side_effect = fake_get_results
mock_erudit_object.return_value = get_mocked_erudit_object()
issue = IssueFactory.create(journal=self.journal, date_published=now())
localidentifiers = []
for i in range(0, 50):
lid = 'lid-{0}'.format(i)
localidentifiers.append(lid)
ArticleFactory.create(issue=issue, localidentifier=lid)
request = self.factory.get('/', data={'format': 'json'})
list_view = EruditDocumentListAPIView.as_view()
# Run
results_data = list_view(request).render().content
# Check
results = json.loads(smart_text(results_data))
self.assertEqual(results['pagination']['count'], 50)
def test_can_generate_a_pdf_into_a_http_response(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
response = HttpResponse(content_type='application/pdf')
# Run & check
generate_pdf(
'public/journal/article_pdf_coverpage.html',
file_object=response, context={
'article': article, 'issue': issue, 'journal': issue.journal})
self.assertTrue(isinstance(response.content, bytes))
self.assertTrue(response.tell())
def test_can_redirect_journals_from_legacy_urls(self):
article = ArticleFactory()
article.issue.volume = "1"
article.issue.number = "1"
article.issue.save()
url = "/revue/{code}/".format(code=article.issue.journal.code, )
resp = self.client.get(url)
assert resp.url == reverse('public:journal:journal_detail',
kwargs=dict(
code=article.issue.journal.code, ))
assert resp.status_code == 301
def test_can_filter_by_article_type_when_no_article_of_type(self):
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create( issue=issue_1, type='article')
author_1 = AuthorFactory.create(lastname='atest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list', kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, {"article_type": 'compterendu'})
# Check
self.assertEqual(response.status_code, 200)
def test_can_properly_paginate_a_queryset_using_a_list_of_localidentifiers(
self):
# Setup
issue = IssueFactory.create(journal=self.journal)
localidentifiers = []
for i in range(0, 10):
lid = {'Corpus_fac': 'Article', 'ID': 'lid-{0}'.format(i)}
localidentifiers.append(lid)
ArticleFactory.create(issue=issue, localidentifier=lid['ID'])
request = Request(self.factory.get('/', data={'page': 1}))
paginator = EruditDocumentPagination()
# Run
object_list = paginator.paginate(10, localidentifiers,
Article.objects.all(), request)
# Check
self.assertEqual(
object_list,
list(
Article.objects.filter(localidentifier__in=[
l['ID'] for l in localidentifiers[:10]
]).order_by('localidentifier')))
def test_can_provide_valid_pagination_data(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
localidentifiers = []
for i in range(0, 50):
lid = {'Corpus_fac': 'Article', 'ID': 'lid-{0}'.format(i)}
localidentifiers.append(lid)
ArticleFactory.create(issue=issue, localidentifier=lid['ID'])
request = Request(self.factory.get('/', data={'page': 2}))
paginator = EruditDocumentPagination()
# Run
paginator.paginate(200, localidentifiers, Article.objects.all(),
request)
response = paginator.get_paginated_response({})
# Check
self.assertEqual(response.data['pagination']['count'], 200)
self.assertEqual(response.data['pagination']['num_pages'], 20)
self.assertEqual(response.data['pagination']['current_page'], 2)
self.assertEqual(response.data['pagination']['next_page'], 3)
self.assertEqual(response.data['pagination']['previous_page'], 1)
self.assertEqual(response.data['pagination']['page_size'], 10)
def test_generates_a_pdf_into_a_bytes_stream_by_default(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
# Run & check
pdf = generate_pdf('public/journal/article_pdf_coverpage.html',
context={
'article': article,
'issue': issue,
'journal': issue.journal
})
self.assertTrue(isinstance(pdf, io.BytesIO))
def test_can_return_erudit_documents(self, mock_get_results, mock_erudit_object):
# Setup
mock_get_results.side_effect = fake_get_results
mock_erudit_object.return_value = get_mocked_erudit_object()
issue = IssueFactory.create(journal=self.journal, date_published=now())
localidentifiers = []
for i in range(0, 50):
lid = 'lid-{0}'.format(i)
localidentifiers.append(lid)
ArticleFactory.create(issue=issue, localidentifier=lid)
request = self.factory.get('/', data={'format': 'json'})
list_view = EruditDocumentListAPIView.as_view()
# Run
results_data = list_view(request).render().content
# Check
results = json.loads(smart_text(results_data))
self.assertEqual(results['pagination']['count'], 50)
def test_can_retrieve_the_article_using_the_local_identifier(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, localidentifier="test_article")
class MyView(SingleArticleMixin, DetailView):
model = Article
view = MyView()
view.kwargs = {"localid": article_1.localidentifier}
# Run & check
self.assertEqual(view.get_object(), article_1)
def test_can_retrieve_the_article_using_the_local_identifier(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, localidentifier='test_article')
class MyView(SingleArticleMixin, DetailView):
model = Article
view = MyView()
view.kwargs = {'localid': article_1.localidentifier}
# Run & check
self.assertEqual(view.get_object(), article_1)
def test_can_filter_by_article_type(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, type='article')
article_2 = ArticleFactory.create(issue=issue_1,
type='compterendu') # noqa
author_1 = AuthorFactory.create(lastname='btest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, article_type='article')
# Check
self.assertEqual(response.status_code, 200)
authors_dicts = response.context['authors_dicts']
assert len(authors_dicts) == 1
def test_do_not_fail_when_user_requests_a_letter_with_no_articles(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, type='article')
author_1 = AuthorFactory.create(lastname='btest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list', kwargs={'code': self.journal.code})
response = self.client.get(url, {"article_type": 'compterendu', 'letter': 'A'})
# Check
self.assertEqual(response.status_code, 200)
def test_legacy_urls_return_are_redirected_with_http_301(self):
article = ArticleFactory()
legacy_urls = [
"/recherche/index.html",
"/client/login.jsp",
"/client/login.jsp?lang=en",
"/these/liste.html",
"/rss.xml",
]
for url in legacy_urls:
assert self.client.get(url).status_code == 301
def test_can_properly_handle_the_case_where_an_item_is_no_longer_in_the_citation_list(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.post('/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
SavedCitationListMiddleware().process_request(request)
view = SavedCitationRemoveView.as_view()
# Run
response = view(request, article.id)
# Check
assert response.status_code == 200
assert 'error' in json.loads(force_text(response.content))
def test_can_add_an_article_to_a_citation_list(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.post('/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
SavedCitationListMiddleware().process_request(request)
view = SavedCitationAddView.as_view()
# Run
response = view(request, article.id)
# Check
assert response.status_code == 200
assert list(request.saved_citations) == [str(article.id), ]
def test_can_save_the_set_of_articles_to_the_session(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.get('/')
request.user = AnonymousUser()
middleware = SessionMiddleware()
middleware.process_request(request)
citation_list = SavedCitationList(request)
citation_list.add(article)
# Run
citation_list.save()
# Check
self.assertEqual(request.session['saved-citations'], [str(article.id), ])
def test_can_redirect_article_from_legacy_urls(self):
from django.utils.translation import deactivate_all
article = ArticleFactory()
url = '/revue/{journal_code}/{issue_year}/v/n{issue_number}/{article_localidentifier}.html'.format( # noqa
journal_code=article.issue.journal.code,
issue_year=article.issue.year,
issue_number=article.issue.number,
article_localidentifier=article.localidentifier)
resp = self.client.get(url)
assert resp.url == reverse(
'public:journal:article_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
issue_localid=article.issue.localidentifier,
localid=article.localidentifier))
assert "/fr/" in resp.url
assert resp.status_code == 301
deactivate_all()
resp = self.client.get(url + "?lang=en")
assert resp.url == reverse(
'public:journal:article_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
issue_localid=article.issue.localidentifier,
localid=article.localidentifier))
assert "/en/" in resp.url
assert resp.status_code == 301
url = '/en/revue/{journal_code}/{issue_year}/v/n{issue_number}/{article_localidentifier}.html'.format( # noqa
journal_code=article.issue.journal.code,
issue_year=article.issue.year,
issue_number=article.issue.number,
article_localidentifier=article.localidentifier)
deactivate_all()
resp = self.client.get(url)
assert resp.url == reverse(
'public:journal:article_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
issue_localid=article.issue.localidentifier,
localid=article.localidentifier))
assert "/en/" in resp.url
assert resp.status_code == 301
def test_can_return_all_the_articles_associated_with_the_last_issue_of_a_journal(
self, mock_erudit_object): # noqa
# Setup
mock_erudit_object.return_value = get_mocked_erudit_object()
issue1 = IssueFactory.create(journal=self.journal,
year=2010,
date_published=dt.datetime.now())
article1 = ArticleFactory.create(issue=issue1)
article2 = ArticleFactory.create(issue=issue1)
issue2 = IssueFactory.create(journal=self.journal,
year=2010,
date_published=dt.datetime.now() -
dt.timedelta(days=2))
ArticleFactory.create(issue=issue2)
request = self.factory.get('/')
# Run
f = LatestJournalArticlesFeed()
f.get_object(request, self.journal.code)
feed = f.get_feed(None, request)
# Check
self.assertEqual(len(feed.items), 2)
self.assertIn(
reverse('public:journal:article_detail',
args=[
article1.issue.journal.code,
article1.issue.volume_slug,
article1.issue.localidentifier,
article1.localidentifier
]), feed.items[0]['link'])
self.assertIn(
reverse('public:journal:article_detail',
args=[
article2.issue.journal.code,
article2.issue.volume_slug,
article2.issue.localidentifier,
article2.localidentifier
]), feed.items[1]['link'])
def test_can_filter_by_article_type_when_no_article_of_type(
self, mock_erudit_object):
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, type='article')
author_1 = AuthorFactory.create(lastname='atest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, {"article_type": 'compterendu'})
# Check
self.assertEqual(response.status_code, 200)
def test_can_properly_handle_the_case_where_an_item_is_no_longer_in_the_citation_list(
self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.post('/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
SavedCitationListMiddleware().process_request(request)
view = SavedCitationRemoveView.as_view()
# Run
response = view(request, article.id)
# Check
assert response.status_code == 200
assert 'error' in json.loads(force_text(response.content))
def test_can_transform_article_xml_to_html(self, mock_ds, mock_xsd300):
# Setup
with open(FIXTURE_ROOT + '/article.xml', mode='r') as fp:
xml = fp.read()
mock_ds.return_value = ['ERUDITXSD300', ] # noqa
mock_xsd300.content = unittest.mock.MagicMock()
mock_xsd300.content.serialize = unittest.mock.MagicMock(return_value=xml)
issue = IssueFactory.create(
journal=self.journal, date_published=dt.datetime.now(), localidentifier='test')
article = ArticleFactory.create(issue=issue)
# Run
ret = render_article(Context({}), article)
# Check
self.assertTrue(ret is not None)
self.assertTrue(ret.startswith('<div xmlns:v="variables-node" class="article-wrapper">'))
def test_can_generate_a_pdf_into_a_http_response(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
response = HttpResponse(content_type='application/pdf')
# Run & check
generate_pdf('public/journal/article_pdf_coverpage.html',
file_object=response,
context={
'article': article,
'issue': issue,
'journal': issue.journal
})
self.assertTrue(isinstance(response.content, bytes))
self.assertTrue(response.tell())
def test_supports_authors_with_only_special_characters_in_their_name(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1)
author_1 = AuthorFactory.create(lastname=':')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url)
# Check
self.assertEqual(response.status_code, 200)
def test_can_remove_an_article_from_a_citation_list(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.post('/')
request.user = AnonymousUser()
SessionMiddleware().process_request(request)
SavedCitationListMiddleware().process_request(request)
request.saved_citations.add(article)
view = SavedCitationRemoveView.as_view()
# Run
response = view(request, article.id)
# Check
assert response.status_code == 200
assert not len(request.saved_citations)
def test_only_letters_with_results_are_active(self):
""" Test that for a given selection in the authors list view, only the letters for which
results are present are shown """
issue_1 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now())
article_1 = ArticleFactory.create( issue=issue_1, type='article')
author_1 = AuthorFactory.create(lastname='atest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list', kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, {"article_type": 'compterendu'})
# Check
self.assertEqual(response.status_code, 200)
assert response.context['letters_exists'].get('A') == 0
def setup(self):
author_1 = AuthorFactory.create(lastname='Abc', firstname='Def')
author_2 = AuthorFactory.create(lastname='Def', firstname='ghi')
JournalType.objects.create(code='S')
JournalType.objects.create(code='C')
self.collection_1 = CollectionFactory.create()
self.thesis_1 = ThesisFactory.create(localidentifier='t1',
collection=self.collection_1,
author=author_1,
title='Thesis A',
publication_year=2014)
self.thesis_2 = ThesisFactory.create(localidentifier='t2',
collection=self.collection_1,
author=author_2,
title='Thesis B',
publication_year=2011)
author_3 = AuthorFactory.create(lastname='Ghi', firstname='Jkl')
author_4 = AuthorFactory.create(lastname='Jkl', firstname='mno')
self.journal_1 = JournalFactory.create(
collection=self.collection, type=JournalType.objects.get(code='S'))
self.journal_2 = JournalFactory.create(
collection=self.collection, type=JournalType.objects.get(code='C'))
self.issue_1 = IssueFactory.create(journal=self.journal_1, year=2012)
self.issue_2 = IssueFactory.create(journal=self.journal_2, year=2013)
self.article_1 = ArticleFactory.create(issue=self.issue_1)
self.article_2 = ArticleFactory.create(issue=self.issue_1)
self.article_3 = ArticleFactory.create(issue=self.issue_2)
self.article_1.authors.add(author_3)
self.article_2.authors.add(author_4)
self.article_3.authors.add(author_3)
clist = SavedCitationListFactory.create(user=self.user)
clist.documents.add(self.thesis_1)
clist.documents.add(self.thesis_2)
clist.documents.add(self.article_1)
clist.documents.add(self.article_2)
clist.documents.add(self.article_3)
def test_associates_the_citation_list_to_the_request_object(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.get('/')
request.user = AnonymousUser()
middleware = SessionMiddleware()
middleware.process_request(request)
citation_list = SavedCitationList(request)
citation_list.add(article)
citation_list.save()
middleware = SavedCitationListMiddleware()
# Run
middleware.process_request(request)
# Check
self.assertEqual(list(request.saved_citations), [str(article.id), ])
def test_can_save_the_set_of_articles_to_the_session(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.get('/')
request.user = AnonymousUser()
middleware = SessionMiddleware()
middleware.process_request(request)
citation_list = SavedCitationList(request)
citation_list.add(article)
# Run
citation_list.save()
# Check
self.assertEqual(request.session['saved-citations'], [
str(article.id),
])
def test_only_letters_with_results_are_active(self):
""" Test that for a given selection in the authors list view, only the letters for which
results are present are shown """
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, type='article')
author_1 = AuthorFactory.create(lastname='atest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
# Run
response = self.client.get(url, {"article_type": 'compterendu'})
# Check
self.assertEqual(response.status_code, 200)
assert response.context['letters_exists'].get('A') == 0
def test_works_with_localidentifiers(self):
# Setup
self.journal.open_access = True
self.journal.save()
issue = IssueFactory.create(
journal=self.journal, date_published=dt.datetime.now(), localidentifier='test')
article = ArticleFactory.create(issue=issue)
url = reverse('public:journal:article_detail', kwargs={
'journal_code': self.journal.code, 'issue_slug': issue.volume_slug,
'issue_localid': issue.localidentifier, 'localid': article.localidentifier})
request = self.factory.get(url)
request.saved_citations = []
# Run
response = ArticleDetailView.as_view()(
request, localid=article.localidentifier)
# Check
self.assertEqual(response.status_code, 200)
def test_can_generate_section_tree_with_three_levels(self):
view = IssueDetailView()
article = ArticleFactory()
ArticleSectionTitleFactory(
article=article,
title="section 1",
level=1,
)
ArticleSectionTitleFactory(
article=article,
title="section 2",
level=2,
)
ArticleSectionTitleFactory(
article=article,
title="section 3",
level=3
)
sections_tree = view.generate_sections_tree([article])
assert sections_tree == {
'type': 'subsection',
'level': 0,
'titles': {'paral': None, 'main': None},
'groups': [{
'type': 'subsection',
'level': 1,
'titles': {'paral': [], 'main': 'section 1'},
'groups': [{
'type': 'subsection',
'level': 2,
'titles': {'paral': [], 'main': 'section 2'},
'groups': [{
'type': 'subsection',
'level': 3,
'titles': {'paral': [], 'main': 'section 3'},
'groups': [
{'objects': [article], 'type': 'objects', 'level': 3},
]
}]
}]
}]
}
def test_associates_the_citation_list_to_the_request_object(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.get('/')
request.user = AnonymousUser()
middleware = SessionMiddleware()
middleware.process_request(request)
citation_list = SavedCitationList(request)
citation_list.add(article)
citation_list.save()
middleware = SavedCitationListMiddleware()
# Run
middleware.process_request(request)
# Check
self.assertEqual(list(request.saved_citations), [
str(article.id),
])
def test_do_not_fail_when_user_requests_a_letter_with_no_articles(self):
# Setup
issue_1 = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now())
article_1 = ArticleFactory.create(issue=issue_1, type='article')
author_1 = AuthorFactory.create(lastname='btest')
article_1.authors.add(author_1)
url = reverse('public:journal:journal_authors_list',
kwargs={'code': self.journal.code})
response = self.client.get(url, {
"article_type": 'compterendu',
'letter': 'A'
})
# Check
self.assertEqual(response.status_code, 200)
def test_can_redirect_issues_from_legacy_urls(self):
article = ArticleFactory()
article.issue.volume = "1"
article.issue.number = "1"
article.issue.save()
url = "/revue/{journal_code}/{year}/v{volume}/n{number}/".format(
journal_code=article.issue.journal.code,
year=article.issue.year,
volume=article.issue.volume,
number=article.issue.number)
resp = self.client.get(url)
assert resp.url == reverse(
'public:journal:issue_detail',
kwargs=dict(journal_code=article.issue.journal.code,
issue_slug=article.issue.volume_slug,
localidentifier=article.issue.localidentifier))
assert resp.status_code == 301
def test_can_transform_article_xml_to_html(self, mock_has_coverpage,
mock_ds, mock_xsd300):
# Setup
with open(FIXTURE_ROOT + '/article.xml', mode='r') as fp:
xml = fp.read()
mock_xsd300.content.serialize = unittest.mock.MagicMock(
return_value=xml)
issue = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now(),
localidentifier='test')
article = ArticleFactory.create(issue=issue)
# Run
ret = render_article(Context({}), article)
# Check
self.assertTrue(ret is not None)
self.assertTrue(
ret.startswith(
'<div xmlns:v="variables-node" class="article-wrapper">'))
def test_can_associate_the_article_to_the_registered_users(self):
# Setup
issue = IssueFactory.create(journal=self.journal)
article = ArticleFactory.create(issue=issue)
request = self.factory.get('/')
request.user = self.user
middleware = SessionMiddleware()
middleware.process_request(request)
citation_list = SavedCitationList(request)
citation_list.add(article)
# Run
citation_list.save()
# Check
self.assertEqual(DBSavedCitationList.objects.count(), 1)
db_citation_list = DBSavedCitationList.objects.first()
self.assertEqual(db_citation_list.user, self.user)
self.assertEqual(list(db_citation_list.documents.all()), [
article,
])
def test_can_transform_article_xml_to_html_when_pdf_exists(
self, mock_pdf, mock_has_coverpage, mock_ds, mock_xsd300):
# Setup
with open(FIXTURE_ROOT + '/article.xml', mode='r') as fp:
xml = fp.read()
fp = open(FIXTURE_ROOT + '/article.pdf', mode='rb')
mock_xsd300.content.serialize = unittest.mock.MagicMock(
return_value=xml)
mock_pdf.exists = True
mock_pdf.content = fp
issue = IssueFactory.create(journal=self.journal,
date_published=dt.datetime.now(),
localidentifier='test')
article = ArticleFactory.create(issue=issue)
# Run
ret = render_article(Context({}), article)
# Check
fp.close()
self.assertTrue(ret is not None)
