Python JournalFactory.create方法代码示例

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 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)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_embeds_the_upcoming_journals_into_the_context(self):
     # Setup
     JournalFactory.create(collection=self.collection, upcoming=False)
     url = reverse('public:home')
     # Run
     response = self.client.get(url)
     # Check
     self.assertEqual(response.status_code, 200)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
    def test_only_main_collections_are_shown_by_default(self):
        collection = CollectionFactory.create()
        main_collection = CollectionFactory.create(is_main_collection=True)
        journal1 = JournalFactory.create(collection=collection)
        journal2 = JournalFactory.create(collection=main_collection)
        url = reverse('public:journal:journal_list')
        response = self.client.get(url)

        assert list(response.context['journals']) == [journal2]

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_return_its_letter_prefix(self):
     # Setup
     journal_1 = JournalFactory.create(
         name='Test', collection=self.collection, publishers=[self.publisher])
     journal_2 = JournalFactory.create(
         name=None, collection=self.collection, publishers=[self.publisher])
     # Run & check
     self.assertEqual(journal_1.letter_prefix, 'T')
     self.assertIsNone(journal_2.letter_prefix)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_filter_the_journals_by_open_access(self):
     # Setup
     collection = CollectionFactory.create()
     journal_1 = JournalFactory.create(collection=collection, open_access=True)
     JournalFactory.create(collection=collection, open_access=False)
     url = reverse('public:journal:journal_list')
     # Run
     response = self.client.get(url, data={'open_access': True})
     # Check
     assert list(response.context['journals']) == [journal_1, ]

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 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)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_filter_the_journals_by_collections(self):
     # Setup
     col_1 = CollectionFactory(code='col1')
     col_2 = CollectionFactory(code='col2')
     JournalFactory.create(collection=col_1)
     journal_2 = JournalFactory.create(collection=col_2)
     url = reverse('public:journal:journal_list')
     # Run
     response = self.client.get(url, data={'collections': ['col2', ]})
     # Check
     assert list(response.context['journals']) == [journal_2, ]

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_filter_the_journals_by_types(self):
     # Setup
     collection = CollectionFactory.create()
     jtype_1 = JournalType.objects.create(code='T1', name='T1')
     jtype_2 = JournalType.objects.create(code='T2', name='T2')
     JournalFactory.create(collection=collection, type=jtype_1)
     journal_2 = JournalFactory.create(collection=collection, type=jtype_2)
     url = reverse('public:journal:journal_list')
     # Run
     response = self.client.get(url, data={'types': ['T2', ]})
     # Check
     assert list(response.context['journals']) == [journal_2, ]

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_returns_only_the_internal_journals(self):
     # Setup
     journal_1 = JournalFactory.create(
         collection=self.collection,
         external_url='http://example.com',
         redirect_to_external_url=True
     )
     JournalFactory.create(collection=self.collection)
     # Run
     journals = Journal.internal_objects.all()
     # Check
     self.assertTrue(journal_1 not in journals)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_return_a_journal_using_its_localidentifier_or_its_code(self):
     # Setup
     journal = JournalFactory.create(
         collection=self.collection, localidentifier='foobar42', code='foobar')
     # Run & check
     self.assertEqual(Journal.legacy_objects.get_by_id('foobar'), journal)
     self.assertEqual(Journal.legacy_objects.get_by_id('foobar42'), journal)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_embed_the_journal_information_in_the_context_if_available(self):
     # Setup
     collection = CollectionFactory.create()
     journal_1 = JournalFactory.create(collection=collection)
     journal_2 = JournalFactory.create(collection=collection)
     journal_info = JournalInformationFactory.create(journal=journal_1)
     url_1 = reverse('public:journal:journal_detail', kwargs={'code': journal_1.code})
     url_2 = reverse('public:journal:journal_detail', kwargs={'code': journal_2.code})
     # Run
     response_1 = self.client.get(url_1)
     response_2 = self.client.get(url_2)
     # Check
     self.assertEqual(response_1.status_code, 200)
     self.assertEqual(response_2.status_code, 200)
     self.assertEqual(response_1.context['journal_info'], journal_info)
     self.assertTrue('journal_info' not in response_2.context)

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
    def test_provides_only_subscriptions_associated_with_the_current_journal(self):
        # Setup
        AuthorizationFactory.create(
            content_type=ContentType.objects.get_for_model(self.journal),
            object_id=self.journal.id,
            user=self.user,
            authorization_codename=AC.can_manage_individual_subscription.codename,
        )

        plan = JournalManagementPlanFactory.create(max_accounts=10)
        JournalManagementSubscriptionFactory.create(journal=self.journal, plan=plan)

        other_journal = JournalFactory.create(collection=self.collection)
        subscription_1 = JournalAccessSubscriptionFactory.create(user=self.user, journal=self.journal)
        JournalAccessSubscriptionFactory.create(user=self.user, journal=other_journal)

        self.client.login(username="david", password="top_secret")
        url = reverse("userspace:journal:subscription:list", kwargs={"journal_pk": self.journal.pk})

        # Run
        response = self.client.get(url)

        # Check
        self.assertEqual(response.status_code, 200)
        self.assertEqual(list(response.context["subscriptions"]), [subscription_1])

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_sort_journals_by_disciplines(self):
     # Setup
     collection = CollectionFactory.create()
     discipline_1 = DisciplineFactory.create(code='abc-discipline', name='ABC')
     discipline_2 = DisciplineFactory.create(code='def-discipline', name='DEF')
     discipline_3 = DisciplineFactory.create(code='ghi-discipline', name='GHI')
     journal_1 = JournalFactory.create(collection=collection)
     journal_1.disciplines.add(discipline_1)
     journal_2 = JournalFactory.create(collection=collection)
     journal_2.disciplines.add(discipline_1)
     journal_3 = JournalFactory.create(collection=collection)
     journal_3.disciplines.add(discipline_2)
     journal_4 = JournalFactory.create(collection=collection)
     journal_4.disciplines.add(discipline_3)
     journal_5 = JournalFactory.create(collection=collection)
     journal_5.disciplines.add(discipline_3)
     journal_6 = JournalFactory.create(collection=collection)
     journal_6.disciplines.add(discipline_3)
     url = reverse('public:journal:journal_list')
     # Run
     response = self.client.get(url, {'sorting': 'disciplines'})
     # Check
     assert response.status_code == 200
     assert len(response.context['sorted_objects']) == 3
     assert response.context['sorted_objects'][0]['key'] == discipline_1.code
     assert response.context['sorted_objects'][0]['collections'][0]['key'] == collection
     assert response.context['sorted_objects'][0]['collections'][0]['objects'] == [
         journal_1, journal_2, ]
     assert response.context['sorted_objects'][1]['key'] == discipline_2.code
     assert response.context['sorted_objects'][1]['collections'][0]['key'] == collection
     assert response.context['sorted_objects'][1]['collections'][0]['objects'] == [journal_3, ]
     assert response.context['sorted_objects'][2]['key'] == discipline_3.code
     assert response.context['sorted_objects'][2]['collections'][0]['key'] == collection
     assert set(response.context['sorted_objects'][2]['collections'][0]['objects']) == set([
         journal_4, journal_5, journal_6, ])

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
 def test_can_resolve_the_current_url_for_another_journal(self):
     # Setup
     journal_2 = JournalFactory.create(collection=self.collection, publishers=[self.publisher])
     factory = RequestFactory()
     base_url = reverse(
         'userspace:journal:information:update', kwargs={'journal_pk': self.journal.pk})
     request = factory.get(base_url)
     request.resolver_match = resolve(base_url)
     # Run
     url = journal_url({'request': request}, journal_2)
     # Check
     self.assertEqual(
         url,
         reverse('userspace:journal:information:update', kwargs={'journal_pk': journal_2.pk}))

# 需要导入模块: from erudit.test.factories import JournalFactory [as 别名]
# 或者: from erudit.test.factories.JournalFactory import create [as 别名]
    def test_returns_a_403_error_if_no_journal_can_be_associated_with_the_current_user(self):
        # Setup
        class MyView(JournalScopeMixin, TemplateView):
            template_name = "dummy.html"

        user = UserFactory.create()
        journal = JournalFactory.create(collection=self.collection)
        url = reverse("userspace:journal:information:update", kwargs={"journal_pk": journal.pk})
        request = self.get_request(url)
        request.user = user
        my_view = MyView.as_view()

        # Run & check
        with self.assertRaises(PermissionDenied):
            my_view(request, journal_pk=self.journal.pk)