コード例 #1
0
    def test_get_posts(self):
        """ Getting posts from a populated database """
        #TODO: use self.create_multiple_posts() and adjust assertEquals
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(data), 2)

        postA = data[0]
        self.assertEqual(postA["title"], "Example Post A")
        self.assertEqual(postA["body"], "Just a test")

        postB = data[1]
        self.assertEqual(postB["title"], "Example Post B")
        self.assertEqual(postB["body"], "Still a test")
コード例 #2
0
    def test_delete_post(self):
        """ Delete a single post from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        # import pdb;
        # pdb.set_trace()

        response = self.client.get("/api/posts/{}".format(postA.id),
                                   headers=[("Accept", "application/json")])

        session.delete(postA)
        session.commit()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        # data = json.loads(response.data)
        # self.assertEqual(data["message"], "Successfully deleted post with id {}".format(postA.id))

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        postB = posts[0]
        self.assertEqual(postB.title, "Example Post B")
        self.assertEqual(postB.body, "Still a test")
コード例 #3
0
    def testGetPosts(self):
        """ Getting posts from a populated database """
        postA = models.Post(title="Title A", body=
            "Posting up over heeeere")
        postB = models.Post(title="Other title", body=
            "What a wonderful world")
        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts",
            headers=[("Accept", "application/json")] 
            )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data)
        self.assertEqual(len(data), 2)

        postA = data[0]
        self.assertEqual(postA["title"], "Title A")
        self.assertEqual(postA["body"], "Posting up over heeeere")

        postB = data[1]
        self.assertEqual(postB["title"], "Other title")
        self.assertEqual(postB["body"], "What a wonderful world")
コード例 #4
0
    def test_get_posts(self):
        """ Getting posts from a populated database """


        # First define test posts and commit them to database
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Another test")

        session.add_all([postA, postB])
        session.commit()

        
        # Then retrieve the posts using the api endpoint

            # Define response as from the endpoint testing
        response = self.client.get("/api/posts",
                                   headers=[("Accept", "application/json")]
        )
        
            # Test response is successful and mimetype correct
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
            # Test two posts returned
        data = json.loads(response.data)
        self.assertEqual(len(data), 2)
            # Test two posts are same as exist in database
        postA = data[0]
        self.assertEqual(postA["title"], "Example Post A")
        self.assertEqual(postA["body"], "Just a test")

        postB = data[1]
        self.assertEqual(postB["title"], "Example Post B")
        self.assertEqual(postB["body"], "Another test")
コード例 #5
0
ファイル: api_tests.py プロジェクト: broschke/flask_api
    def test_post_put(self):
        """ Posting a new post """
        data = {
            "title": "Example Post",
            "body": "Just a test"
        }
        postA = models.Post(title="Just a test", body="Post with bells")
        
        session.add_all([postA])
        session.commit()

        response = self.client.put("/api/posts/{}".format(postA.id),
            data=json.dumps(data),
            content_type="application/json",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.mimetype, "application/json")
    
        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["id"], 1)
        self.assertEqual(data["title"], "Example Post")
        self.assertEqual(data["body"], "Just a test")

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        post = posts[0]
        self.assertEqual(post.title, "Example Post")
        self.assertEqual(post.body, "Just a test")
コード例 #6
0
 def test_delete_post(self):
     """ Deleting a single post from a populated database """
     postA = models.Post(title="Example Post A", body="Delete this")
     postB = models.Post(title="Example Post B", body="Don't Delete this")        
     
     session.add_all([postA,postB])
     session.commit()
     
     
     response = self.client.get("/api/posts/{}".format(postA.id),
         headers=[("Accept", "application/json")] )
         
     session.delete(postA)
     session.commit()
     
     response = self.client.get("/api/posts/{}".format(postB.id))
     
     self.assertEqual(response.status_code, 200)
     self.assertEqual(response.mimetype, "application/json")
     
     posts = session.query(models.Post).all()
     self.assertEqual(len(posts), 1)
     
     post = json.loads(response.data.decode("ascii"))
     self.assertEqual(post["title"], "Example Post B")
     self.assertEqual(post["body"], "Don't Delete this")
コード例 #7
0
ファイル: api_tests.py プロジェクト: mroswell/posts-api
    def testGetPosts(self):
        """ Getting posts from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data)
        self.assertEqual(len(data), 2)

        postA = data[0]
        self.assertEqual(postA["title"], "Example Post A")
        self.assertEqual(postA["body"], "Just a test")

        postB = data[1]
        self.assertEqual(postB["title"], "Example Post B")
        self.assertEqual(postB["body"], "Still a test")
コード例 #8
0
ファイル: api_tests.py プロジェクト: sambbaron/posts
    def testGetPostsWithTitleAndBody(self):
        """ Filtering posts by title and body 
            Test posts that include 'Just' in title and 'bells' in body """
        
        # Add three posts - two contain whistle
        postA = models.Post(title="Just a test", body="Post with bells")
        postB = models.Post(title="Still a Test", body="Post with whistles")
        postC = models.Post(title="Another Test",
                            body="Post with bells and whistles")

        session.add_all([postA, postB, postC])
        session.commit()

        # Route using query string
        response = self.client.get("/api/posts?title_like=Just&body_like=bells",
            headers=[("Accept", "application/json")]
        )
        # Test response status code and mimetype
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        # Test number of posts
        posts = json.loads(response.data)
        self.assertEqual(len(posts), 1)
        # Test first post content
        post = posts[0]
        self.assertEqual(post["title"], "Just a test")
        self.assertEqual(post["body"], "Post with bells")
コード例 #9
0
ファイル: api_tests.py プロジェクト: Hank02/posts
    def test_get_posts_with_body(self):
        """ Filtering posts by body """
        postA = models.Post(title="Post with bells", body="A long and interesting text goes here")
        postB = models.Post(title="Post with whistles", body="Something really smart goes here")
        postC = models.Post(title="Post with bells and whistles", body="This is not a long text")

        session.add_all([postA, postB, postC])
        session.commit()

        response = self.client.get("/api/posts?body_like=long",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with bells")
        self.assertEqual(post["body"], "A long and interesting text goes here")

        post = posts[1]
        self.assertEqual(post["title"], "Post with bells and whistles")
        self.assertEqual(post["body"], "This is not a long text")
コード例 #10
0
    def test_delete_single_post(self):
        """ Deleting a single post from the database """

        # Define test posts and commit to database
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Another test")
        
        session.add_all([postA, postB])
        session.commit()

        # Test post is in database
        self.test_get_post()

        
        # Test connection to delete posts endpoint
        response = self.client.delete("/api/post/1",
                                   headers=[("Accept", "application/json")]
        )
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        # Test response message is correct
        data = json.loads(response.data)
        self.assertEqual(data["message"], "Deleted post with id 1 from the database")
                
        # Confirm deletion by testing GETting the same post
        self.test_non_existant_post()
コード例 #11
0
ファイル: api_tests.py プロジェクト: bb071988/endpoints
    def test_delete_post(self):
        """ Setup and delete a post """
        #### Add post a and post b
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        
        ### query for the post B ID
        
        post = session.query(models.Post).get(postB.id)
        
        session.delete(post)
        session.commit()
       
        response = self.client.get("/api/posts/{}".format(postB.id),
            headers=[("Accept", "application/json")]
        )
        
        
        #post = json.loads(response.data)
        print "hello"
        
        with open("delete_post1.txt", 'w+') as testfile:
            #testfile.write(json.dumps(post))
            testfile.write("response is equal to: {}".format(response))
            
            
        self.assertEqual(response.status_code, 404)
        self.assertEqual(response.mimetype, "application/json")
コード例 #12
0
ファイル: api_tests.py プロジェクト: bb071988/endpoints
    def test_get_post(self):
        """ Getting a single post from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts/{}".format(postB.id),
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        post = json.loads(response.data)
        
        with open("test_get_post.txt", 'w+') as testfile:
            testfile.write(json.dumps(post))
            
                # f = open('workfile', 'w+')
        # # f.write("this is the {0} ".format(data)
        # f.write(json.dumps(data))
        self.assertEqual(post["title"], "Example Post B")
        self.assertEqual(post["body"], "Still a test")
コード例 #13
0
ファイル: api_tests.py プロジェクト: bharbron/posts
 def testEditPost(self):
   """ Editing a single post """
   postA = models.Post(title="Example post A", body="Just a test")
   postB = models.Post(title="Example post B", body="Still a test")
   
   session.add_all([postA, postB])
   session.commit()
   
   data = {
     "title": "Edited post B",
     "body": "Now an edited test"
   }
   
   response = self.client.put("/api/posts/{}".format(postB.id),
                              data=json.dumps(data),
                              content_type="application/json",
                              headers=[("Accept", "application/json")]
                              )
   
   self.assertEqual(response.status_code, 200)
   self.assertEqual(response.mimetype, "application/json")
   self.assertEqual(urlparse(response.headers.get("Location")).path,
                   "/api/posts/2")
   
   data = json.loads(response.data)
   self.assertEqual(data["id"], 2)
   self.assertEqual(data["title"], "Edited post B")
   self.assertEqual(data["body"], "Now an edited test")
   
   post = session.query(models.Post).get(2)
   self.assertEqual(post.title, "Edited post B")
   self.assertEqual(post.body, "Now an edited test")
コード例 #14
0
ファイル: api_tests.py プロジェクト: verben-a/posts
    def test_get_posts_with_title(self):
        """ Filtering posts by title """
        postA = models.Post(title="Post with bells", body="Just a test")
        postB = models.Post(title="Post with whistles", body="Still a test")
        postC = models.Post(title="Post with bells and whistles",
                            body="Another test")

        session.add_all([postA, postB, postC])
        session.commit()

        response = self.client.get("/api/posts?title_like=whistles",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with whistles")
        self.assertEqual(post["body"], "Still a test")

        post = posts[1]
        self.assertEqual(post["title"], "Post with bells and whistles")
        self.assertEqual(post["body"], "Another test")
コード例 #15
0
    def testGetPostsWithTitle(self):
        """ Filtering posts by title """
        postA = models.Post(title="Post with green eggs", body="Just a test")
        postB = models.Post(title="Post with ham", body="Still a test")
        postC = models.Post(title="Post with green eggs and ham",
                            body="Another test")

        session.add_all([postA, postB, postC])
        session.commit()

        response = self.client.get("/api/posts?title_like=ham",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data)
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with ham")
        self.assertEqual(post["body"], "Still a test")

        post = posts[1]
        self.assertEqual(post["title"], "Post with green eggs and ham")
        self.assertEqual(post["body"], "Another test")
コード例 #16
0
    def test_get_posts_with_title_and_body(self):
        """ Filtering posts by title and body """

        # First create number of posts
        postA = models.Post(title="Post with bells", body="Just a test")
        postB = models.Post(title="Post with whistles", body="Another test")
        postC = models.Post(title="Post with whistles", body="More tests")

        # Add posts to database
        session.add_all([postA, postB, postC])
        session.commit()
        
        
        # Test for posts containing 'Whistle' in title and 'test' in body
            # - Header is correct
        response = self.client.get("/api/posts?title_like=whistles&body_like=test",
                                   headers=[("Accept", "application/json")]
                               )
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

           # - Number of posts is correct
        posts = json.loads(response.data)
        print posts
        self.assertEqual(len(posts), 2)

            # - Individual post's title and body are correct
        post = posts[0]
        self.assertEqual(post["title"], "Post with whistles" )
        self.assertEqual(post["body"], "Another test" )

        post = posts[1]
        self.assertEqual(post["title"], "Post with whistles" )
        self.assertEqual(post["body"], "More tests" )
コード例 #17
0
ファイル: api_tests.py プロジェクト: Hank02/posts
    def test_edit_post(self):
        """ Edit an existing post """
        
        postA = models.Post(title="Original Post Title", body="This is the original, unedited text")

        session.add_all([postA])
        session.commit()
        
        data = {
            "title": "Edited Post Title",
            "body": "This is the new and improved text"
        }

        response = self.client.post("/api/posts/1",
            data=json.dumps(data),
            content_type="application/json",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        self.assertEqual(urlparse(response.headers.get("Location")).path, "/api/posts/1")

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["id"], 1)
        self.assertEqual(data["title"], "Edited Post Title")
        self.assertEqual(data["body"], "This is the new and improved text")

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        post = posts[0]
        self.assertEqual(post.title, "Edited Post Title")
        self.assertEqual(post.body, "This is the new and improved text")
コード例 #18
0
    def testPutPost(self):
        """ Editing a post via a PUT """
        
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        
        data = {
            "title": "Edited Post B",
            "body": "Scrambled eggs"
        }

        response = self.client.put("/api/posts/1",
            data=json.dumps(data),
            content_type="application/json",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.mimetype, "application/json")
        self.assertEqual(urlparse(response.headers.get("Location")).path,
                         "/api/posts/1")

        data = json.loads(response.data)
        self.assertEqual(data["id"], 1)
        self.assertEqual(data["title"], "Edited Post B")
        self.assertEqual(data["body"], "Scrambled eggs")
コード例 #19
0
 def testGetPostsWithTitleAndBody(self):
     """ Filtering posts by title and body"""
     # Add three posts to database
     # One of which has "whistles" in title and "Another" in body
     postA = models.Post(title="Post with bells", body="Just a test")
     postB = models.Post(title="Post with whistles", body="Still a test")
     postC = models.Post(title="Post with bells and whistles", body="Another test")
     
     session.add_all([postA, postB, postC])
     session.commit()
     
     # Make a GET request to the endpoint and adding query string
     response = self.client.get("/api/posts?title_like=whistles&body_like=Another",
                               headers=[("Accept", "application/json")]
                               )
     
     # Check the response status and mimetype
     self.assertEqual(response.status_code, 200)
     self.assertEqual(response.mimetype, "application/json")
     
     # Ensure the correct post is returned
     posts = json.loads(response.data)
     self.assertEqual(len(posts), 1)
     
     post = posts[0]
     self.assertEqual(post["title"], "Post with bells and whistles")
     self.assertEqual(post["body"], "Another test")
コード例 #20
0
ファイル: api_tests.py プロジェクト: cenyia/posts
    def test_delete_post(self):
        """ Deleting a post """
        
        postA = database.Post(title="Example Post A", body="Just a test")
        postB = database.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        
        
        response = self.client.delete("/api/posts/<id>")

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(data), 2)

        postA = data[0]
        self.assertEqual(postA["title"], "Example Post A")
        self.assertEqual(postA["body"], "Just a test")

        postB = data[1]
        self.assertEqual(postB["title"], "Example Post B")
        self.assertEqual(postB["body"], "Still a test")
コード例 #21
0
 def testGetPosts(self):
     """ Getting posts from a populated database """
     postA = models.Post(title="Example Post A", body="Just a test")
     postB = models.Post(title="Example Post B", body="Still a test")
     
     session.add_all([postA, postB])
     session.commit()
     
     # Use test client to make a GET request
     response = self.client.get("/api/posts",
                               headers=[("Accept", "application/json")]
                               )
     
     # Check status returned by endpoint is 200 OK
     self.assertEqual(response.status_code, 200)
     # Check endpoint returned JSON by the mimetype
     self.assertEqual(response.mimetype, "application/json")
     
     # Decode the response using 'json.loads()'
     data = json.loads(response.data)
     self.assertEqual(len(data), 2)
     
     postA = data[0]
     self.assertEqual(postA["title"], "Example Post A")
     self.assertEqual(postA["body"], "Just a test")
     
     postB = data[1]
     self.assertEqual(postB["title"], "Example Post B")
     self.assertEqual(postB["body"], "Still a test")
コード例 #22
0
    def test_delete(self):
        """ Deleting a post """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts/{}".format(postA.id),
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data.decode("ascii"))

        post = data
        self.assertEqual(post["title"], "Example Post A")
        self.assertEqual(post["body"], "Just a test")

        response = self.client.delete("/api/posts/{}".format(postA.id),
                                      headers=[("Accept", "application/json")])

        response = self.client.get("/api/posts/{}".format(postA.id),
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 404)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["message"], "Could not find post with id 1")
コード例 #23
0
    def testGetPostsWithTitleAndBody(self):
        """ Filtering posts by title and body """
        postA = models.Post(title="Green eggs and ham", body="A post by Sam I Am about my favorite foods")
        postB = models.Post(title="Green fish blue fish", body="A post about Sam I Am's fish bowl")
        postC = models.Post(title="Green is my favorite color", body="A post by James about how much I love the color green")
        postD = models.Post(title="The Cat in the Hat", body="A post by Sam I Am about my greatest rival for power")

        session.add_all([postA, postB, postC, postD])
        session.commit()

        response = self.client.get("/api/posts?title_like=green&body_like=Sam",
            headers=[("Accept", "application/json")]
            )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data)
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Green eggs and ham")
        self.assertEqual(post["body"], "A post by Sam I Am about my favorite foods")

        post = posts[1]
        self.assertEqual(post["title"], "Green fish blue fish")
        self.assertEqual(post["body"], "A post about Sam I Am's fish bowl")
コード例 #24
0
ファイル: api_tests.py プロジェクト: sambbaron/posts
    def testGetPosts(self):
        """ Getting posts from a populated database """
        
        # Add new posts
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")
        session.add_all([postA, postB])
        session.commit()        
        
        # Routed from api.py and push accept header
        response = self.client.get("/api/posts",
            headers=[("Accept", "application/json")]
        )
        
        # Test response status and type
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        
        # Set JSON data response and test number of responses
        data = json.loads(response.data)
        self.assertEqual(len(data), 2)

        # Test content of postA
        postA = data[0]
        self.assertEqual(postA["title"], "Example Post A")
        self.assertEqual(postA["body"], "Just a test")
        # Test content of postB
        postB = data[1]
        self.assertEqual(postB["title"], "Example Post B")
        self.assertEqual(postB["body"], "Still a test")
コード例 #25
0
    def testPostsPut(self):
        """ Editing an existing post """
        postA = models.Post(title="Title A", body=
            "Posting up over heeeere")
        session.add_all([postA])
        session.commit()

        data = {
        "title": "Example Post",
        "body": "Just a test"
        }

        response = self.client.put("/api/posts/1",
            data=json.dumps(data),
            content_type="application/json",
            headers=[("Accept", "application/json")]
            )

        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.mimetype, "application/json")
        self.assertEqual(urlparse(response.headers.get("Location")).path,
            "/api/posts/1")

        data = json.loads(response.data)
        self.assertEqual(data["id"], 1)
        self.assertEqual(data["title"], "Example Post")
        self.assertEqual(data["body"], "Just a test")

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        post = posts[0]
        self.assertEqual(post.title, "Example Post")
        self.assertEqual(post.body, "Just a test")
コード例 #26
0
ファイル: api_tests.py プロジェクト: DesPenny/posts
    def testPostEdit(self):
        """ Testing the edit an existing post """
        # First, create a new post
        data_inject = {
            "title": "This Post has been updated",
            "body": "The body has been edited"
        }
        
        postA = models.Post(title="Example Post A", body="Just a test")
        
        session.add_all([postA])
        session.commit()
  
        #Now edit the post with new data
        response = self.client.put("/api/posts/{}".format(postA.id),
                                      data=json.dumps(data_inject),
                                      content_type="application/json",
                                      headers=[("Accept", "application/json")])
        
        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.mimetype, "application/json")

        data=json.loads(response.data)
        # Test number of posts
        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)
        # Test that it contains the new data
        self.assertEqual(data["title"], "This Post has been updated")
        self.assertEqual(data["body"], "The body has been edited")
コード例 #27
0
ファイル: api_tests.py プロジェクト: mroswell/posts-api
    def testGetPostsWithTitle(self):
        """ Filtering posts by title """
        postA = models.Post(title="Post with bells", body="Just a test")
        postB = models.Post(title="Post with whistles", body="Still a test")
        postC = models.Post(title="Post with bells and whistles",
                            body="Another test")

        session.add_all([postA, postB, postC])
        session.commit()

        response = self.client.get("/api/posts?title_like=whistles",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data)
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with whistles")
        self.assertEqual(post["body"], "Still a test")

        post = posts[1]
        self.assertEqual(post["title"], "Post with bells and whistles")
        self.assertEqual(post["body"], "Another test")
コード例 #28
0
    def test_edit_post(self):
        postA = models.Post(title="Post with bells",
                            body="Just a test for bells")
        postB = models.Post(title="Post with whistles",
                            body="Still a test but for whistles")
        postC = models.Post(title="Post with bells and whistles",
                            body="Another test")

        session.add_all([postA, postB, postC])
        session.commit()

        data = {"title": "New Title", "body": "New body"}

        response = self.client.put("/api/posts/1/edit",
                                   data=json.dumps(data),
                                   content_type="application/json",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 202)
        post_1 = session.query(models.Post).get(1)
        self.assertEqual(post_1.title, "New Title")
        self.assertEqual(post_1.body, "New body")
        post_2 = session.query(models.Post).get(2)
        self.assertEqual(post_2.title, "Post with whistles")
        self.assertEqual(post_2.body, "Still a test but for whistles")
コード例 #29
0
    def test_put(self):
        """ Updating a post via put """

        postA = models.Post(title="Post with bells",
                            body="Just a whistle test")
        session.add_all([postA])
        session.commit()

        data = {"title": "Post with a whistle", "body": "Just a whistle test"}

        response = self.client.put("/api/post/{}".format(postA.id),
                                   data=json.dumps(data),
                                   content_type="application/json",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 201)

        self.assertEqual(data["title"], "Post with a whistle")
        self.assertEqual(data["body"], "Just a whistle test")

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        post = posts[0]
        self.assertEqual(post.title, "Post with a whistle")
        self.assertEqual(post.body, "Just a whistle test")
コード例 #30
0
 def test_post_put(self):
     """Putting a new post"""
     postA = models.Post(title="Example Post A", body="Just a test") 
     postB = models.Post(title="Example Post B", body="Still a test")
     
     session.add_all([postA, postB])
     session.commit()
     
     data = {
         "title": "New Post", 
         "body" : "Trying something out"
     }
     
     response = self.client.put("/api/posts/{}".format(postB.id), data=json.dumps(data),
     content_type="application/json",headers=[("Accept", "application/json")]
     )
     
     
     self.assertEqual(response.status_code, 201)
     self.assertEqual(response.mimetype, "application/json")
     self.assertEqual(urlparse(response.headers.get("Location")).path,
                   "/api/posts/{}".format(postB.id))
     
     data=json.loads(response.data.decode("ascii"))
     self.assertEqual(data["id"],postB.id)
     self.assertEqual(data["title"], "New Post")
     self.assertEqual(data["body"], "Trying something out")
     
     posts= session.query(models.Post).all()
     self.assertEqual(len(posts), 2)
     
     post = posts[1]
     self.assertEqual(post.title, "New Post")
     self.assertEqual(post.body, "Trying something out")
コード例 #31
0
ファイル: api_tests.py プロジェクト: kolohelios/py-posts
 def test_get_posts(self):
     ''' getting posts from a populated database '''
     postA = models.Post(title = 'Example Post A', body = 'Just a test')
     postB = models.Post(title = 'Example Post B', body = 'Still a test')
     
     session.add_all([postA, postB])
     session.commit()
     
     response = self.client.get('/api/posts',
         headers = [('Accept', 'application/json')]
     )
     
     self.assertEqual(response.status_code, 200)
     self.assertEqual(response.mimetype, 'application/json')
     
     data = json.loads(response.data.decode('ascii'))
     self.assertEqual(len(data), 2)
     
     postA = data[0]
     self.assertEqual(postA['title'], 'Example Post A')
     self.assertEqual(postA['body'], 'Just a test')
     
     postB = data[1]
     self.assertEqual(postB['title'], 'Example Post B')
     self.assertEqual(postB['body'], 'Still a test')
コード例 #32
0
    def test_put(self):
        """ Updating a post via put """
        
        postA = models.Post(title="Post with bells", body="Just a whistle test")
        session.add_all([postA])
        session.commit()
        
        data = {
            "title": "Post with a whistle",
            "body": "Just a whistle test"
        }

        response = self.client.put("/api/post/{}".format(postA.id),
            data=json.dumps(data),
            content_type="application/json",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 201)

        self.assertEqual(data["title"], "Post with a whistle")
        self.assertEqual(data["body"], "Just a whistle test")

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        post = posts[0]
        self.assertEqual(post.title, "Post with a whistle")
        self.assertEqual(post.body, "Just a whistle test")
コード例 #33
0
    def test_get_posts(self):
        """ Getting posts from a populated database """
        postA = models.Post(name="Example Post A",
                            ingredients="Just a test",
                            directions="testing")
        postB = models.Post(name="Example Post B",
                            ingredients="Still a test",
                            directions="still testing")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(data), 2)

        postA = data[0]
        self.assertEqual(postA["name"], "Example Post A")
        self.assertEqual(postA["ingredients"], "Just a test")

        postB = data[1]
        self.assertEqual(postB["name"], "Example Post B")
        self.assertEqual(postB["ingredients"], "Still a test")
コード例 #34
0
    def testGetPostWithBody(self):
        """Filtering posts by body"""
        postA = models.Post(title="Post with green eggs", body="We have eggs")
        postB = models.Post(title="Post with ham", body="We have eggs")
        postC = models.Post(title="Post with green eggs and ham", body="Another test")
        session.add_all([postA, postB, postC])
        session.commit()

        response = self.client.get("/api/posts?body_like=eggs",
            headers=[("Accept", "application/json")]
            )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data)
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with green eggs")
        self.assertEqual(post["body"], "We have eggs")

        post = posts[1]
        self.assertEqual(post["title"], "Post with ham")
        self.assertEqual(post["body"], "We have eggs")
コード例 #35
0
ファイル: api_tests.py プロジェクト: GLMeece/thinkful-mentor
    def test_delete_single_post(self):
        postA = models.Post(title="Example Post A", body="Delete this")
        postB = models.Post(title="Example Post B", body="Don't delete this")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get(
            "/api/posts/{}".format(postA.id),
            headers=[("Accept", "application/json")])

        session.delete(postA)
        session.commit()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        # data = json.loads(response.data)

        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)

        postB = posts[0]
        self.assertEqual(postB.title, "Example Post B")
        self.assertEqual(postB.body, "Don't delete this")
コード例 #36
0
    def testGetPostsWithTitleBody(self):
        """ Filtering posts by title and body"""
        postA = models.Post(title="Post with green eggs", body="Ham a test")
        postB = models.Post(title="Post with ham", body="Eggs a test")
        postC = models.Post(title="Post with green eggs and ham",
                            body="Another eggs")
        postD = models.Post(title="Post ham", body="Hier sind keine Eier")

        session.add_all([postA, postB, postC, postD])
        session.commit()

        response = self.client.get("/api/posts?title_like=ham&body_like=eggs",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data)
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with ham")
        self.assertEqual(post["body"], "Eggs a test")

        post = posts[1]
        self.assertEqual(post["title"], "Post with green eggs and ham")
        self.assertEqual(post["body"], "Another eggs")
コード例 #37
0
ファイル: api_tests.py プロジェクト: les-tallman/Thinkful
    def test_get_posts_with_title_and_body(self):
        """ Filtering posts by title and body """
        postA = models.Post(title="Post with bells", body="Just a test")
        postB = models.Post(title="Post with whistles", body="Bells are ringing")
        postC = models.Post(title="Post with bells and whistles",
                            body="More bells")

        session.add_all([postA, postB, postC])
        session.commit()

        response = self.client.get("/api/posts?title_like=whistles&body_like=bells",
            headers=[("Accept", "application/json")]
        )

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(posts), 2)

        post = posts[0]
        self.assertEqual(post["title"], "Post with whistles")
        self.assertEqual(post["body"], "Bells are ringing")

        post = posts[1]
        self.assertEqual(post["title"], "Post with bells and whistles")
        self.assertEqual(post["body"], "More bells")
コード例 #38
0
    def test_get_posts(self):
        """ Getting posts from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
コード例 #39
0
ファイル: api_tests.py プロジェクト: annanymouse/posts
    def testGetPostsWithTitle(self):
        """ Filtering posts by title """
        
        # Adding all the posts
        postA = models.Post(title="Post with bells", body="Just a bells test")
        postB = models.Post(title="Post with whistles", body="Still a whistles test")
        postC = models.Post(title="Post with bells and whistles", body="Another bells test")
        session.add_all([postA, postB, postC])
        session.commit()

        # Getting a response for posts with title like "whistles"
        response = self.client.get("/api/posts?title_like=whistles", headers=[("Accept", "application/json")])

        # Testing the response
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        # Getting the posts back
        posts = json.loads(response.data)
        # Testing that we got 2 posts back
        self.assertEqual(len(posts), 2)
        # Testing the content of the posts returned
        post = posts[0]
        self.assertEqual(post["title"], "Post with whistles")
        self.assertEqual(post["body"], "Still a whistles test")
        post = posts[1]
        self.assertEqual(post["title"], "Post with bells and whistles")
        self.assertEqual(post["body"], "Another bells test")
コード例 #40
0
ファイル: api_tests.py プロジェクト: andreashuebner/posts
    def testDeletePost(self):
        """ Deleting a single post from a populated database """
        
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        
        response = self.client.delete("/api/posts/{}".format(postB.id),
            headers=[("Accept","application/json")])
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        
        post = json.loads(response.data)
        self.assertEqual(post["title"], "Example Post B")
        self.assertEqual(post["body"], "Still a test")
        
        # test that deleted post does not exist anymore
        response = self.client.get("/api/posts/{}".format(postB.id),
            headers=[("Accept","application/json")])

        self.assertEqual(response.status_code, 404)
        
        self.assertEqual(response.mimetype, "application/json")
        data = json.loads(response.data)
        self.assertEqual(data["message"], "Could not find post with id {}".format(postB.id))
コード例 #41
0
  def test_delete_post(self):
    """ Delete a single post from a populated database """
    postA = models.Post(title="Example Post A", body="Just a test")
    postB = models.Post(title="Example Post B", body="Still a test")

    session.add_all([postA, postB])
    session.commit()
    
    # import pdb;
    # pdb.set_trace()

    response = self.client.get("/api/posts/{}".format(postA.id),
      headers=[("Accept", "application/json")]
    )

    session.delete(postA)
    session.commit()

    self.assertEqual(response.status_code, 200)
    self.assertEqual(response.mimetype, "application/json")

    # data = json.loads(response.data)
    # self.assertEqual(data["message"], "Successfully deleted post with id {}".format(postA.id))

    posts = session.query(models.Post).all()
    self.assertEqual(len(posts), 1)

    postB = posts[0]
    self.assertEqual(postB.title, "Example Post B")
    self.assertEqual(postB.body, "Still a test")
コード例 #42
0
    def create_multiple_posts(self):
        """ Create multiple posts for tests """
        #TODO: maybe make one for a single test post? Only if needed
        postA = models.Post(title="Post with bells", body="Nobody expects")
        postB = models.Post(title="Post with whistles", body="Still a test")
        postC = models.Post(title="Post with bells and whistles",
                            body="Nobody expects the Spanish Inquisition!")

        session.add_all([postA, postB, postC])
        session.commit()
コード例 #43
0
    def test_delete_post_wrong_method(self):
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        response = self.client.post("/api/posts/3/delete",
                                    headers=[("Accept", "application/json")])

        posts = session.query(models.Post).all()
        self.assertIn(postA, posts)
        self.assertEqual(response.status_code, 405)
コード例 #44
0
ファイル: api_tests.py プロジェクト: verben-a/posts
    def test_get_posts(self):
        """ Getting posts from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        response = self.client.get('/api/posts',
                                   headers=[("Accept", "application/json")])

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(data), 2)
コード例 #45
0
    def test_delete_post(self):
        """ Getting a single post from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.delete("/api/posts/{}".format(postB.id),
                                      headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
コード例 #46
0
    def test_delete_post(self):
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        # How to change method to DELETE?
        response = self.client.delete("/api/posts/{}".format(postB.id),
                                      headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
コード例 #47
0
    def test_delete_post(self):
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        response = self.client.delete("/api/posts/{}/delete".format(postA.id),
                                      headers=[("Accept", "application/json")])

        posts = session.query(models.Post).all()
        self.assertNotIn(postA, posts)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
コード例 #48
0
 def test_delete_post(self):
     """ Delete a single post """
     postA = models.Post(title="Example Post A", body="Just a test")
     session.add_all([postA,])
     session.commit()
     
     response = self.client.delete("/api/posts/{}".format(postA.id),
         headers=[("Accept", "application/json")]
     )
     
     self.assertEqual(response.status_code, 200)
     self.assertEqual(response.mimetype, "application/json")
     data = json.loads(response.data.decode("ascii"))
     self.assertEqual(len(data), 0)
コード例 #49
0
    def test_get_post(self):
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts/{}".format(postB.id))

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "applications/json")

        post = json.loads(response.data.decode("ascii"))
        self.assertEqual(post["title"], "Example Post B")
        self.assertEqual(post["body"], "Still a test")
コード例 #50
0
    def test_delete_post_with_wrong_id(self):
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()
        response = self.client.delete("/api/posts/3/delete",
                                      headers=[("Accept", "application/json")])

        posts = session.query(models.Post).all()
        self.assertIn(postA, posts)
        self.assertEqual(response.status_code, 404)
        self.assertEqual(response.mimetype, "application/json")
        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["message"], "Could not find post with id 3")
コード例 #51
0
    def test_delete_single_post(self):
        """ deleting a post from a populated database """
        postA = models.Post(title="test Post A", body="testing a")

        session.add_all([postA])
        session.commit()

        response = self.client.post("/api/posts/{}/delete".format(postA.id),
                                    headers=[("Accept", "application/json")])
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        entries = session.query(models.Post).all()
        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["message"], "Post has been deleted!")
        self.assertEqual(len(data), 1)
コード例 #52
0
    def testGetPost(self):
        """ Getting a single post from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts/{}".format(postB.id))

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        post = json.loads(response.data)
        self.assertEqual(post["title"], "Example Post B")
        self.assertEqual(post["body"], "Still a test")
コード例 #53
0
    def test_delete_existing_post(self):
        postA = models.Post(title="Post A", body="Body A")
        postB = models.Post(title="Post B", body="Body B")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.delete("/api/posts/{}".format(postB.id),
                                      headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        post = json.loads(response.data.decode('ascii'))
        self.assertEqual(post['title'], postB.title)
        self.assertEqual(post['body'], postB.body)
コード例 #54
0
    def test_get_post(self):
        """ Getting a single post from a populated database """
        postA = models.Post(title="Post A", body="Body A")
        postB = models.Post(title="Post B", body="Body B")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.get("/api/posts/{}".format(postB.id),
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        post = json.loads(response.data.decode("ascii"))
        self.assertEqual(post["title"], "Post B")
        self.assertEqual(post["body"], "Body B")
コード例 #55
0
    def testGetPostsWithTitleWithBody(self):
        """ Filtering posts by title """
        postA = models.Post(title="Post with ham", body="And with eggs")

        session.add_all([postA])
        session.commit()

        response = self.client.get("/api/posts?title_like=ham&body_like=eggs",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        posts = json.loads(response.data)
        self.assertEqual(len(posts), 1)

        post = posts[0]
        self.assertEqual(post["title"], "Post with ham")
コード例 #56
0
ファイル: api_tests.py プロジェクト: sambbaron/posts
    def testDeletePost(self):
        """ Delete a single post from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.delete("/api/posts/{}".format(postB.id),
            headers=[("Accept", "application/json")]
        )        

        # Test one post deleted/one post remaining
        data = json.loads(response.data)
        self.assertEqual(len(data), 1)
        # Test response status, message, and mimetype
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        self.assertEqual(data["message"], "Post 2 deleted")
コード例 #57
0
    def test_delete_post(self):
        """ Deleting posts from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.delete("/api/posts/{}".format(postA.id),
                                      headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")
        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["message"], "Deleted post with id 1")

        # Assert that there is only one post in the database
        posts = session.query(models.Post).all()
        self.assertEqual(len(posts), 1)
コード例 #58
0
    def test_edit_body(self):
        # editing title
        posts = []
        for i in range(1, 11):
            posts.append(
                models.Post(title="Post Title Number {}".format(i),
                            body="Post body no {}".format(i)))
        session.add_all(posts)
        session.commit()

        random_num = random.choice(range(1, 11))
        random_post = session.query(models.Post).get(random_num)

        data = {"title": random_post.title, "body": "Edited body"}
        random_post = random.choice(range(1, 11))
        response = self.client.put("/api/posts/{}".format(random_num),
                                   data=json.dumps(data),
                                   content_type="application/json",
                                   headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.mimetype, "application/json")
        self.assertEqual(
            urlparse(response.headers.get("Location")).path,
            "/api/posts/{}".format(random_num))

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(data["id"], random_num)
        self.assertEqual(data["title"],
                         "Post Title Number {}".format(random_num))
        self.assertEqual(data["body"], "Edited body")

        posts = session.query(models.Post).all()

        for i in range(0, 10):
            print(posts[i].title)

        self.assertEqual(len(posts), 10)

        random_post = session.query(models.Post).get(random_num)
        self.assertEqual(random_post.title,
                         "Post Title Number {}".format(random_num))
        self.assertEqual(random_post.body, "Edited body")
コード例 #59
0
    def test_delete_single_post(self):  #6
        """ Delete a single post from a populated database """
        postA = models.Post(title="Example Post A", body="Just a test")
        postB = models.Post(title="Example Post B", body="Still a test")

        session.add_all([postA, postB])
        session.commit()

        response = self.client.delete("/api/posts/{}".format(postB.id),
                                      headers=[("Accept", "application/json")])

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.mimetype, "application/json")

        data = json.loads(response.data.decode("ascii"))
        self.assertEqual(len(data), 1)

        postA = data[0]
        self.assertEqual(postA["title"], "Example Post A")
        self.assertEqual(postA["body"], "Just a test")