def test_post_update_post(self):
""" Posting a new post """
data = {
"title": "Example Post",
"body": "Just a test"
}
response = self.client.post("/api/posts",
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.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")
data = {
"title": "Example Updated Post",
"body": "Just an update test"
}
response = self.client.post("/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.decode("ascii"))
self.assertEqual(data["id"], 1)
self.assertEqual(data["title"], "Example Updated Post")
self.assertEqual(data["body"], "Just an update test")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Example Updated Post")
self.assertEqual(post.body, "Just an update test")
def test_modified_data(self):
""" Tests editing existing post """
data = {
"title": "Example Post",
"body": "Just a test"
}
mod_data = {
"title": "Example Post modified",
"body": "This is my new bodayyyy"
}
response = self.client.post("/api/posts",
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.decode("ascii"))
self.assertEqual(data["id"], 1)
self.assertEqual(data["title"], "Example Post")
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")
# Now test the PUT modified version
response = self.client.put("/api/posts/{}".format(1),
data=json.dumps(mod_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"], "Example Post modified")
self.assertEqual(data["body"], "This is my new bodayyyy")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Example Post modified")
self.assertEqual(post.body, "This is my new bodayyyy")
def test_delete_post(self):
post = models.Post(title='Example Post A', body='Just a test')
session.add(post)
session.commit()
self.assertEqual(session.query(models.Post).get(1), post)
response = self.client.delete('/api/posts/1',
headers=[('Accept', 'application/json')]
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.mimetype, 'application/json')
self.assertEqual(session.query(models.Post).get(1), None)
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 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 testPostPost(self):
""" Posting a new post """
data = {
"title": "Example Post",
"body": "Just a test"
}
response = self.client.post("/api/posts",
data=json.dumps(data),
content_type="application/json",
headers=[("Accept", "application/json")]
)
# Check response for '201 Created' status
self.assertEqual(response.status_code, 201)
self.assertEqual(response.mimetype, "application/json")
# 'Location' header has been set to point the client towards new resource
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 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_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")
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_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")
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 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_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 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 test_post_post(self):
''' posting a new post '''
data = {
'title': 'Example Post',
'body': 'Just a test'
}
response = self.client.post('/api/posts',
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.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 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 testEditPost(self):
""" Editing title and body of an existing post """
data = {
"title": "Example Post",
"body": "Just a test"
}
response = self.client.post("/api/posts",
data=json.dumps(data),
content_type="application/json",
headers=[("Accept", "application/json")]
)
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")
update = {
"title": "Updated Title",
"body": "Updated Body"
}
response = self.client.post("/api/posts/1",
data=json.dumps(update),
content_type="application/json",
headers=[("Accept", "application/json")]
)
data = json.loads(response.data)
self.assertEqual(data["id"], 1)
self.assertEqual(data["title"], "Updated Title")
self.assertEqual(data["body"], "Updated Body")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Updated Title")
self.assertEqual(post.body, "Updated Body")
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):
""" Delete a single post from a populated database """
self.test_get_post()
post = session.query(models.Post).filter(models.Post.title.like("%Example Post A%")).first()
response = self.client.delete("/api/posts/{}".format(post.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 successfully deleted")
def test_delete_post(self):
postA = models.Post(title="Example Post A", body="Just a test")
session.add(postA)
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), 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")
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_delete_post(self):
"""Deleting a single post from the database"""
postA = models.Post(title="Example Post A", body="Just a test")
session.add(postA)
session.commit()
response = self.client.delete("/api/posts/{}".format(postA.id))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.mimetype, "application/json")
postA = session.query(models.Post).get(1)
#self.assertNotEqual(postA.id, 1)
self.assertIsNone(postA)
def test_delete_post(self):
"""Deleting a single post from the database"""
postA = models.Post(title="Example Post A", body="Just a test")
session.add(postA)
session.commit()
response = self.client.delete("/api/posts/{}".format(postA.id))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.mimetype, "application/json")
postA = session.query(models.Post).get(1)
#self.assertNotEqual(postA.id, 1)
self.assertIsNone(postA)
def testDelPost(self):
"""Deleting a single post from a populated database"""
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, 204)
self.assertEqual(response.mimetype, "application/json")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 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)
def test_post_put(self):
""" Editing a post """
data = {"title": "Example Post", "body": "Just a test"}
response = self.client.post("/api/posts",
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.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")
data = {"title": "Edited example Post", "body": "Edited just a test"}
response = self.client.put("/api/posts/{}".format(post.id),
data=json.dumps(data),
content_type="application/json",
headers=[("Accept", "application/json")])
self.assertEqual(response.status_code, 202)
self.assertEqual(response.mimetype, "application/json")
response = self.client.get("/api/posts/{}".format(post.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"], "Edited example Post")
self.assertEqual(post["body"], "Edited just 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 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_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 testPostPostToId(self):
#editing a post at a specific id
dataUpdateB = {
'title': 'Updated Post B',
'body': 'Updated test for post B'
}
postA = models.Post(title="Example Post A", body="Test for post A")
postB = models.Post(title="Example Post B", body="Test for post B")
postC = models.Post(title="Example Post C", body="Test for post C")
session.add_all([postA, postB, postC])
session.commit()
response = self.client.post("/api/posts/{}".format(postB.id),
data=json.dumps({"title":"Updated Post B", "body":"Updated test for post B"}),
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/2")
data = json.loads(response.data)
print data
self.assertEqual(data["id"], 2)
self.assertEqual(data["title"], "Updated Post B")
self.assertEqual(data["body"], "Updated test for post B")
posts = session.query(models.Post).filter(models.Post.id == 2).all()
print data
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.id, 2)
self.assertEqual(post.title, "Updated Post B")
self.assertEqual(post.body, "Updated test for post B")
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 testPutPost(self):
""" Editing a post """
# Adding a post to the database
post = models.Post(title="Example Post", body="Just a test")
session.add(post)
session.commit()
data = {
"title": "Updated Example Post",
"body": "Just an updated test"
}
# Getting a response for the post
response = self.client.put("/api/post/{}".format(post.id),
data = json.dumps(data),
content_type="application/json",
headers=[("Accept", "application/json")]
)
# Testing the response
self.assertEqual(response.status_code, 201)
self.assertEqual(response.mimetype, "application/json")
# Location of the updated post
self.assertEqual(urlparse(response.headers.get("Location")).path,
"/api/posts/1")
# Testing that the json response data is our updated post data
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")
# Querying the database to check that our updated post is there
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
# Checking that the contents of the post in the database matches our updated post
post = posts[0]
self.assertEqual(post.title, "Updated Example Post")
self.assertEqual(post.body, "Just an updated 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_deleted_post(self):
postC = models.Post(title="Example Post C", body="Delete this")
postD = models.Post(title="Example Post D", body="Don't delete this")
session.add_all([postC, postD])
session.commit()
response = self.client.get("/api/posts/{}".format(postC.id),
headers=[("Accept", "application/json")]
)
session.delete(postC)
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)
postD = posts[0]
self.assertEqual(postD.title, "Example Post D")
self.assertEqual(postD.body, "Don't delete this")
def test_post_put(self):
""" Posting a new post """
# Test post title and body
data = {
"title": "Example Post",
"body": "Just a test"
}
# Test API response with post method
# - Test post request
response = self.client.post("api/posts",
data = json.dumps(data),
content_type="application/json",
headers=[("Accept", "application/json")]
)
# - Test header of response is as expected (201 not 200 as 'created')
self.assertEqual(response.status_code, 201)
self.assertEqual(response.mimetype, "application/json")
# - Location of post is endpoint where new post can be accessed
self.assertEqual(urlparse(response.headers.get("Location")).path,
"/api/posts/1")
# - Test response body('data') is as expected
data = json.loads(response.data)
self.assertEqual(data["id"], 1)
self.assertEqual(data["title"], "Example Post")
self.assertEqual(data["body"], "Just a test")
# - Test database contains post
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
# - Test database entry is same as Test Post
post = posts[0]
self.assertEqual(post.title, "Example Post")
self.assertEqual(post.body, "Just a test")
def test_delete_single_post(self):
"""delete a single post"""
postA = models.Post(title="Example Post A", body="Don't delete")
postB = models.Post(title="Example Post B", body="Delete")
session.add_all([postA, postB])
session.commit()
response = self.client.get(
"/api/posts/{}".format(postB.id),
headers=[("Accept", "application/json")])
session.delete(postB)
session.commit
self.assertEqual(response.status_code, 200)
self.assertEqual(response.mimetype, "application/json")
data = session.query(models.Post).all()
self.assertEqual(len(data), 1)
postA = data[0]
self.assertEqual(postA.title, "Example Post A")
self.assertEqual(postA.body, "Don't delete")
def test_post_edit_post(self):
""" Edit an existing post """
# Creat an entry in the datbase to edit.
edit_post = models.Post(title="Test Edit",
body="Please change the content of this post")
session.add(edit_post)
session.commit()
data = {
"title": "Example editing a post",
"body": "Test edit"
}
response = self.client.post("/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.decode("ascii"))
self.assertEqual(data["id"], 1)
self.assertEqual(data["title"], "Example editing a post")
self.assertEqual(data["body"], "Test edit")
# Verify the post was inserted into the database
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Example editing a post")
self.assertEqual(post.body, "Test edit")
