def test_can_return_its_published_issues(self): # Setup issue_1 = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now() - dt.timedelta(days=1)) issue_2 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now()) IssueFactory.create(journal=self.journal, date_published=None) # Run & check self.assertEqual(set(self.journal.published_issues), {issue_1, issue_2})
def test_can_return_its_last_issue(self): # Setup IssueFactory.create( journal=self.journal, date_published=dt.datetime.now() - dt.timedelta(days=1)) issue_2 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now()) IssueFactory.create(journal=self.journal, date_published=None) # Run & check self.assertEqual(self.journal.last_issue, issue_2)
def test_knows_that_it_is_in_open_access_if_its_issue_is_in_open_access(self): # Setup issue_1 = IssueFactory.create(journal=self.journal, open_access=True) article_1 = ArticleFactory.create(issue=issue_1) issue_2 = IssueFactory.create(journal=self.journal, open_access=False) article_2 = ArticleFactory.create(issue=issue_2) # Run 1 check self.assertTrue(article_1.open_access) self.assertFalse(article_2.open_access)
def test_embeds_the_latest_issues_into_the_context(self): # Setup issue_1 = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now() - dt.timedelta(days=1)) issue_2 = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now()) url = reverse('public:home') # Run response = self.client.get(url) # Check self.assertEqual(response.status_code, 200) self.assertEqual(list(response.context['latest_issues']), [issue_2, issue_1, ])
def test_can_embed_the_latest_issue_in_the_context(self): # Setup collection = CollectionFactory.create() journal = JournalFactory.create(collection=collection) JournalInformationFactory.create(journal=journal) IssueFactory.create( journal=journal, date_published=dt.datetime.now() - dt.timedelta(days=1)) issue_2 = IssueFactory.create(journal=journal, date_published=dt.datetime.now()) IssueFactory.create(journal=journal, date_published=None) url = reverse('public:journal:journal-detail', kwargs={'code': journal.code}) # Run response = self.client.get(url) # Check self.assertEqual(response.status_code, 200) self.assertEqual(response.context['latest_issue'], issue_2)
def test_can_grant_access_to_an_article_if_it_is_associatd_to_an_institutional_account(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), localidentifier='test', open_access=True) article = ArticleFactory.create(issue=issue) policy = PolicyFactory.create(max_accounts=2) policy.access_journal.add(self.journal) organisation = OrganisationFactory.create() institutional_account = InstitutionalAccountFactory( institution=organisation, policy=policy) InstitutionIPAddressRangeFactory.build( institutional_account=institutional_account, 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('/') parameters = request.META.copy() parameters['HTTP_X_FORWARDED_FOR'] = '192.168.1.3' request.META = parameters view = MyView() view.request = request # Run # check self.assertTrue(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_institutional_account(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), localidentifier='test', open_access=False) 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() parameters = request.META.copy() parameters['HTTP_X_FORWARDED_FOR'] = '192.168.1.3' request.META = parameters view = MyView() view.request = request # Run # check self.assertTrue(view.has_access())
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_works_with_pks(self): # Setup issue = IssueFactory.create(journal=self.journal, date_published=dt.datetime.now()) url = reverse('public:journal:issue-detail', kwargs={ 'journal_code': self.journal.code, 'pk': issue.pk}) # Run response = self.client.get(url) # Check self.assertEqual(response.status_code, 200)
def test_can_return_its_last_issue_with_open_access(self): # Setup IssueFactory.create( journal=self.journal, date_published=dt.datetime.now() - dt.timedelta(days=2)) issue_2 = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now() - dt.timedelta(days=1), open_access=True) IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), open_access=False) IssueFactory.create(journal=self.journal, date_published=None, open_access=True) # Run & check self.assertEqual(self.journal.last_oa_issue, issue_2)
def test_works_with_pks(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), open_access=True) article = ArticleFactory.create(issue=issue) url = reverse('public:journal:article-detail', kwargs={ 'journal_code': self.journal.code, 'issue_localid': issue.localidentifier, 'pk': article.pk}) request = self.factory.get(url) # Run response = ArticleDetailView.as_view()( request, localid=article.localidentifier) # Check self.assertEqual(response.status_code, 200)
def test_can_grant_access_to_an_article_if_it_is_in_open_access(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), localidentifier='test', open_access=True) article = ArticleFactory.create(issue=issue) class MyView(ArticleAccessCheckMixin): def get_article(self): return article view = MyView() # Run # check self.assertTrue(view.has_access())
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 class="article-wrapper">'))
def test_do_not_grant_access_by_default(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), localidentifier='test', open_access=False) article = ArticleFactory.create(issue=issue) class MyView(ArticleAccessCheckMixin): def get_article(self): return article request = self.factory.get('/') view = MyView() view.request = request # Run # check self.assertFalse(view.has_access())
def test_can_grant_access_to_an_article_if_it_is_associated_to_an_individual_subscription(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), localidentifier='test', open_access=False) 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 view = MyView() view.request = request # Run # check self.assertTrue(view.has_access())
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_a_flag_into_the_context(self): # Setup issue = IssueFactory.create( journal=self.journal, date_published=dt.datetime.now(), localidentifier='test', open_access=True) article = ArticleFactory.create(issue=issue) class MyViewAncestor(object): def get_context_data(self, **kwargs): return {} class MyView(ArticleAccessCheckMixin, MyViewAncestor): def get_article(self): return article view = MyView() # Run # check self.assertTrue(view.has_access()) self.assertTrue(view.get_context_data()['article_access_granted'])
def test_can_retrieve_the_pdf_of_existing_articles(self, mock_ds, mock_pdf): # Setup with open(os.path.join(FIXTURE_ROOT, 'dummy.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()) 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', args=( journal_id, issue_id, article_id )) request = self.factory.get(url) # Run response = ArticleRawPdfView.as_view()( request, journalid=journal_id, issueid=issue_id, articleid=article_id) # Check self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'], 'application/pdf')
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_counts']), 26) self.assertEqual(response.context['letters_counts']['b'], 1) self.assertEqual(response.context['letters_counts']['c'], 2) for letter in 'adefghijklmnopqrstuvwxyz': self.assertEqual(response.context['letters_counts'][letter], 0)
def setUp(self): super(TestIssue, self).setUp() self.issue = IssueFactory.create(journal=self.journal)
def setUp(self): super(TestArticle, self).setUp() self.issue = IssueFactory.create(journal=self.journal) self.article = ArticleFactory.create(issue=self.issue)