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 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_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)