Example #1
0
 def test_slug_created(self):
     post = Post()
     post.title = 'Test'
     post.description = 'Test'
     post.save()
     # we now have a date
     self.assertEqual(post.slug, 'test')
Example #2
0
class ManagerTestCases(TestCase):

    def setUp(self):
        self.p1 = Post(
            title='test post',
            source_content='test',
            slug='test1')
        self.p1.save()

    def tearDown(self):
        self.p1.status = Post.HIDDEN
        self.p1.save()

    def test_published(self):
        """manager method returns only published blog posts"""
        # none
        self.assertEqual(0, Post.objects.published().count())
        # set to published
        self.p1.status = Post.PUBLISHED
        self.p1.save()
        # now one
        self.assertEqual(1, Post.objects.published().count())

    def test_hidden(self):
        """manager method returns only hidden blog posts"""
        # none
        self.assertEqual(1, Post.objects.hidden().count())
        # set to published
        self.p1.status = Post.HIDDEN
        self.p1.save()
        # now one
        self.assertEqual(1, Post.objects.hidden().count())
Example #3
0
 def test_edit_url(self):
     """edit url returns correctly"""
     p = Post()
     p.title = 'This is a test post'
     p.slug = 'this-is-test-post'
     p.source_content = 'Hm, ha ha.'
     p.save()
     self.assertEqual(p.edit_url(), '/blog/edit/1/')
    def test_video_tag(self):
        """The video tag allows a html5 video tag to be outputted using
        {% video http://h264.url http://webm.url http://poster.url %}
        """
        p = Post()
        p.title = 'test post '
        p.source_content = '{% video http://w.video.mp4 http://w.video.webm http://w.poster.jpg %}'
        p.save()
        html = """<p><video controls="controls" poster="http://w.poster.jpg" preload>
<source src="http://w.video.mp4" type='video/mp4; codecs="avc1.42E01E,mp4a.40.2"'>
<source src="http://w.video.webm"  type='video/webm; codecs="vp8, vorbis"'>
<object id="flashvideo" width="720" height="540" data="http://releases.flowplayer.org/swf/flowplayer-3.2.10.swf" type="application/x-shockwave-flash">
<param name="movie" value="http://releases.flowplayer.org/swf/flowplayer-3.2.10.swf">
<param name="allowfullscreen" value="true">
<param name="allowscriptaccess" value="always">
<param name="flashvars" value='config={"clip":{"url":"http://w.video.mp4}}'>
</object>
</video></p>"""
        self.assertHTMLEqual(p.rendered_content, html)
 def test_use_date_if_supplied(self):
     """If a date is supplied at the time of creation
     then it will be used when saving"""
     post_date = datetime.now()
     post = Post()
     post.title = 'Test'
     post.slug = 'test'
     post.source_content = "#Hello"
     post.created = post_date
     post.save()
     # we now have a date
     self.assertEqual(post_date, post.created)
 def test_markdown_rendering(self):
     """The source is rendered into markdown on saving"""
     post = Post()
     post.title = 'Test'
     post.slug = 'test'
     post.source_content = "# Hello"
     post.save()
     # we now have markdown
     self.assertHTMLEqual('<h1 id="hello">Hello</h1>', post.rendered_content)
 def test_date_if_blank(self):
     """If no date is supplied for a post then
     datetime.now() is applied"""
     post = Post()
     post.title = 'Test'
     post.slug = 'test'
     post.source_content = "#Hello"
     post.save()
     # we now have a date
     self.assertTrue(post.created)
Example #8
0
    def setUp(self):
        # make a post and attachment
        self.post = Post()
        self.post.title = 'Blog Post'
        self.post.slug = 'blog-post'
        self.post.source_content = 'Blog Post'
        self.post.status = Post.PUBLISHED
        self.post.save()

        # now user for the auth'd views
        self.user = User()
        self.user.username = 'test'
        self.user.set_password('test')
        self.user.email = '[email protected]'
        self.user.is_active = True
        self.user.save()
Example #9
0
 def test_pygments(self):
     """Pygments works as expected"""
     post = Post()
     post.title = 'Test'
     post.slug = 'test'
     post.source_content = '# Hello \n\n <code lang="jibberish">boom</code>'
     post.save()
     self.assertHTMLEqual(
         """<h1 id="hello">
         Hello
         </h1><p>
         <div class="highlight">
         <pre>
         boom
         </pre>
         </div>""",
         post.rendered_content)
Example #10
0
class ViewTestCases(TestCase):

    def setUp(self):
        # make a post and attachment
        self.post = Post()
        self.post.title = 'Blog Post'
        self.post.slug = 'blog-post'
        self.post.source_content = 'Blog Post'
        self.post.status = Post.PUBLISHED
        self.post.save()

        # now user for the auth'd views
        self.user = User()
        self.user.username = 'test'
        self.user.set_password('test')
        self.user.email = '[email protected]'
        self.user.is_active = True
        self.user.save()

    def test_multiple_tags(self):
        """Multiple tags don't cause 500 on views"""
        # make tags
        t1 = Tag(slug='a')
        t1.save()
        t2 = Tag(slug='a')
        t2.save()

        # get view and it is 200
        r = self.client.get(reverse('omblog:tag', args=[t2.slug]))
        self.assertEqual(200, r.status_code)

    def test_feed(self):
        """The feed view works as expected"""
        r = self.client.get(reverse('omblog:feed'))
        self.assertEqual(r.status_code, 200)

    def test_login(self):
        """The login view works as expected"""
        # get is a 200
        r = self.client.get(reverse('omblog:login'))
        self.assertEqual(r.status_code, 200)

        # post is a 200
        r = self.client.post(reverse('omblog:login'), {})
        self.assertEqual(r.status_code, 200)

    def test_attach_delete_requires_login(self):
        """attach_delete requires login to access"""
        # attach delete is a 302
        r = self.client.post(reverse('omblog:attach_delete'), {})
        self.assertEqual(302, r.status_code)

    def test_attach_delete(self):
        """Attach delete works as expected"""
        # create image
        image = PostImage(post=self.post)
        image.title = 'Blog Post Image'
        image.src = 'fake/path/a.png'
        image.save()

        # login
        self.assertTrue(
            self.client.login(username='test', password='test'))

        # we have one post Image
        self.assertEqual(1, PostImage.objects.count())

        # post is a 200
        r = self.client.post(
            reverse('omblog:attach_delete'),
            {'pk': image.pk})
        self.assertEqual(200, r.status_code)

        # we have no post Images
        self.assertEqual(0, PostImage.objects.count())

        # Django 1.4 raises Http404 so just ignore these
        if DJANGO_MINOR > 4:
            # do a non existant one and we nicely 404
            r = self.client.post(
                reverse('omblog:attach_delete'),
                {'pk': 1230})
            self.assertEqual(404, r.status_code)

            # send junk and it fails nicely 404
            r = self.client.post(
                reverse('omblog:attach_delete'),
                {'pk': None})
            self.assertEqual(404, r.status_code)

    def test_attach_requires_login(self):
        """attach requires login to access"""
        r = self.client.post(reverse('omblog:attach'), {})
        self.assertEqual(302, r.status_code)

    def test_attach(self):
        """attach works as expected"""
        # login
        self.assertTrue(
            self.client.login(username='test', password='test'))

        # prep the data
        i = Image.new('RGB', (800,800))
        i.save('omblog-test.jpg','JPEG')

        # send data
        with open('omblog-test.jpg') as fp:
            r = self.client.post(
                reverse('omblog:attach'),
                {'post': self.post.pk,
                 'phile': fp})
            self.assertEqual(200, r.status_code)

        # cleanup the file
        unlink('omblog-test.jpg')

        # Django 1.4 raises Http404 so just ignore these
        if DJANGO_MINOR > 4:
            # send junk for post and we get 404
            r = self.client.post(
                reverse('omblog:attach'),
                {'post': 12321321})
            self.assertEqual(404, r.status_code)

    def test_create_requires_login(self):
        """create requires login to access"""
        r = self.client.post(reverse('omblog:create'), {})
        self.assertEqual(302, r.status_code)

    def test_create_works_as_expected(self):
        """create creates!"""
        self.assertTrue(
            self.client.login(username='test', password='test'))

        # send garbage and we still have one
        # we got a 200
        r = self.client.post(reverse('omblog:create'), {
            'title': '',
            'description': '',
        })

        # we have one post
        self.assertEqual(1, Post.objects.count())

        # we got a 200
        r = self.client.post(reverse('omblog:create'), {
            'title': 'the title',
            'description': 'the description',
        })
        self.assertEqual(200, r.status_code)

        # we have two posts
        self.assertEqual(2, Post.objects.count())

    def test_edit_requires_login(self):
        """edit requires login to access"""
        r = self.client.get(reverse('omblog:edit', args=[self.post.pk]))
        self.assertEqual(302, r.status_code)

    @skipIf(
        DJANGO_MINOR <= 4,
        'Skipping test as Django version is 1.4 or less')
    def test_edit_works_as_expected(self):
        """edit edits!"""
        self.assertTrue(
            self.client.login(username='test', password='test'))

        # we got a 200 on GET
        r = self.client.get(reverse('omblog:edit', args=[self.post.pk]))
        self.assertEqual(200, r.status_code)

        # we got a 200 on POST
        r = self.client.post(reverse('omblog:edit', args=[self.post.pk]),
            {'title': 'The title',
            'status': 4,
            'slug': 'the-new-slug',
            'description': 'The description',
            'source_content': 'The content'})
        self.assertEqual(200, r.status_code)

        # everything was saved
        p = Post.objects.get(pk=self.post.pk)
        self.assertEqual(p.title, 'The title')
        self.assertEqual(p.description, 'The description')
        self.assertEqual(p.status, 4)
        self.assertEqual(p.slug, 'the-new-slug')
        self.assertEqual(p.source_content, 'The content')

    def test_tag(self):
        """tag yields 200"""
        # make tag and we get a 200
        tag = Tag(slug='t')
        tag.save()
        r = self.client.get(reverse('omblog:tag', args=[tag.slug]))
        self.assertEqual(200, r.status_code)

    def test_index(self):
        """index yields 200"""
        r = self.client.get(reverse('omblog:index'))
        self.assertEqual(200, r.status_code)

    def test_month(self):
        """month yields 200"""
        r = self.client.get(
            reverse('omblog:month', args=[
                self.post.created.year,
                self.post.created.month]))
        self.assertEqual(200, r.status_code)

    def test_post(self):
        """post yields 200"""
        r = self.client.get(reverse('omblog:post', args=[self.post.slug]))
        self.assertEqual(200, r.status_code)

    def test_post_404(self):
        """non existant post is 404"""
        # Django 1.4 raises Http404 so just ignore these
        if DJANGO_MINOR > 4:
            r = self.client.get(reverse('omblog:post', args=['shoes']))
            self.assertEqual(404, r.status_code)

    def test_redirect_edit_requires_login(self):
        """redirect_edit yields 302"""
        r = self.client.get(
            reverse('omblog:edit_redirect',
            args=[self.post.slug]))

        url = '{}?next=/blog/{}/edit/'.format(
            reverse('omblog:login'),
            self.post.slug)

        self.assertRedirects(r, url)

    @skipIf(
        DJANGO_MINOR <= 4,
        'Skipping test as Django version is 1.4 or less')
    def test_redirect_edit_redirects_when_logged_in(self):
        """redirect_edit redirects correctly"""
        self.assertTrue(
            self.client.login(username='test', password='test'))

        r = self.client.get(
            reverse('omblog:edit_redirect',
            args=[self.post.slug]))

        self.assertRedirects(r, reverse('omblog:edit', args=[self.post.pk]))
Example #11
0
    def test_cache_page_index_cache_enabled_false(self):
        """if no cache is enabled in the settings then
        no caching takes place"""
        # request the page
        request = self.rf.get(reverse('omblog:index'))
        response = views.index(request)
        self.assertNotContains(response, 'THISISATESTPOST')

        # now create a blog post
        p = Post()
        p.title = 'THISISATESTPOST'
        p.slug = 'slug'
        p.source_content = 'This is a test post'
        p.status = p.PUBLISHED
        p.description = 'test post'
        p.save()

        # now it contains the content
        response = views.index(request)
        self.assertContains(response, 'THISISATESTPOST')

        # enabled it again
        settings.OMBLOG_CACHE_ENABLED = True
        reload(o_settings)

        # change the post to hidden and get view again
        p.status = p.HIDDEN
        p.save()

        # not contains
        response = views.index(request)
        self.assertNotContains(response, 'THISISATESTPOST')

        # change post status again and save
        p.status = p.PUBLISHED
        p.save()

        # not contains, because the page is cached
        response = views.index(request)
        self.assertNotContains(response, 'THISISATESTPOST')
Example #12
0
    def test_cache_page_month_cache_enabled_false(self):
        """if no cache is enabled in the settings then
        no caching takes place"""
        # make the date
        d = datetime(
            year=2012,
            month=6,
            day=18,
            minute=2,
            hour=3,
            second=10)
        # request the page
        request = self.rf.get(
            reverse('omblog:month', args=[d.year, d.month]))
        response = views.month(request, d.year, d.month)
        self.assertNotContains(response, 'THISISATESTPOST')

        # now create a blog post
        p = Post()
        p.title = 'THISISATESTPOST'
        p.slug = 'slug'
        p.source_content = 'This is a test post'
        p.status = p.PUBLISHED
        p.description = 'test post'
        p.created = d
        p.save()

        # now it contains the content
        response = views.month(request, d.year, d.month)
        self.assertContains(response, 'THISISATESTPOST')

        # enabled it again
        settings.OMBLOG_CACHE_ENABLED = True
        reload(o_settings)

        # change the post to hidden and get view again
        p.status = p.HIDDEN
        p.save()

        # not contains
        response = views.month(request, d.year, d.month)
        self.assertNotContains(response, 'THISISATESTPOST')

        # change post status again and save
        p.status = p.PUBLISHED
        p.save()

        # not contains, because the page is cached
        response = views.month(request, d.year, d.month)
        self.assertNotContains(response, 'THISISATESTPOST')
Example #13
0
 def setUp(self):
     self.p1 = Post(
         title='test post',
         source_content='test',
         slug='test1')
     self.p1.save()
Example #14
0
 def handle(self, *args, **kwargs):
     #
     #
     # kill all
     Post.objects.all().delete()
     Tag.objects.all().delete()
     #
     #
     # now import
     for mdfile in os.listdir(MDFILES):
         if mdfile == '.DS_Store':
             continue
         f = '%s/%s' % (MDFILES, mdfile)
         with codecs.open(f, encoding='UTF-8') as md:
             contents = md.read()
             parts = contents.split('---')
             header = yaml.load(parts[0])
         # build the post
         try:
             # make post
             p = Post()
             # created
             p.created = header['created']
             # title
             p.title = header['title']
             # url
             slug = mdfile.split('/').pop().split('.')[0]
             if slug.startswith('201'):
                 slug = slug[11:]
             p.slug = slug
             # description
             p.description = header['description']
             # contents
             p.source_content = parts[1]
             # status
             p.status = p.PUBLISHED
             # save it
             p.save()
             # tags
             try:
                 for tag in header['tags']:
                     tag, created = Tag.objects.get_or_create(tag=tag)
                     if created:
                         tag.slug = slugify(tag)
                         tag.save()
                     p.tags.add(tag)
             except KeyError:
                 pass
         except TypeError:
             # is an scrappy idea
             # make post
             if mdfile == 'index.html':
                 continue
             p = Post()
             p.title = mdfile[11:]
             p.slug = slugify(p.title)
             p.contents = contents
             p.save()