def testEditPost(self):
#Logging in as Alice and creating a test post
self.simulate_login(self.user_a)
add_response = self.add_test_post()
post = session.query(Post).filter_by(author_id = self.user_a.id).first()
#editing the content as Alice
alice_edit_response = self.client.post("/post/{}/edit".format(post.id), data={
"title": "Alice's updated title",
"content": "Alice's updated content"
})
#Logging out as Alice and logigng in as Eddie
self.simulate_logout(self.user_a)
self.simulate_login(self.user_b)
#Attempting to edit Alice's post as Eddie
eddie_edit_response = self.client.post("/post/{}/edit".format(post.id), data={
"title": "Eddie's title",
"content": "Eddie's content"
})
new_post = session.query(Post).first()
self.assertEqual(new_post.title, "Alice's updated title")
self.assertEqual(new_post.content, "<p>Alice's updated content</p>\n")
self.assertEqual(new_post.author, self.user_a)
self.assertEqual(alice_edit_response.status_code, 302)
self.assertEqual(eddie_edit_response.status_code, 302)
def testUpdate(self): carol = session.query(User).filter(User.name == "Alice").one() carol.name = "Carol" session.add(carol) session.commit() temp = session.query(User).filter(User.id == 1).one() self.assertEqual(temp.name, "Carol")
def testDeletePost(self): #this is not described in detail in tutorial, it from example of testAddPost
self.simulate_login()
response1 = self.client.post("/post/add", data={
"title": "Test Post1",
"content": "Test content1"
})
response2 = self.client.post("/post/add", data={
"title": "Test Post2",
"content": "Test content2"
})
self.assertEqual(response1.status_code, 302)
self.assertEqual(urlparse(response1.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 2)
#we are testing that post 2 is NOT being deleted. In contrast to post 1 which IS deleted
post2 = posts[1]
post2_id = post2.id
delete_url2 = "/post/" + str(post2.id) + "/delete"
post2_list = session.query(models.Post).filter(models.Post.id == post2_id).all()
self.assertEqual(len(post2_list), 1)
#we are testing that post1 is in fact being deleted. This is the real test.
post1 = posts[0]
post1_id = post1.id
delete_url1 = "/post/" + str(post1.id) + "/delete"
session.delete(post1)
session.commit()
post1_list = session.query(models.Post).filter(models.Post.id == post1_id).all()
self.assertEqual(len(post1_list), 0)
def testAddPost(self):
# Does not work before logged in
response = self.client.post("/post/add", data = {
"title": "Test Post",
"content": "Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/login")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
# Works after logging in
self.simulate_login(self.alice)
response = self.client.post("/post/add", data = {
"title": "Test Post",
"content": "Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.alice)
def test_add_edit_entry(self):
self.simulate_login()
response = self.client.post("/entry/add",
data={
"title": "Test Entry",
"content": "Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.title, "Test Entry")
self.assertEqual(entry.content, "Test content")
self.assertEqual(entry.author, self.user)
response = self.client.post("/entry/1/edit",
data={
"title": "Edited Test Entry",
"content": "Edited Test Content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.title, "Edited Test Entry")
self.assertEqual(entry.content, "Edited Test Content")
def testEditPost(self):
# To act as a logged in user
self.simulate_login()
# Send a POST request to add
response = self.client.post("/post/add", data={
"title": "Test Post",
"content": "Test Content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
# Send a POST request to edit
post = posts[0].id
self.client.post("/post/{}/edit".format(post), data={
"title": "Change Test Post",
"content": "Change Test Content"
})
post = session.query(models.Post).first()
self.assertEqual(post.title, "Change Test Post")
self.assertEqual(post.content, "<p>Change Test Content</p>\n")
self.assertEqual(post.author, self.user)
def testRelationships(self): alice = session.query(User).filter(User.name == "Alice").one() post1 = session.query(Post).filter(Post.title == "Alice's Title").one() self.assertEqual(alice.posts[0].title, "Alice's Title") self.assertEqual(post1.author.name, "Alice") session.delete(alice) session.commit() self.assertIsNone(post1.author)
def testAdds(self): posts = session.query(Post).all() self.assertEqual(len(posts), 2) users = session.query(User).all() self.assertEqual(len(users),2) alice = session.query(User).filter(User.name == "Alice").one() self.assertEqual(alice.id, 1) post1 = session.query(Post).filter(Post.title == "Alice's Title").one() self.assertEqual(post1.id, 1)
def test_delete_entry(self):
self.simulate_login()
self.test_add_entry()
entry = session.query(Entry).first()
entries = session.query(Entry).all()
session.delete(entry)
session.commit()
entries = session.query(Entry).all()
self.assertEqual(len(entries), 0)
def testDeletePost(self):
self.simulate_login(self.user_a)
add_response = self.add_test_post()
post = session.query(Post).first()
delete_response = self.client.post("/post/{}/delete".format(post.id))
count = len(session.query(Post).all())
self.assertEqual(delete_response.status_code, 302)
self.assertEqual(count, 0)
self.assertEqual(session.query(Post).filter_by(id=post.id).first(), None)
def test_delete_entry(self):
self.simulate_login()
self.test_add_entry()
entries_beginning = session.query(Entry).all()
entry_id = str(1)
#this is a weak point of this test - it relies on there being an entry with id 1...
response = self.client.post("/entry/"+str(entry_id)+"/delete",
data = entry_id)
entries_end = session.query(Entry).all()
self.assertEqual(len(entries_end), (len(entries_beginning)-1))
def testDeletePost(self):
self.simulate_login()
response = self.client.post("/post/add", data={
"title": "Test Post",
"content": "Test content"
})
posts = session.query(models.Post).all()
post = posts[0]
response = self.client.get("/post/{}/delete".format(post.id))
self.assertEqual(response.status_code, 302)
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def testDeletePost(self):
self.simulate_login(self.alice)
# Create an example post by Alice
response = self.client.post("/post/add", data = {
"title": "Test Post",
"content": "Test content"
})
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.alice)
# Redirect if not logged in
self.simulate_logout()
response = self.client.post("/post/%i/delete" % post.id)
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.alice)
# Redirect if user is not author of post
self.simulate_login(self.bob)
response = self.client.post("/post/%i/delete" % post.id)
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.alice)
# Works is user is logged in and author of post
self.simulate_login(self.alice)
response = self.client.post("/post/%i/delete" % post.id)
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def testAddPost(self):
#call simulate_login method to act as a logged in user.
self.simulate_login()
#send POST request to /post/add using self.client.post method.
#use data paramter to provide the form data for an example post
response = self.client.post("/post/add", data={
"title": "Test Post",
"content": "Test content"
})
"""check response from app looks correct"""
#make sure user is being redirected to / route by checking status code
#and location header of the response
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
#look to see that only one post has been added
posts = session.query(models.Post).all()
self.assertEqual(len(posts),1)
#verifying post has been added to db correctly by making sure title and content values are correct
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.user)
def test_edit_post(self):
self.simulate_login()
test_post = models.Post(
title="Test Post",
content="Test Content",
author_id=self.user.id
)
session.add(test_post)
session.commit()
response = self.client.post("/post/edit/1", data={
"title": "Edit Post",
"content": "Edit content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Edit Post")
# self.assertEqual(post.content, "<p>Edit content</p>\n")
self.assertEqual(post.content, "Edit content")
self.assertEqual(post.author, self.user)
def adduser():
"""Create new user"""
# User input name and email address
name = raw_input("Name: ")
email = raw_input("Email: ")
# Test whether user already exists
if session.query(User).filter_by(email=email).first():
print "User with that email address already exists"
return
# User input password (entered twice for verification)
password = ""
password_2 = ""
# Loop while either password is empty or passwords do not match
while not (password and password_2) or password != password_2:
# Use builtin getpass function to input password without echoing string
password = getpass("Password: "******"Re-enter password: ")
# Create new user instance
# Password is converted to hash - string of characters based on SHA1 hashing algorithm
# Hashes only work one-way (password to hash string) to prevent malicious use of stored passwords
user = User(name=name,
email=email,
password=generate_password_hash(password))
session.add(user)
session.commit()
def setUp(self):
""" Test setup """
self.browser = Browser("phantomjs")
# Set up the tables in the database
Base.metadata.create_all(engine)
# Create an example user
self.user = models.User(name="Alice", email="*****@*****.**",
password=generate_password_hash("test"))
session.add(self.user)
session.commit()
# Create an example post with example user as author
self.author = session.query(models.User).filter(
models.User.name == "Alice").first()
self.post = models.Post(
title="Test Post #1",
content="The quick brown fox jumps over the lazy dog.",
author=self.author
)
session.add(self.post)
session.commit()
self.process = multiprocessing.Process(target=app.run)
self.process.start()
time.sleep(1)
def adduser():
"""
Ask user for name, email address, and password (twice).
Check to make sure the user is not already stored in the database.
Make sure both passwords entered by user match.
Finally, create the user object and add it to our database.
"""
name = raw_input("Name: ")
email = raw_input("Email: ")
if session.query(User).filter_by(email=email).first():
print "User with that email address already exists"
return
password = raw_input("Password: "******"Re-enter password: "******"Password: "******"Re-enter password: "******"""
generate_password_hash function:
1) Function is used to hash our password
2) Hashing - process that converts our plain text password
into a string of characters
3) Passwords use only One-Way-Hashes: process works in one direction
"""
session.add(user)
session.commit()
def test_edit_post(self):
self.simulate_login()
test_post = models.Post(title="Test Post",
content="Test Content",
author_id=self.user.id)
session.add(test_post)
session.commit()
response = self.client.post("/post/edit/1",
data={
"title": "Edit Post",
"content": "Edit content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Edit Post")
# self.assertEqual(post.content, "<p>Edit content</p>\n")
self.assertEqual(post.content, "Edit content")
self.assertEqual(post.author, self.user)
def adduser():
"""
Ask user for name, email address, and password (twice).
Check to make sure the user is not already stored in the database.
Make sure both passwords entered by user match.
Finally, create the user object and add it to our database.
"""
name = raw_input("Name: ")
email = raw_input("Email: ")
if session.query(User).filter_by(email=email).first():
print "User with that email address already exists"
return
password = raw_input("Password: "******"Re-enter password: "******"Password: "******"Re-enter password: "******"""
generate_password_hash function:
1) Function is used to hash our password
2) Hashing - process that converts our plain text password
into a string of characters
3) Passwords use only One-Way-Hashes: process works in one direction
"""
session.add(user)
session.commit()
def test_edit_entry(self):
self.simulate_login()
# Create an test entry
test_entry = Entry(title="Test title",
content="Testing editing entry",
author=self.user)
session.add(test_entry)
session.commit()
response = self.client.post("/entry/1/edit",
data={
"title": "Title edited",
"content": "Content edited"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.title, "Title edited")
self.assertEqual(entry.content, "Content edited")
self.assertEqual(entry.author, self.user)
def test_delete_entry(self):
self.simulate_login()
response = self.client.post("/entry/add", data={
"title": "Test Entry",
"content": "Test content"
})
entries = session.query(Entry).all()
entry=entries[0]
response = self.client.post("/entry/{}/delete".format(entry.id))
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 0)
def adduser():
"""Create new user"""
name = input("Name: ")
email = input("Email: ")
if session.query(User).filter_by(email=email).first():
print ("User with that email address already exists")
return
password = raw_input("Password: "******"Re-enter password: "******"Password: "******"Re-enter password: "******"""
generate_password_hash function:
1) Function is used to hash our password
2) Hashing - process that converts our plain text password
into a string of characters
3) Passwords use only One-Way-Hashes: process works in one direction
"""
session.add(user)
session.commit()
def test_delete_post(self):
self.simulate_login()
response = self.client.post('/post/add', data={
'title': 'Test Post',
'content': 'Test Content'
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, '/')
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
print type(response)
print vars(response)
post = posts[0]
post_url = '/post/%s' % post.id
post_delete = '/post/%s/delete' % post.id
self.assertEqual(self.client.get(post_url).status_code, 200)
delete_post = self.client.get(post_delete)
self.assertEqual(delete_post.status_code, 302)
self.assertEqual(self.client.get(post_url).status_code, 500)
print delete_post
def test_delete_entry(self):
self.stimulate_login()
#add entry
response = self.client.post("/entry/add", data={"title": "Test Entry", "content": "Test content"})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
#confirm entry has been added
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.author, self.user)
#delete entry
response = self.client.post("/entry/1/delete")
self.assertEqual(response.status_code, 302)
entries = session.query(Entry).all()
self.assertEqual(len(entries),0)
def test_wrong_author_edit(self):
self.simulate_login()
response = self.client.post("entry/0/edit", data=self.entry_data)
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertNotEqual(entry.author, self.peter)
def testLogout(self):
self.testAddPost()
self.simulate_logout()
response = self.client.get("/post/1/edit")
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
post = session.query(models.Post).first()
self.assertEqual(post.title, "Test Post")
response = self.client.get("/post/1/delete")
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
self.assertEqual(posts[0].title, "Test Post")
def testDeletePost(self):
self.testAddPost()
response = self.client.post("/post/1/delete")
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def test_delete_entry(self):
self.test_add_entry()
self.browser.visit("http://127.0.0.1:8080/entry/0/delete")
button = self.browser.find_by_css("button[type=submit]")
button.click()
entries = session.query(Entry).count()
self.assertEqual(entries, 0)
def test_wrong_author_edit(self):
self.simulate_login()
response = self.client.post("entry/0/edit", data=self.entry_data)
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertNotEqual(entry.author, self.peter)
def test_del_entry(self):
self.simulate_login()
response = self.client.post("/entry/add", data={
"title": "Test Entry",
"content": "Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
response = self.client.post("/entry/{}/delete".format(entry.id))
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 0)
def test_add_edit_delete_entry(self):
self.simulate_login()
response = self.client.post("/entry/add", data={
"title": "Test Entry",
"content": "Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
#should be one entry
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
#checks that title and content appear correctly
entry = entries[0]
self.assertEqual(entry.title, "Test Entry")
self.assertEqual(entry.content, "Test content")
self.assertEqual(entry.author, self.user)
#tests edit entry function
response = self.client.post("/entry/1/edit", data={
"title": "Edited Test Entry",
"content": "Edited Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
# Test post data
entry = session.query(Entry).all()
entry = entries[0]
#New title/content after edit
self.assertEqual(entry.title, "Edited Test Entry")
self.assertEqual(entry.content, "Edited Test content")
self.assertEqual(entry.author, self.user)
#deletes the entry
response = self.client.post("/entry/1/delete")
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
# Should not be any entries left
entries = session.query(Entry).all()
self.assertEqual(len(entries), 0)
def testDeletePost(self):
# To act as a logged in user
self.simulate_login()
# Send a POST request to add
response = self.client.post("/post/add", data={
"title": "Test Post",
"content": "Test Content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
# Send a POST request to delete
post = posts[0].id
self.client.post("/post/{}/delete".format(post))
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def test_edit_entry(self):
self.test_add_entry()
self.browser.visit("http://127.0.0.1:8080/entry/0/edit")
self.browser.fill("title", "test title + edit")
self.browser.fill("content", "test content + edit")
button = self.browser.find_by_css("button[type=submit]")
button.click()
entry = session.query(Entry).all()[0]
self.assertEqual(entry.title, "test title + edit")
self.assertEqual(entry.content, "test content + edit")
def testAddPost(self): self.simulate_login(self.user_a) response = self.add_test_post() self.assertEqual(response.status_code, 302) self.assertEqual(urlparse(response.location).path, "/") posts = session.query(models.Post).all() self.assertEqual(len(posts), 1) post = posts[0] self.assertEqual(post.title, "Test Post") self.assertEqual(post.content, "<p>Test content</p>\n") self.assertEqual(post.author, self.user_a)
def adduser():
name=input("Name: ")
email=input("Email: ")
if session.query(User).filter_by(email=email).first():
print("User with that email address alreadye exists")
return
password=""
while len(password)<8 or password!= password_2:
password=getpass("Password: "******"Re-enter password: ")
user = User(name=name, email=email, password=generate_password_hash(password))
session.add(user)
session.commit()
def test_edit_post(self):
self.simulate_login()
response = self.client.post("/post/add",
data={
"title": "Test Post",
"content": "Test content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
# print post.content
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.user)
response = self.client.post("/post/1/edit",
data={
"title": "Test Post",
"content": "Test content EDITED"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/post/1")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
# print post.content
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content EDITED</p>\n")
self.assertEqual(post.author, self.user)
def testDeletePost(self):
self.simulate_login()
response = self.client.post("/post/add",
data={
"title": "Test Post",
"content": "Test content"
})
posts = session.query(models.Post).all()
post = posts[0]
url = "/post/" + str(post.id) + "/delete/confirm"
response = self.client.post(str(url))
url = "/post/" + str(post.id)
response = self.client.post(str(url))
self.assertEqual(response.status_code, 405)
def test_add_entry(self):
self.simulate_login()
response = self.client.post("/entry/add", data={"title": "Test Entry", "content": "Test content"})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.title, "Test Entry")
self.assertEqual(entry.content, "Test content")
self.assertEqual(entry.author, self.user)
def test_add_post(self):
self.simulate_login()
response = self.client.post("/post/add", data={"title": "Test Post", "content": "Test content"})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.user)
def test_delete_post(self):
"""Test deleting post"""
self.simulate_login()
self.client.post("/post/add", data={
"title": "Test Post",
"content": "Test content"
})
response = self.client.post("/post/1/delete")
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(Post).all()
self.assertEqual(len(posts), 0)
def adduser():
name = input("Name: ")
email = input("Email: ")
if session.query(User).filter_by(email=email).first():
print("User with that email address already exists")
return
password = ""
while len(password) < 8 or password != password_2:
password = getpass("Password: "******"Re-enter password: ")
user = User(name=name, email=email,
password=generate_password_hash(password))
session.add(user)
session.commit()
def adduser():
name = input('Name: ')
email = input('Email: ')
if session.query(User).filter_by(email = email).first():
print('User with that email address already exists.')
return
password = ''
password_2 = ''
while len(password) < 8 or password != password_2:
password = getpass('Password: '******'Re-enter password: ')
user = User(name = name, email = email, password = generate_password_hash(password))
session.add(user)
session.commit()
def test_view_post(self):
self.simulate_login()
response = self.client.post('/post/add', data={
'title': 'Test Post',
'content': 'Test Content'
})
posts = session.query(models.Post).all()
post = posts[0]
post_url = '/post/%s/' % post.id
view_post = self.client.get(post_url)
print view_post
def adduser():
name = input('Name: ')
email = input('Email: ')
if session.query(User).filter_by(email=email).first():
print('User with that email address already exists')
return
password = ''
while len(password) < 8 or password != password_2:
password = getpass('Password: '******'Re-enter Password: ')
user = User(name=name,
email=email,
password=generate_password_hash(password))
session.add(user)
session.commit()
def test_delete_entry(self):
self.simulate_login()
title = "Launch your career as a web developer with 1-on-1 mentorship"
content = """Serious about becoming an engineer but unsure about committing to
a time consuming and expensive bootcamp? Our Web Development Career Path course
was designed with one goal: to get you hired. You\'ll work with a mentor, 1-on-1,
every step of the way. You\'ll also get unlimited access to expert-led Workshops
and Q&A Sessions when you're stuck or want to learn more."""
entry_id = self.simulate_add_entry(title, content)
delete_url = "/post/{}/delete".format(entry_id)
response = self.client.get(delete_url)
self.assertEqual(response.status_code, 302)
entries = session.query(Entry).filter(Entry.id == entry_id).all()
self.assertEqual(len(entries), 0)
def test_delete_post(self):
test_post = models.Post(title="Test Post",
content="Test Content",
author_id=self.user.id)
session.add(test_post)
session.commit()
post_id = test_post.id
self.simulate_login()
response = self.client.post("/post/delete/{}".format(post_id))
""" self.assertEqual(response.status_code, 302) AssertionError: 405 != 302 """
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def adduser():
name = raw_input("Name: ")
email = raw_input("Email: ")
if session.query(User).filter_by(email=email).first():
print "User with that email already exists"
return
password = ""
password2 = ""
while not (password and password2) or password != password2:
password = getpass("Password: "******"Re-Enter Password: ")
user = User(name=name, email=email, password=generate_password_hash(password))
session.add(user)
session.commit()
def adduser():
user = User()
user.name = raw_input("Name: ")
email = raw_input("Email: ")
if email == session.query(User).filter(User.email==email).first():
print "Someone's already registered with that email."
return
user.email = email
password = ""
password2 = ""
while not (password and password2) or password != password2:
password = getpass("Password:"******"Repeat password:")
user.password = generate_password_hash(password)
session.add(user)
session.commit()
def test_delete_entry(self):
self.simulate_login()
title ="Launch your career as a web developer with 1-on-1 mentorship"
content = """Serious about becoming an engineer but unsure about committing to
a time consuming and expensive bootcamp? Our Web Development Career Path course
was designed with one goal: to get you hired. You\'ll work with a mentor, 1-on-1,
every step of the way. You\'ll also get unlimited access to expert-led Workshops
and Q&A Sessions when you're stuck or want to learn more."""
entry_id = self.simulate_add_entry(title, content)
delete_url = "/post/{}/delete".format(entry_id)
response = self.client.get(delete_url)
self.assertEqual(response.status_code, 302)
entries = session.query(Entry).filter(Entry.id == entry_id).all()
self.assertEqual(len(entries), 0)
def adduser():
name = input("Name: ")
email = input("Email: ")
if session.query(User).filter_by(email=email).first():
print("User with that email address already exists")
return
password = ""
password_2 = ""
while len(password) < 8 or password != password_2:
password = getpass("Password: "******"Re-enter password: ")
# Hashing is the process which converts the plain text password to a string of characters
user = User(name=name,
email=email,
password=generate_password_hash(password))
session.add(user)
session.commit()
def testDeletePost(self):
"""Test deleting post"""
# Login using login simulation method from above
self.simulate_login()
# Add post
self.add_post()
# Delete Post
response = self.client.post("/post/1/delete")
# Test app response
self.assertEqual(response.status_code, 302) # 302 Found - redirect after POST
self.assertEqual(urlparse(response.location).path, "/") # Redirect path is root URI
# Test post data
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def test_add_entry(self):
self.simulate_login()
response = self.client.post('/entry/add',
data={
'title': 'Test Entry',
'content': 'Test content'
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, '/')
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.title, 'Test Entry')
self.assertEqual(entry.content, 'Test content')
self.assertEqual(entry.author, self.user)
def adduser():
name = raw_input("Name: ")
email = raw_input("Email: ")
if session.query(User).filter_by(email=email).first():
print "User with that email address already exists"
return
password = ""
password_2 = ""
while not (password and password_2) or password != password_2:
password = raw_input("Password: "******"Re-enter password: ")
break
user = User(name=name,
email=email,
password=generate_password_hash(password))
session.add(user)
session.commit()
def test_signup_user(self):
response = self.client.post("/signup",
data={
"name": "Bob",
"email": "*****@*****.**",
"password": "******",
"password_2": "thisisbobspassword",
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/login")
users = session.query(User).all()
self.assertEqual(len(users), 2)
user = users[1]
self.assertEqual(user.name, "Bob")
self.assertEqual(user.email, "*****@*****.**")
def test_create_user(self):
self.simulate_login()
response = self.client.post("/newuser",
data={
"name": "Nick Test",
"email": "*****@*****.**",
"password": "******"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
users = session.query(User).all()
self.assertEqual(len(users), 2)
user = users[1]
self.assertEqual(user.name, "Nick Test")
self.assertEqual(user.email, "*****@*****.**")
self.assertNotEqual(user.password, "testpassword")
def testAddPost(self):
"""Test adding post"""
# Login using login simulation method from above
self.simulate_login()
# Add post
response = self.add_post()
# Test app response
self.assertEqual(response.status_code, 302) # 302 Found - redirect after POST
self.assertEqual(urlparse(response.location).path, "/") # Redirect path is root URI
# Test post in database with count
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
# Test post data
post = posts[0]
self.assertEqual(post.title, "Test Post")
self.assertEqual(post.content, "<p>Test content</p>\n")
self.assertEqual(post.author, self.user)
def test_add_entry(self):
# Call simulate_login method so you can act as a logged in user
self.simulate_login()
response = self.client.post("/entry/add",
data={
"title": "Test Entry",
"content": "Test Content"
})
# The HTTP response status code 302 Found is a common way of performing URL redirection.
# Make sure that your user is being redirected to the / route by checking the status code and the location header of the response
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
entries = session.query(Entry).all()
self.assertEqual(len(entries), 1)
entry = entries[0]
self.assertEqual(entry.title, "Test Entry")
self.assertEqual(entry.content, "Test Content")
self.assertEqual(entry.author, self.user)
