run_tests.py

#!/usr/bin/env python3

import argparse
from datetime import datetime
import logging
import unittest

from sqlalchemy.exc import OperationalError
from werkzeug.exceptions import NotFound

import plantagenet
from plantagenet import app


class PostTest(unittest.TestCase):
    def setUp(self):
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
        app.config['TESTING'] = True
        self.cl = app.test_client()
        app.testing = True
        with app.app_context():
            app.db.create_all()

    def tearDown(self):
        app.db.session.rollback()

    def test_init(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # then the title is the same as what was passed to the constructor
        self.assertEqual('title', post.title)

        # then the content is the same as what was passed to the constructor
        self.assertEqual('content', post.content)

        # then the date is the same as what was passed to the constructor
        self.assertEqual(datetime(2017, 1, 1), post.date)

    def test_init_optional_arg_is_draft(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # then optional argument "is_draft" have its default value of False
        self.assertFalse(post.is_draft)

    def test_init_set_is_draft(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1), True)

        # then the is_draft field is the same as what was passed to the
        # constructor
        self.assertTrue(post.is_draft)

    def test_init_set_is_draft_named(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1),
                                is_draft=True)

        # then the is_draft field is the same as what was passed to the
        # constructor
        self.assertTrue(post.is_draft)

    def test_init_optional_arg_notes(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # then optional argument "notes" have its default value of None
        self.assertIsNone(post.notes)

    def test_init_set_notes(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1),
                                False, 'notes')

        # then the is_draft field is the same as what was passed to the
        # constructor
        self.assertEqual('notes', post.notes)

    def test_init_set_notes_named(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1),
                                False, notes='notes')

        # then the is_draft field is the same as what was passed to the
        # constructor
        self.assertEqual('notes', post.notes)

    def test_init_set_slug_from_simple_title(self):
        # when a Post with a simple title is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # then the post's slug is set
        self.assertEqual('title', post.slug)

    def test_init_set_slug_from_title_with_spaces(self):
        # when a Post with a simple title is created
        post = plantagenet.Post('title  one', 'content', datetime(2017, 1, 1))

        # then the post's slug is set, with consecutive spaces replaced by a
        # single hyphen
        self.assertEqual('title-one', post.slug)

    def test_init_set_slug_from_title_with_leading_spaces(self):
        # when a Post with a simple title is created
        post = plantagenet.Post(' title', 'content', datetime(2017, 1, 1))

        # then the post's slug is set, with leading spaces removed
        self.assertEqual('title', post.slug)

    def test_init_set_slug_from_title_with_trailing_spaces(self):
        # when a Post with a simple title is created
        post = plantagenet.Post('title ', 'content', datetime(2017, 1, 1))

        # then the post's slug is set, with trailing spaces removed
        self.assertEqual('title', post.slug)

    def test_init_set_slug_from_title_with_non_word_characters(self):
        # when a Post with a simple title is created
        post = plantagenet.Post('title ! $,()', 'content',
                                datetime(2017, 1, 1))

        # then the post's slug is set, with non-word chars removed
        self.assertEqual('title', post.slug)

    def test_init_set_slug_from_title_with_upper_case(self):
        # when a Post with a simple title is created
        post = plantagenet.Post('TITLEtitletItLe', 'content',
                                datetime(2017, 1, 1))

        # then the post's slug is set
        self.assertEqual('titletitletitle', post.slug)

    def test_init_set_summary_from_content(self):
        # when a Post is created
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # then the post's summary is set from the content
        self.assertEqual('content', post.summary)

    def test_init_set_summary_from_content_truncated(self):
        # when a Post is created from content with length == 100
        content = '12345678901234567890123456789012345678901234567890' \
                  '12345678901234567890123456789012345678901234567890'  # 100
        post = plantagenet.Post('title', content, datetime(2017, 1, 1))

        # then the post's summary is set from the content without modification
        self.assertEqual(content, post.summary)

        # when a Post is created from content with length > 100
        content2 = '12345678901234567890123456789012345678901234567890' \
                   '123456789012345678901234567890123456789012345678901'  # 101
        expected = '12345678901234567890123456789012345678901234567890' \
                   '12345678901234567890123456789012345678901234567890...'
        post = plantagenet.Post('title', content2, datetime(2017, 1, 1))

        # then the post's summary is set from the truncated content
        self.assertEqual(expected, post.summary)

    def test_init_set_last_updated_date(self):
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # then the post's summary is set from the content without modification
        self.assertEqual(datetime(2017, 1, 1), post.last_updated_date)

    def test_summarize_consecutive_spaces_are_condensed(self):
        # when
        result = plantagenet.Post.summarize('one  two')

        # then
        self.assertEqual('one two', result)

    def test_summarize_html_tags_are_removed(self):
        # when
        result = plantagenet.Post.summarize('<a href="/">Home</a>')

        # then
        self.assertEqual('Home', result)

    def test_summarize_punctuation_has_added_space(self):
        # when
        result = plantagenet.Post.summarize('one,two.three?four!five')

        # then
        self.assertEqual('one, two. three? four! five', result)

    def test_summarize_wordish_chars_are_kept(self):
        # when
        result = plantagenet.Post.summarize('Something,.?!')

        # then
        self.assertEqual('Something, . ? ! ', result)

    def test_summarize_non_wordish_chars_are_removed(self):
        # when
        result = plantagenet.Post.summarize(
            'Something :@#$%^&*()[]-_=+[]{}\\|;:\'"/<>')

        # then
        self.assertEqual('Something ', result)

    def test_summarize_long_values_are_truncated(self):
        # when a string has length == 100
        content = '12345678901234567890123456789012345678901234567890' \
                  '12345678901234567890123456789012345678901234567890'  # 100
        result = plantagenet.Post.summarize(content)

        # then the summarized value is the same
        self.assertEqual(content, result)

        # when a string has length > 100
        content2 = '12345678901234567890123456789012345678901234567890' \
                   '123456789012345678901234567890123456789012345678901'  # 101
        expected2 = '12345678901234567890123456789012345678901234567890' \
                    '12345678901234567890123456789012345678901234567890...'
        result2 = plantagenet.Post.summarize(content2)

        # then the summarized value is truncated
        self.assertEqual(expected2, result2)

    def test_summary_is_set_when_content_is_set(self):
        # given
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # when
        post.content = 'content2'

        # then
        self.assertEqual('content2', post.summary)

    def test_content_is_not_None(self):
        # given
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))

        # when
        post.content = None

        # then
        self.assertEqual('', post.content)
        self.assertEqual('', post.summary)

    def test_get_by_slug(self):
        # given
        post1 = plantagenet.Post('title1', 'content1', datetime(2017, 1, 1))
        post2 = plantagenet.Post('title2', 'content2', datetime(2017, 1, 1))
        post3 = plantagenet.Post('title3', 'content3', datetime(2017, 1, 1))
        app.db.session.add(post1)
        app.db.session.add(post2)
        app.db.session.add(post3)

        # when
        result = plantagenet.Post.get_by_slug('title2')

        # then
        self.assertIs(post2, result)

    def test_get_by_slug_missing(self):
        # given
        post1 = plantagenet.Post('title1', 'content1', datetime(2017, 1, 1))
        post2 = plantagenet.Post('title2', 'content2', datetime(2017, 1, 1))
        post3 = plantagenet.Post('title3', 'content3', datetime(2017, 1, 1))
        app.db.session.add(post1)
        app.db.session.add(post2)
        app.db.session.add(post3)

        # when
        result = plantagenet.Post.get_by_slug('title4')

        # then
        self.assertIsNone(result)

    def test_get_unique_slug(self):
        # when
        slug = plantagenet.Post.get_unique_slug('title')

        # then
        self.assertEqual('title', slug)

    def test_get_unique_slug_not_unique(self):
        # given a post that already exists
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))
        app.db.session.add(post)

        # when we try to get a slug with the same value
        slug = plantagenet.Post.get_unique_slug('title')

        # then it increments a counter and returns the slightly different value
        self.assertEqual('title-1', slug)


class CreateDbTest(unittest.TestCase):
    def test_create_db_command(self):
        # given an app with uninitialize database
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
        app.config['TESTING'] = True
        self.cl = app.test_client()
        app.testing = True

        # precondition: the database table have not been created yet
        self.assertRaises(OperationalError, plantagenet.Post.query.first)
        self.assertRaises(OperationalError, plantagenet.Tag.query.first)
        self.assertRaises(OperationalError, plantagenet.Option.query.first)

        # when the create_db function is called
        plantagenet.create_db()

        # then the database tables are created
        self.assertIsNone(plantagenet.Post.query.first())
        self.assertIsNone(plantagenet.Tag.query.first())
        self.assertIsNone(plantagenet.Option.query.first())


class HashPasswordTest(unittest.TestCase):
    def test_hash_password(self):
        # given
        unhashed_password = '12345'

        # when
        result = plantagenet.hash_password(unhashed_password)

        # then
        self.assertTrue(
            plantagenet.bcrypt.check_password_hash(result, unhashed_password))


class CliCommandsTest(unittest.TestCase):
    def setUp(self):
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
        app.config['TESTING'] = True
        self.cl = app.test_client()
        app.testing = True
        with app.app_context():
            app.db.create_all()

    def tearDown(self):
        app.db.session.rollback()
        app.db.drop_all()

    def test_reset_slug(self):
        # given a post with a non-standard slug is put into the db
        post = plantagenet.Post('title', 'content', datetime(2017, 1, 1))
        post.slug = 'slug12345'
        app.db.session.add(post)
        app.db.session.commit()

        # precondition: the post is in the db
        self.assertIsNotNone(post.id)
        post2 = plantagenet.Post.query.first()
        self.assertIsNotNone(post2.id)
        self.assertIs(post2, post)

        # precondition: the post's slug is different from the title
        self.assertNotEqual('title', post.slug)

        # when the reset_slug function is called
        plantagenet.reset_slug(post.id)

        # then the post's slug is changed to match the title (plus
        # counter, meh)
        self.assertEqual(post.title, post.slug)

    def test_reset_slug_missing(self):
        # precondition: no posts are in the db
        result = plantagenet.Post.query.first()
        self.assertIsNone(result)

        # when the function is called with the id of a nonexistent post,
        # then an exception is thrown
        self.assertRaises(NotFound, plantagenet.reset_slug, 1)


class VersionTest(unittest.TestCase):
    def test_version_number_is_correct(self):
        from plantagenet import Options
        # expect
        self.assertEqual('0.2', Options.get_version())


def run():
    parser = argparse.ArgumentParser()
    parser.add_argument('--print-log', action='store_true',
                        help='Print the log.')
    args = parser.parse_args()

    if args.print_log:
        logging.basicConfig(level=logging.DEBUG,
                            format=('%(asctime)s %(levelname)s:%(name)s:'
                                    '%(funcName)s:'
                                    '%(filename)s(%(lineno)d):'
                                    '%(threadName)s(%(thread)d):%(message)s'))

    unittest.main(argv=[''])


if __name__ == '__main__':
    run()