示例#1
0
    def test_return_the_first_page_if_the_page_param_is_not_a_number(self, rf):
        blog_page = BlogPageFactory.create()
        for _ in range(15):
            ArticlePageFactory.create(parent=blog_page)
        setattr(blog_page, 'entries', ArticlePage.objects.all())

        context = blog_page.get_context(rf.get('/', {'page': 'foobar'}))

        assert isinstance(context['paginated_entries'], Page)
        assert context['paginated_entries'].number == 1
示例#2
0
    def test_is_able_to_paginate_attached_entries(self, rf):
        blog_page = BlogPageFactory.create()
        for _ in range(30):
            ArticlePageFactory.create(parent=blog_page)
        setattr(blog_page, 'entries', ArticlePage.objects.all())

        context = blog_page.get_context(rf.get('/', {'page': 2}))

        assert isinstance(context['paginated_entries'], Page)
        assert context['paginated_entries'].number == 2
示例#3
0
    def test_includes_latest_articles_and_recipes(self, rf):
        article_page_1 = ArticlePageFactory.create(parent=self.blog_page,
                                                   owner=self.owner,
                                                   date=tz.now() -
                                                   dt.timedelta(days=5),
                                                   live=True)
        article_page_2 = ArticlePageFactory.create(parent=self.blog_page,
                                                   owner=self.owner,
                                                   date=tz.now() -
                                                   dt.timedelta(days=4),
                                                   live=True)
        article_page_3 = ArticlePageFactory.create(parent=self.blog_page,
                                                   owner=self.owner,
                                                   date=tz.now() -
                                                   dt.timedelta(days=2),
                                                   live=True)
        article_page_4 = ArticlePageFactory.create(  # noqa: F841
            parent=self.blog_page, owner=self.owner, live=False)

        recipe_page_1 = RecipePageFactory.create(parent=self.blog_page,
                                                 owner=self.owner,
                                                 date=tz.now() -
                                                 dt.timedelta(days=3),
                                                 live=True)
        recipe_page_2 = RecipePageFactory.create(parent=self.blog_page,
                                                 owner=self.owner,
                                                 live=True)
        recipe_page_3 = RecipePageFactory.create(parent=self.blog_page,
                                                 owner=self.owner,
                                                 date=tz.now() -
                                                 dt.timedelta(days=1),
                                                 live=True)
        recipe_page_4 = RecipePageFactory.create(  # noqa: F841
            parent=self.blog_page, owner=self.owner, live=False)

        request = rf.get('/')
        request.site = self.site
        self.feed.get_feed(None, request)
        entries = self.feed.items()

        assert entries == [
            recipe_page_2,
            recipe_page_3,
            article_page_3,
            recipe_page_1,
            article_page_2,
            article_page_1,
        ]
示例#4
0
    def test_can_return_the_live_articles_ordered_by_reversed_publication_dates(
            self):
        blog_page = BlogPageFactory.create()

        article_page_1 = ArticlePageFactory.create(parent=blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=2),
                                                   live=True)
        article_page_2 = ArticlePageFactory.create(parent=blog_page, live=True)
        article_page_3 = ArticlePageFactory.create(parent=blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=1),
                                                   live=True)
        article_page_4 = ArticlePageFactory.create(parent=blog_page,
                                                   live=False)  # noqa: F841

        assert list(blog_page.get_articles()) == [
            article_page_2, article_page_3, article_page_1
        ]
示例#5
0
    def test_entries_list_include_the_latest_articles_and_recipes(self, rf):
        article_page_1 = ArticlePageFactory.create(parent=self.blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=5),
                                                   live=True)
        article_page_2 = ArticlePageFactory.create(parent=self.blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=4),
                                                   live=True)
        article_page_3 = ArticlePageFactory.create(parent=self.blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=2),
                                                   live=True)
        article_page_4 = ArticlePageFactory.create(parent=self.blog_page,
                                                   live=False)  # noqa: F841

        recipe_page_1 = RecipePageFactory.create(parent=self.blog_page,
                                                 date=tz.now() -
                                                 dt.timedelta(days=3),
                                                 live=True)
        recipe_page_2 = RecipePageFactory.create(parent=self.blog_page,
                                                 live=True)
        recipe_page_3 = RecipePageFactory.create(parent=self.blog_page,
                                                 date=tz.now() -
                                                 dt.timedelta(days=1),
                                                 live=True)
        recipe_page_4 = RecipePageFactory.create(parent=self.blog_page,
                                                 live=False)  # noqa: F841

        response = self.blog_page.entries_list(rf.get('/'))

        assert list(response.context_data['self'].latest_recipes) == [
            recipe_page_2,
            recipe_page_3,
            recipe_page_1,
        ]
        assert list(response.context_data['self'].latest_articles) == [
            article_page_3,
            article_page_2,
            article_page_1,
        ]
示例#6
0
    def test_entries_search_can_search_for_blog_entries(self, rf):
        article_page_1 = ArticlePageFactory.create(parent=self.blog_page,
                                                   live=True,
                                                   title='My super article')
        ArticlePageFactory.create(parent=self.blog_page,
                                  live=True,
                                  title='My dummy article')
        recipe_page_1 = RecipePageFactory.create(parent=self.blog_page,
                                                 live=True,
                                                 title='My super recipe')
        RecipePageFactory.create(parent=self.blog_page,
                                 live=True,
                                 title='My dummy recipe')

        response = self.blog_page.entries_search(
            rf.get('/search', {'q': 'super'}))

        assert set(response.context_data['self'].entries) == {
            article_page_1.page_ptr,
            recipe_page_1.page_ptr,
        }
示例#7
0
    def test_can_return_its_live_entries(self):
        blog_page = BlogPageFactory.create()

        article_page_1 = ArticlePageFactory.create(parent=blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=5),
                                                   live=True)
        article_page_2 = ArticlePageFactory.create(parent=blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=4),
                                                   live=True)
        article_page_3 = ArticlePageFactory.create(parent=blog_page,
                                                   date=tz.now() -
                                                   dt.timedelta(days=2),
                                                   live=True)
        article_page_4 = ArticlePageFactory.create(parent=blog_page,
                                                   live=False)  # noqa: F841

        recipe_page_1 = RecipePageFactory.create(parent=blog_page,
                                                 date=tz.now() -
                                                 dt.timedelta(days=3),
                                                 live=True)
        recipe_page_2 = RecipePageFactory.create(parent=blog_page, live=True)
        recipe_page_3 = RecipePageFactory.create(parent=blog_page,
                                                 date=tz.now() -
                                                 dt.timedelta(days=1),
                                                 live=True)
        recipe_page_4 = RecipePageFactory.create(parent=blog_page,
                                                 live=False)  # noqa: F841

        assert set(blog_page.get_entries()) == {
            recipe_page_1.page_ptr,
            recipe_page_2.page_ptr,
            recipe_page_3.page_ptr,
            article_page_1.page_ptr,
            article_page_2.page_ptr,
            article_page_3.page_ptr,
        }
示例#8
0
 def test_inserts_its_parent_page_into_the_context(self, rf):
     article_page = ArticlePageFactory.create(parent=self.blog_page)
     context = article_page.get_context(rf.get('/my-article'))
     assert context['blog_page'] == self.blog_page