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")
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")
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")
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")
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(postA) session.add(postB) session.commit() session.delete(postA) session.delete(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), 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")
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")
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")
def testPostPut(self): """ Editing a post """ data = { "title": "UPDATED Example Post", "body": "Just an UPDATED test" } #first you create a post post = models.Post(title="example title", body="example body") session.add(post) session.commit() response = self.client.put("/api/edit/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") data = json.loads(response.data) self.assertEqual(data["id"], 1) self.assertEqual(data["title"], "UPDATED Example Post") self.assertEqual(data["body"], "Just an UPDATED test") posts = session.query(models.Post).all() self.assertEqual(len(posts), 1) post = posts[0] self.assertEqual(post.title, "UPDATED Example Post") self.assertEqual(post.body, "Just an UPDATED test")
def testEditPost(self): """ Editing a post """ postA = models.Post(title="Example Post A", body="Just a test") session.add(postA) session.commit() data = { "title": "Change Post", "body": "Change test" } 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, 200) self.assertEqual(response.mimetype, "application/json") posts = session.query(models.Post).all() self.assertEqual(len(posts), 1) post = posts[0] self.assertEqual(post.title, "Change Post") self.assertEqual(post.body, "Change test")
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")
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")
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" )
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()
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")
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")
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')
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")
def test_update_post(self): """ Updating a post (PUT request) 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(postA) session.commit() data_payload = { "title": "Example Post", "body": "a new test" } response = self.client.put("/api/posts/{}".format(postA.id), data=json.dumps(data_payload), content_type="application/json", headers=[("Accept", "application/json")] ) self.assertEqual(response.status_code, 200) self.assertEqual(response.mimetype, "application/json") data_response = json.loads(response.data) # {u'body': u'Just a test', u'id': 1, u'title': u'Example Post'} self.assertEqual(len(data_response), 3) # postA = data[0] self.assertEqual(data_response["title"], "Example Post") self.assertEqual(data_response["body"], "a new test")
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")
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")
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")
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")
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()
def test_edit_title_and_body(self): """ Editing a post's title and body """ data = { "title": "new example A", "body": "new example body" } postA= models.Post(title="Example A", body="test edit") session.add(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, 200) self.assertEqual(response.mimetype, "application/json") data = json.loads(response.data.decode("ascii")) self.assertEqual(data["title"], "new example A") self.assertEqual(data["body"], "new example body") posts = session.query(models.Post).all() self.assertEqual(len(posts), 1) post = posts[0] self.assertEqual(post.title, "new example A") self.assertEqual(post.body, "new example body")
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")
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")
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")
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")
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")
def test_delete_post(self): """ Deleting 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() 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(data["message"], "Deleted post 2")
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)
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)
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.decode("ascii")) self.assertEqual(post["title"], "Example Post B") self.assertEqual(post["body"], "Still a test")
def test_delete_post(self): """ Deleting a post """ #TODO: see create_multiple_posts() postA = models.Post(title="Example Post A", body="Just a test") session.add(postA) session.commit() response = self.client.delete("/api/posts/1", 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"], "Post #1 successfully deleted") self.assertEqual(session.query(models.Post).count(), 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")
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")
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")
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)
def test_delete_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") 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")
def test_delete_post(self): """ Deleting a single post from a 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() post_B_before = session.query(models.Post).get(postB.id) 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(data["message"], "Post {} deleted".format(postB.id)) post_B_after = session.query(models.Post).get(postB.id) post_deleted = post_B_before != None and post_B_after == None self.assertEqual(post_deleted, True)
def test_get_posts_with_body(self): """ Filtering posts by 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() response = self.client.get("/api/posts?body_like=Another", 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), 1) post = posts[0] self.assertEqual(post["title"], "Post with bells and whistles") self.assertEqual(post["body"], "Another test")
def testPutPost(self): """ Edit an existing post """ # Add new post postNew = models.Post(title="Just a test", body="Post with bells") session.add(postNew) session.commit() data = { "title": "Change the title", "body": "Change the body" } # Create PUT request using JSON from 'data' dictionary response = self.client.put("/api/posts/1", data=json.dumps(data), content_type="application/json", headers=[("Accept", "application/json")] ) # Test response code, mimetype, and location path self.assertEqual(response.status_code, 200) self.assertEqual(response.mimetype, "application/json") self.assertEqual(urlparse(response.headers.get("Location")).path, "/api/posts/1") # Test post content from response data = json.loads(response.data) self.assertEqual(data["title"], "Change the title") self.assertEqual(data["body"], "Change the body") # Query post from database posts = session.query(models.Post).all() self.assertEqual(len(posts), 1) # Test post content from database post = posts[0] self.assertEqual(post.title, "Change the title") self.assertEqual(post.body, "Change the body")
def test_get_posts_with_title_and_body(self): 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="Body with bells and whistles") session.add_all([postA, postB, postC]) session.commit() #different search query: 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), 1) post = posts[0] self.assertEqual(post["title"], "Post with bells and whistles") self.assertEqual(post["body"], "Body with bells and whistles")
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")
def seed(): post = Post(title="ksldfj", body="test2-2") session.add(post) session.commit()