コード例 #1
0
class TestBlog(unittest.TestCase):
    def setUp(self) -> None:
        self.blog = Blog('Test', 'Test Author')

    def tearDown(self) -> None:
        del self.blog

    def test_create_post_in_blog(self):
        self.blog.create_post('Test post', 'Test Content')
        self.assertEqual(len(self.blog.posts), 1)
        self.assertEqual(self.blog.posts[0].title, 'Test post')
        self.assertEqual(self.blog.posts[0].content, 'Test Content')

    def test_json_no_post(self):
        expected = {'title': 'Test', 'author': 'Test Author', 'posts': []}
        self.assertDictEqual(expected, self.blog.json())

    def test_json(self):
        self.blog.create_post('Test post', 'Test Content')
        expected = {
            'title': 'Test',
            'author': 'Test Author',
            'posts': [{
                'title': 'Test post',
                'content': 'Test Content'
            }]
        }
        self.assertDictEqual(expected, self.blog.json())
コード例 #2
0
 def test_json(self):
     b = Blog('TestTitle', 'TestAuthor')
     self.assertDictEqual(b.json(), {
         'title': 'TestTitle',
         'author': 'TestAuthor',
         'posts': []
     })
コード例 #3
0
 def test_json_no_posts(self):
     b = Blog("Test", "Test Author")
     expected = {
         "title": "Test",
         "author": "Test Author",
         "posts": [],
     }
     self.assertDictEqual(expected, b.json())
コード例 #4
0
ファイル: blogs_test.py プロジェクト: allyboy08/auto_testing
 def test_json(self):
     b = Blog("Test", "Test Author")
     b.create_post("Test Post", "Test Content")
     
     expected = {"title": "Test", "author": "Test Author", "posts": [{"title": "Test Post", "content": "Test Content"}]}
     
     self.assertDictEqual(expected, b.json())
     
コード例 #5
0
    def test_json_no_posts(self):
        b = Blog("Testbloggen", "Alexandra Wåhlander")
        expected = {"Title": "Testbloggen",
                    "Author": "Alexandra Wåhlander",
                    "Posts": []
                    }

        self.assertDictEqual(expected, b.json())
コード例 #6
0
    def test_json(self):
        post1 = Post("post1 title", "post1 content")
        post2 = Post("post2 title", "post2 content")
        posts = [post1, post2]
        expected_json = {
            "title": "Test",
            "author": "Author",
            "posts": [Post("post1 title", "post1 content"),
                      Post("post2 title", "post2 content")]
        }

        b = Blog("Test", "Author", posts)

        print(b.json().__repr__())
        print(expected_json.__repr__())

        self.assertEqual(expected_json.__repr__(), b.json().__repr__(), "Blog json is incorrect!")
コード例 #7
0
    def test_json_no_posts(self):
        b = Blog('Test', 'Test author')

        self.assertDictEqual(b.json(), {
            'title': b.title,
            'author': b.author,
            'posts': [],
        })
コード例 #8
0
ファイル: blog_test.py プロジェクト: lciamp/python-test
 def test_json_no_posts(self):
     b = Blog('Test', 'Test Author')
     expected = {
         'title': 'Test',
         'author': 'Test Author',
         'posts': []
     }
     self.assertDictEqual(expected, b.json())
コード例 #9
0
    def test_json_no_posts(self):
        b = Blog('Test', 'Test author')

        self.assertDictEqual(b.json(), {
            'title': b.title,
            'author': b.author,
            'posts': [],
        })
コード例 #10
0
 def test_json(self):
     b = Blog("Testing Json", "Neto")
     b.create_post("Testing Post", "Testing Post Content")
     self.assertDictEqual({"title": "Testing Json", "author": "Neto", "posts": [{"title": "Testing Post",
                                                                                 "content":
                                                                                     "Testing Post Content"}]},
                                                                                 b.json(),
                                                                                 "The json was not created")
コード例 #11
0
 def test_json_no_posts(self):
     b = Blog('Test', 'Test Author')
     expected = {
         "title": "Test",
         "author": "Test Author",
         "posts": []
     }
     self.assertDictEqual(b.json(), expected)
コード例 #12
0
    def test_json_with_no_posts(self):
        b = Blog('My Blog', 'John Smith')

        expected = {'title': 'My Blog',
                    'author': 'John Smith',
                    'posts': []
                    }
        self.assertDictEqual(expected, b.json())
コード例 #13
0
ファイル: test_blog.py プロジェクト: valievav/api_auto_tests
    def test_json_no_posts(self):
        b = Blog('My blog', 'VV')
        exp_json = {
            'title': 'My blog',
            'author': 'VV',
            'posts': []
        }

        self.assertDictEqual(exp_json, b.json())
コード例 #14
0
    def test_json_with_posts(self):
        b = Blog('Test', 'Test author')
        b.create_post('Test Post', 'Test Content')

        self.assertDictEqual(b.json(), {
            'title': b.title,
            'author': b.author,
            'posts': [{'title': 'Test Post', 'content': 'Test Content'}],
        })
コード例 #15
0
ファイル: blog_test.py プロジェクト: nogeeky/cog-training
    def test_json_no_posts(self):
        new_blog = Blog("Test Title", "Test Author")

        expected = {
            'title': 'Test Title',
            'author': 'Test Author',
            'posts': []
        }

        self.assertDictEqual(expected, new_blog.json())
コード例 #16
0
    def test_json_no_post(self):
        blog_object = Blog('test_title', 'test_author')  # Given data to test

        expected = {
            'title': 'test_title',
            'author': 'test_author',
            'posts': []
        }

        self.assertDictEqual(expected, blog_object.json())
コード例 #17
0
ファイル: blog_test.py プロジェクト: manrodri/tdd
    def test_json(self):
        b = Blog('Test Blog', 'Manuel')
        b.create_post('foo', 'bar')

        expected = {
            'title': "Test Blog",
            "author": "Manuel",
            "posts": [{
                "title": 'foo',
                "content": "bar"
            }]
        }

        self.assertEqual('Test Blog', b.json()['title'])
        self.assertEqual("Manuel", b.json()['author'])

        self.assertEqual(1, len(b.json()["posts"]))
        self.assertEqual('foo', b.json()['posts'][0].title)
        self.assertEqual('bar', b.json()['posts'][0].content)
コード例 #18
0
    def test_json(self):
        b = Blog('Test', 'Test Author')
        b.create_post('Test Post', 'Test Content')

        expected = {'title': 'Test',
                    'author': 'Test Author',
                    'posts': [{'title': 'Test Post',
                               'content': 'Test Content'}]}

        self.assertDictEqual(expected, b.json())
コード例 #19
0
    def test_json_no_post(self):
        b = Blog("Title blog", "Author blog")

        expected = {
            "title": "Title blog",
            "author": "Author blog",
            "posts": []
        }

        self.assertDictEqual(b.json(), expected)
コード例 #20
0
    def test_json(self):
        b = Blog("Test", "Test Author")
        b.create_post("Test Post", "Test Content")

        expected = {
            "title": "Test",
            "author": "Test Author",
            "posts": [ {"title": "Test Post",
                        "content": "Test Content"}] }

        self.assertDictEqual(expected, b.json())
コード例 #21
0
    def test_json(self):
        b = Blog('My Blog', 'John Smith')
        b.create_post('Post Title', 'Post Content')

        expected = {'title': 'My Blog',
                    'author': 'John Smith',
                    'posts': [{'title': 'Post Title',
                               'content': 'Post Content'}
                              ],
                    }
        self.assertDictEqual(expected, b.json())
コード例 #22
0
    def test_json(self):
        b = Blog("Testbloggen", "Alexandra Wåhlander")
        b.create_post("Test post", "Test Content")

        expected = {"Title": "Testbloggen",
                    "Author": "Alexandra Wåhlander",
                    "Posts": [
                        {"title": "Test post",
                               "content": "Test Content"}]
                    }
        self.assertDictEqual(expected, b.json())
コード例 #23
0
def test_blog_json():
    b = Blog('Test', 'Test Author')
    b.create_post('Test Post', 'Test Content')
    expected = {
        'title': 'Test',
        'author': 'Test Author',
        'posts': [{
            'title': 'Test Post',
            'content': 'Test Content'
        }]
    }
    assert b.json() == expected
コード例 #24
0
 def test_json(self):
     b = Blog('Test', 'Test Author')
     b.create_post('Test Post', 'Test Content')
     expected = {
         "title": "Test",
         "author": "Test Author",
         "posts": [{
             "title": "Test Post",
             "content": "Test Content",
         }]
     }
     self.assertDictEqual(b.json(), expected)
コード例 #25
0
 def test_json_with_post(self):
     b = Blog('TestTitle', 'TestAuthor')
     b.create_post('TestPostTitle', 'TestContent')
     self.assertDictEqual(
         b.json(), {
             'title': 'TestTitle',
             'author': 'TestAuthor',
             'posts': [{
                 'title': 'TestPostTitle',
                 'content': 'TestContent'
             }]
         })
コード例 #26
0
ファイル: test_blog.py プロジェクト: MaistrenkoAnton/ATDD
 def test_json(self):
     b = Blog('The best book', 'John Doe')
     b.create_post('Test Post', 'Test content')
     expect = {
         'title': 'The best book',
         'author': 'John Doe',
         'posts': [{
             'title': 'Test Post',
             'content': 'Test content',
         }]
     }
     self.assertDictEqual(expect, b.json())
コード例 #27
0
    def test_json(self):
        blog_object = Blog('test_title', 'test_author')  # Given data to test
        blog_object.create_post('post_title', 'post_content')
        expected = {
            'title': 'test_title',
            'author': 'test_author',
            'posts': [{
                'title': 'post_title',
                'content': 'post_content'
            }]
        }

        self.assertDictEqual(expected, blog_object.json())
コード例 #28
0
 def test_json_no_posts(self):
     b = Blog('Test', 'Test Author')
     b.posts = [Post('', '')]
     expected_json = {
         'title': 'Test',
         'author': 'Test Author',
         'posts': [
             {
                 'title': '', 'content': ''
             }
         ]
     }
     self.assertEqual(expected_json, b.json())
コード例 #29
0
    def test_json(self):
        my_blog = Blog('BlogName', 'BlogAuthor')
        my_blog.create_post('PostTitle', 'PostContent')
        expected = {
            'title': 'BlogName',
            'author': 'BlogAuthor',
            'posts': [{
                'title': 'PostTitle',
                'content': 'PostContent'
            }]
        }

        self.assertDictEqual(expected, my_blog.json())
コード例 #30
0
ファイル: blog_test.py プロジェクト: rere-dnaw/courseProgress
    def test_json_no_post(self):
        """
        Unit test for json method when no posts
        """
        b_1 = Blog('Test title', 'Test author')

        expected = {
            'Title': 'Test title',
            'Author': 'Test author',
            'Posts': [post.json() for post in b_1.posts],
        }

        self.assertDictEqual(b_1.json(), expected)
コード例 #31
0
    def test_json(self):
        b = Blog("Love", "Kingsman")
        b.create_post("love", "siblings")
        expected = {
            "title": "Love",
            "author": "Kingsman",
            "posts": [{
                "title": "love",
                "content": "siblings"
            }]
        }

        self.assertDictEqual(expected, b.json())
コード例 #32
0
    def test_json(self):
        b = Blog('Test Title', 'Author')
        b.create_post("Kenya", "Amazing Kenya")

        expected = {
            'title': 'Test Title',
            'author': 'Author',
            'posts': [{
                'title': "Kenya",
                'content': 'Amazing Kenya'
            }]
        }
        self.assertDictEqual(expected, b.json())
コード例 #33
0
    def test_json(self):
        blog = Blog('Title', 'Author')
        blog.create_post('PostTitle', 'PostContent')
        expected = {
            'title': 'Title',
            'author': 'Author',
            'posts': [{'Title': 'PostTitle',
                       'Content': 'PostContent',
                       },
                      ]
        }

        self.assertEqual(blog.json(), expected)
コード例 #34
0
    def test_json_no_posts(self):
        b = Blog("Test", "Test Author")
        expected = {"title": "Test", "author": "Test Author", "posts": []}

        self.assertDictEqual(expected, b.json())