def with_entry(db, request):
from journal import write_entry
expected = (u'Test Title)', u'Test Text')
with app.test_request_context('/'):
write_entry(*expected)
get_database_connection().commit()
def cleanup():
# NOTE: "You use a test_request_context in both setup and
# teardown to ensure that flask.g exists."
with app.test_request_context('/'):
con = get_database_connection()
cur = con.cursor()
cur.execute("DELETE FROM entries")
con.commit()
# Also note that allowing the two "with" blocks to close commits the
# transactions for each test context.
request.addfinalizer(cleanup)
return expected
def test_edit_entry(req_context):
from journal import edit_entry
from journal import write_entry
fields = ('title', 'text')
original = ('Test Title', 'Test Text')
req_context.params = dict(zip(fields, original))
write_entry(req_context)
req_context.db.commit()
rows = run_query(req_context.db, READ_ENTRY)
assert len(rows) == 1
actual = rows[0][1:3]
for idx, val in enumerate(original):
assert val == actual[idx]
req_context.matchdict = {'id': rows[0][0]}
expected = ('New Title', 'New Text')
req_context.params = dict(zip(fields, expected))
edit_entry(req_context)
req_context.db.commit()
rows = run_query(req_context.db, "SELECT title, text FROM entries")
assert len(rows) == 1
actual = rows[0]
for idx, val in enumerate(expected):
assert val == actual[idx]
def test_get_entry(req_context):
from journal import get_entry, write_entry, get_all_entries
# Verify it's empty
entries = get_all_entries()
assert len(entries) == 0
expected = ("Get Entry Title", "Get Entry Test")
write_entry(*expected)
# Verify it isn't empty
entries = get_all_entries()
assert len(entries) == 1
# Derive the id and use it to get_entry():
the_only_entry = get_entry(entries[0]['id'])
# I wish I had more time to do that properly, but it works.
assert expected[0] == the_only_entry['title']
assert expected[1] == the_only_entry['text']
assert 'created' in the_only_entry
def test_get_entry(req_context):
from journal import get_entry, write_entry
expected = ("My Title", "My Text")
write_entry(*expected)
entry_id = 4
entry = get_entry(entry_id)
assert expected[0] == entry['title']
assert expected[1] == entry['text']
def test_write_entry(req_context):
from journal import write_entry
expected = ("My Title", "My Text")
write_entry(*expected)
rows = run_independent_query("SELECT * FROM entries")
assert len(rows) == 1
for val in expected:
assert val in rows[0]
def test_get_entry(req_context):
from journal import get_entry, write_entry
expected = ("My Title", "My Text")
write_entry(*expected)
entry_id = 4
entry = get_entry(entry_id)
assert expected[0] == entry['title']
assert expected[1] == entry['text']
def test_write_entry(req_context):
from journal import write_entry
expected = ("My Title", "My Text")
write_entry(*expected)
rows = run_independent_query("SELECT * FROM entries")
assert len(rows) == 1
for val in expected:
assert val in rows[0]
def test_get_all_entries(req_context):
expected = ("My Title", "My Text")
write_entry(*expected)
entries = get_all_entries()
assert len(entries) == 1
for entry in entries:
assert expected[0] == entry['title']
assert expected[1] == entry['text']
assert 'created' in entry
def write_post(step):
from journal import write_entry
expected = (u'Test Title', step.multiline)
with app.test_request_context('/'):
write_entry(*expected)
# manually commit transaction here to avoid rollback due to
# handled exceptions
get_database_connection().commit()
def test_edit_entry(req_context):
from journal import edit_entry
from journal import write_entry
expected = ("My Title", "My Text")
write_entry(*expected)
the_row_we_added = run_independent_query("SELECT * FROM entries")
def test_get_all_entries(req_context):
from journal import get_all_entries, write_entry
expected = ("My Title", "<p>My Text</p>")
write_entry(*expected)
entries = get_all_entries()
assert len(entries) == 1
for entry in entries:
assert expected[0] == entry['title']
assert expected[1] == entry['text']
assert 'created' in entry
def test_get_one_entry(req_context):
from journal import get_one_entry
from journal import write_entry
expected = ("My Title", "My Text")
write_entry(*expected) # find actual row numbers from test db
target_entry = run_independent_query('SELECT id FROM entries')[0]
entry_2_update = get_one_entry(target_entry)
print entry_2_update
assert expected[0] == entry_2_update[1]
assert expected[1] == entry_2_update[2]
def test_get_one_entry(req_context):
from journal import get_one_entry
from journal import write_entry
expected = ("My Title", "My Text")
write_entry(*expected) # find actual row numbers from test db
target_entry = run_independent_query('SELECT id FROM entries')[0]
entry_2_update = get_one_entry(target_entry)
print entry_2_update
assert expected[0] == entry_2_update[1]
assert expected[1] == entry_2_update[2]
def test_get_all_entries(req_context):
from journal import get_all_entries, write_entry
expected = ("My Title", "My Text")
write_entry(*expected)
entries = get_all_entries()
assert len(entries) == 1
for entry in entries:
assert expected[0] == entry['title']
assert expected[1] == entry['text']
assert 'created' in entry
def add_entry(step):
from journal import write_entry
expected = ('Test Title', 'Test Text')
with app.test_request_context('/'):
write_entry(*expected)
# manually commit transaction here to avoid rollback due to
# handled exceptions
get_database_connection().commit()
world.expected = expected
def test_get_entry_1(req_context):
from journal import write_entry
from journal import get_entry
markdown_input = (u'Test Title', u'#Test Text')
expected_html = u'<h1>Test Text</h1>'
write_entry(markdown_input[0], markdown_input[1])
rows = run_independent_query("SELECT id FROM entries")
entry = get_entry(rows[0])
assert entry['text'] == markdown_input[1]
assert entry['title'] == markdown_input[0]
assert entry['html'] == expected_html
def test_edit_entry(req_context):
from journal import write_entry
from journal import get_entry
from journal import edit_entry
markdown_input = (u'Test Title', u'#Test Text')
write_entry(markdown_input[0], markdown_input[1])
rows = run_independent_query("SELECT id FROM entries")
entry = get_entry(rows[0])
new_strings = (u'New Title', u'New Text')
edit_entry(entry['id'], *new_strings)
entry = get_entry(rows[0])
assert entry['text'] == new_strings[1]
assert entry['title'] == new_strings[0]
def with_entry(db, request):
from journal import write_entry
expected = (u'Test Title', u'Test Text')
with app.test_request_context('/'):
write_entry(*expected)
get_database_connection().commit()
def cleanup():
with app.test_request_context('/'):
con = get_database_connection()
cur = con.cursor()
cur.execute("DELETE FROM entries")
con.commit()
request.addfinalizer(cleanup)
return expected
def with_entry(db, request):
from journal import write_entry
expected = (u'Test Title', u'Test Text')
with app.test_request_context('/'):
write_entry(*expected)
# commit transaction to avoid rollback if exception raised
get_database_connection().commit()
def cleanup():
with app.test_request_context('/'):
con = get_database_connection()
cur = con.cursor()
cur.execute("DELETE FROM entries")
# and here as well
con.commit()
request.addfinalizer(cleanup)
return expected
def with_entry(db, request):
from journal import write_entry
expected = (u'Test Title', u'Test Text')
with app.test_request_context('/'):
write_entry(*expected)
# manually commit transaction here to avoid rollback
# due to handled Exception
get_database_connection().commit()
def cleanup():
with app.test_request_context('/'):
con = get_database_connection()
cur = con.cursor()
cur.execute("DELETE FROM entries")
# and here as well
con.commit()
request.addfinalizer(cleanup)
return expected
def test_update_entry(req_context):
from journal import write_entry, update_entry
initial = ("Initial Title", "Initial Text")
expected = ("New Title", "New Text")
write_entry(*initial)
rows = run_independent_query("SELECT * FROM entries")
(id_num, ) = run_independent_query(
"SELECT id FROM entries WHERE title='Initial Title'")[0]
print id_num
assert len(rows) == 1
for val in initial:
assert val in rows[0]
# do the update
update_entry(id_num, *expected)
rows = run_independent_query("SELECT * FROM entries")
assert len(rows) == 1
for val in expected:
assert val in rows[0]
def test_update_entry(req_context):
from journal import write_entry, update_entry
initial = ("Initial Title", "Initial Text")
expected = ("New Title", "New Text")
write_entry(*initial)
rows = run_independent_query("SELECT * FROM entries")
(id_num, ) = run_independent_query(
"SELECT id FROM entries WHERE title='Initial Title'")[0]
print id_num
assert len(rows) == 1
for val in initial:
assert val in rows[0]
# do the update
update_entry(id_num, *expected)
rows = run_independent_query("SELECT * FROM entries")
assert len(rows) == 1
for val in expected:
assert val in rows[0]
def test_write_entry(req_context):
from journal import write_entry
fields = ('title', 'text')
expected = ('Test Title', 'Test Text')
req_context.params = dict(zip(fields, expected))
# assert that there are no entries when we start
rows = run_query(req_context.db, READ_ENTRY)
assert len(rows) == 0
write_entry(req_context)
# manually commit so we can see the entry on query
req_context.db.commit()
rows = run_query(req_context.db, "SELECT title, text FROM entries")
assert len(rows) == 1
actual = rows[0]
for idx, val in enumerate(expected):
assert val == actual[idx]
def test_write_entry(req_context):
from journal import write_entry
expected = ("My Title", "My Text")
# Remember, star args are just how you unpack things.
# ((double star args unpack things into a dict.))
write_entry(*expected)
# "run_independent_query() is a 'helper function' you can re-use."
# Where's it come from, pytest? By way of the decorator??
rows = run_independent_query("SELECT * FROM entries")
# Huh, so this is just assertEquals... from pytest?
# Maybe not, since it's its own freestanding operation?
assert len(rows) == 1
for val in expected:
assert val in rows[0]
def test_write_entry_not_string(req_context):
# 5 gets turned into a string, None throws an integrity error
from journal import write_entry
fields = ('title', 'text')
expected = (5, None)
req_context.params = dict(zip(fields, expected))
# assert that there are no entries when we start
rows = run_query(req_context.db, "SELECT * FROM entries")
assert len(rows) == 0
with pytest.raises(IntegrityError):
result = write_entry(req_context)
def test_write_entry_wrong_columns(req_context):
# throws integrity error for not writing into title and text
from journal import write_entry
fields = ('bob', 'hope')
expected = ('some text', 'more text')
req_context.params = dict(zip(fields, expected))
# assert that there are no entries when we start
rows = run_query(req_context.db, "SELECT * FROM entries")
assert len(rows) == 0
with pytest.raises(IntegrityError):
result = write_entry(req_context)
def test_write_entry(req_context):
from journal import write_entry
fields = ('title', 'text')
expected = ('Test Title', 'Test Text')
req_context.params = dict(zip(fields, expected))
rows = run_query(req_context.db, "SELECT * FROM entries")
assert len(rows) == 0
result = write_entry(req_context)
req_context.db.commit()
rows = run_query(req_context.db, "SELECT title, text FROM entries")
assert len(rows) == 1
actual = rows[0]
for idx, val in enumerate(expected):
assert val == actual[idx]
def test_write_entry_extra_columns(req_context):
# when we write into columns that aren't there, nothing happens
from journal import write_entry
fields = ('title', 'bob', 'text', 'hope')
expected = ('some text', 'more text', 'more', 'less')
req_context.params = dict(zip(fields, expected))
# assert that there are no entries when we start
rows = run_query(req_context.db, "SELECT * FROM entries")
assert len(rows) == 0
result = write_entry(req_context)
# manually commit so we can see the entry on query
req_context.db.commit()
rows = run_query(req_context.db, "SELECT title, text FROM entries")
assert len(rows) == 1
assert rows == [('some text', 'more')]
def create_entry(step):
with app.test_request_context('/'):
entry = ("My Title", "My Text")
write_entry(*entry)
