def test__get_db(self):
fresh_db = None
with captured_output():
with self.app_context:
fresh_db = psql_db.get_db()
fresh_db.load_schema()
self.assertIsNotNone(self.db)
def test__post_no_snippet(self):
with captured_output():
login_user(self.client)
result = self.client.post(
"/999/view",
)
self.assertEqual(404, result.status_code)
def test__user_is_test(self):
with captured_output():
with self.app.test_request_context("/create") as trc:
trc.g.user = self.db.run_query(
"SELECT * FROM users WHERE id = %s", (1, ))[0]
g_user = trc.g.user
self.assertEqual("test", g_user.get("username"))
def test__delete_snippet_success(self):
with captured_output():
login_user(self.client)
result = self.client.post("/1/delete")
redirect_url = result.headers.get("location")
expected_url = "http://localhost/"
self.assertEqual(redirect_url, expected_url)
def testUpdate(self):
ech = echo.Echo()
expected = "blind pig"
with captured_output() as (out, err):
ech.update(expected)
observed = out.getvalue()
self.assertEqual(expected, observed)
def setUp(self):
with captured_output():
super().setUp()
self.client.post("/users/register",
data={
"username": "******",
"password": "******"
})
def test__post_success_status(self):
with captured_output():
login_user(self.client)
result = self.client.post(
"/1/view",
follow_redirects=True
)
self.assertEqual(200, result.status_code)
def test__post_no_title(self):
with captured_output():
login_user(self.client)
result = self.client.post(
"/create",
data={"title": None, "body": "test"}
)
self.assertIn(b'Title is required.', result.data)
def test__register_no_password(self):
with captured_output():
result = self.client.post(
"/users/register",
data={"username": "******"},
follow_redirects=True,
)
self.assertIn(b'Password is required.', result.data)
def test__post_success_status(self):
with captured_output():
login_user(self.client)
result = self.client.post(
"/create",
data={"title": "test", "body": "test"},
follow_redirects=True
)
self.assertEqual(200, result.status_code)
def test__register_post_status_success(self):
with captured_output():
result = self.client.post("/users/register",
data={
"username": "******",
"password": "******"
},
follow_redirects=True)
self.assertEqual(200, result.status_code)
def test__user_is_None(self):
with captured_output():
with self.client.session_transaction() as sess:
sess.pop("user_id", None)
with self.app.test_request_context("/") as trc:
trc.session = sess
users.load_logged_in_user()
g_user = trc.g.get("user", None)
self.assertEqual(None, g_user)
def test__user_is_test(self):
with captured_output():
with self.client.session_transaction() as sess:
sess["user_id"] = "1"
with self.app.test_request_context("/") as trc:
trc.session = sess
users.load_logged_in_user()
g_user = trc.g.get("user")
self.assertEqual("test", g_user.get("username"))
def test__run_query__insert(self):
with captured_output():
self.db.run_query(
"INSERT INTO users (username, password) VALUES (%s, %s)",
("un1", "pw1"))
cur = self.db.conn.cursor()
cur.execute("SELECT * FROM users WHERE username='******'")
result = cur.fetchall()
self.assertEqual(len(result), 1)
def test__run_query__select(self):
with captured_output():
self.db.open_connection()
cur = self.db.conn.cursor()
cur.execute(
"INSERT INTO users (username, password) VALUES (%s, %s)",
("un1", "pw1"))
result = self.db.run_query("SELECT * FROM users WHERE username=%s",
("un1", ))
self.assertEqual(len(result), 1)
def test__post_success(self):
with captured_output():
login_user(self.client)
result = self.client.post(
"/create",
data={"title": "test", "body": "test"}
)
redirect_url = result.headers.get("location")
expected_url = "http://localhost/"
self.assertEqual(redirect_url, expected_url)
def test__close_db(self):
# the close_db method interacts with Flask's g object, which lives
# within the request_context rather than the app_context
with captured_output():
with self.app.test_request_context() as trc:
trc.g.db = psql_db.get_db()
trc.g.db.open_connection()
psql_db.close_db()
self.assertNotEqual(self.db.conn.closed, 0)
def test__valid_snippet_check_author_passes(self):
with captured_output():
with self.app_context:
with self.client.session_transaction() as sess:
sess["user_id"] = "1"
with self.app.test_request_context() as trc:
trc.session = sess
users.load_logged_in_user()
snippet = snippets.get_snippet("1", check_author=True)
self.assertEqual("test_title1", snippet["title"])
def test__valid_snippet_check_author_fails(self):
with captured_output():
with self.app_context:
with self.client.session_transaction() as sess:
sess["user_id"] = "2"
with self.assertRaises(werkzeug.exceptions.Forbidden):
# abort 403 == Forbidden
with self.app.test_request_context() as trc:
trc.session = sess
users.load_logged_in_user()
snippets.get_snippet("1", check_author=True)
def test__clear_schema(self):
actual_tables = []
with captured_output():
self.db.clear_schema()
self.db.open_connection()
cur = self.db.conn.cursor()
cur.execute("SELECT table_name FROM information_schema.tables " +
"WHERE table_schema = 'public'")
for table in cur.fetchall():
actual_tables.append(table)
self.assertEqual([], actual_tables)
def test__login_wrong_password(self):
with captured_output():
result = self.client.post(
"/users/login",
data={
"username": "******",
"password": "******"
},
follow_redirects=True,
)
self.assertIn(b'Incorrect password.', result.data)
def test__load_schema(self):
actual_tables = []
expected_tables = ['users', 'snippet']
with captured_output():
self.db.open_connection()
cur = self.db.conn.cursor()
for table in expected_tables:
cur.execute(
"select exists(select * from information_schema.tables " +
"where table_name=%s)", (table, ))
actual_tables.append(cur.fetchone()[0])
self.assertEqual(True, all(actual_tables))
def test__register_post_url(self):
with captured_output():
result = self.client.post(
"/users/register",
data={
"username": "******",
"password": "******"
},
)
redirect_url = result.headers.get("location")
expected_url = "http://localhost/users/login"
self.assertEqual(redirect_url, expected_url)
def test__register_already_registered(self):
with captured_output():
result = self.client.post(
"/users/register",
data={
"username": "******",
"password": "******"
},
follow_redirects=True,
)
result = self.client.post(
"/users/register",
data={
"username": "******",
"password": "******"
},
follow_redirects=True,
)
self.assertIn(b'User test is already registered.', result.data)
def setUp(self):
super().setUp()
with captured_output():
self.client.post(
"/users/register",
data={
"username": "******",
"password": "******"
},
follow_redirects=True,
)
self.client.post(
"/users/login",
data={
"username": "******",
"password": "******"
},
follow_redirects=True,
)
def setUp(self):
with captured_output():
super().setUp()
self.client.post(
"/users/register",
data={"username": "******", "password": "******"}
)
self.client.post(
"/users/register",
data={"username": "******", "password": "******"}
)
self.db.run_query(
"INSERT INTO snippet (title, body, author_id) VALUES (%s, %s, %s)",
("test_title1", "test_body1", 1)
)
self.db.run_query(
"INSERT INTO snippet (title, body, author_id) VALUES (%s, %s, %s)",
("test_title2", "test_body2", 1)
)
def test__get_status_code_200(self):
with captured_output():
login_user(self.client)
result = self.client.get("/1/view")
self.assertEqual(200, result.status_code)
def test__get_render_create_html(self):
with captured_output():
login_user(self.client)
result = self.client.get("/create")
self.assertIn(b'New Post', result.data)
def test__snippets_exist(self):
with captured_output():
result = self.client.get("/")
snippets_exist = (b'test_title2' in result.data) and (b'test_title1' in result.data)
self.assertTrue(snippets_exist)
def test__delete_snippet_wrong_author_returns_403(self):
with captured_output():
login_user(self.client, "test2")
result = self.client.post("/1/delete")
self.assertEqual(403, result.status_code)
def test__delete_snippet_doesnt_exist_returns_404(self):
with captured_output():
login_user(self.client)
result = self.client.post("/999/delete")
self.assertEqual(404, result.status_code)
