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