def test_create_mymodel_entry(dbtransaction, dummy_request):
"""Test creation of model."""
new_model = Entry(title="new stuff", text="stuff goes here")
assert new_model.id is None
DBSession.add(new_model)
DBSession.flush()
assert new_model.id is not None
def test_edit_route(dbtransaction, app):
"""Test if permissions block anonymous users."""
new_model = Entry(title="new stuff", text="stuff goes here")
DBSession.add(new_model)
DBSession.flush()
response = app.get('/edit/{}'.format(new_model.id), status=403)
assert response.status_code == 403
def test_edit_route(dbtransaction, app):
"""Test if permissions block anonymous users."""
new_model = Entry(title="new stuff", text="stuff goes here")
DBSession.add(new_model)
DBSession.flush()
response = app.get('/edit/{}'.format(new_model.id), status=403)
assert response.status_code == 403
def test_create_entry(dbtransaction):
"""Test for a change of state of the model."""
new_model = Entry(title='something', text='something else')
assert new_model.id is None
DBSession.add(new_model)
DBSession.flush()
assert new_model.id is not None
def test_edit_route(dbtransaction, app):
"""Test if permissions block anonymous users."""
new_model = Entry(title="scotist", text="haecceitas")
DBSession.add(new_model)
DBSession.flush()
with pytest.raises(webtestapp.AppError):
app.get('/edit/{}'.format(new_model.id))
def test_create_entry(dbtransaction):
"""Test for a change of state of the model."""
new_model = Entry(title="jill", text='jello')
assert new_model.id is None
DBSession.add(new_model)
DBSession.flush()
assert new_model.id is not None
def test_create_entry(sqlengine):
"""Assert entry was entered into database."""
new_entry = Entry(title="Entry1", text="Hey, this works. Awesome.")
assert new_entry.id is None
DBSession.add(new_entry)
DBSession.flush()
assert new_entry.id is not None
def loaded_db(dbtransaction):
"""Instantiate a temporary database. Return one entry."""
from learning_journal.models import Entry, DBSession
new_model = Entry(title="scotist", text='haecceitas')
DBSession.add(new_model)
DBSession.flush()
return new_model
def test_create_entry(dbtransaction):
"""Assert entry was entered into database."""
new_entry = Entry(title="Entry1", text="Hey, this works. Awesome.")
assert new_entry.id is None
DBSession.add(new_entry)
DBSession.flush()
assert new_entry.id is not None
def loaded_db_item(dbtransaction):
"""Instantiate a temporary database. Return one entry."""
from learning_journal.models import Entry, DBSession
new_model = Entry(title="jill", text='jello')
DBSession.add(new_model)
DBSession.flush()
return new_model
def loaded_db_item(dbtransaction):
"""Instantiate a temporary database. Return one entry."""
from learning_journal.models import Entry, DBSession
new_model = Entry(title="jill", text='jello')
DBSession.add(new_model)
DBSession.flush()
return new_model
def test_models(dbtransaction):
new_post = Post(title="\u1555( \u141b )\u1557", text='( \u0361\xb0 \u035c\u0296 \u0361\xb0)')
assert new_post.id is None
assert new_post.created is None
DBSession.add(new_post)
DBSession.flush()
assert new_post.id is not None
assert new_post.created is not None
def test_list_view(dbtransaction, dummy_request):
"""Test list view function."""
from learning_journal.views import list_view
new_model = Entry(title="scotist", text="haecceitas")
DBSession.add(new_model)
DBSession.flush()
response_dict = list_view(dummy_request)
assert response_dict['content'].one().title == new_model.title
def main():
database_url = os.environ.get("DATABASE_URL", None)
engine = create_engine(database_url)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
for post in get_posts():
populate_db(post)
def main():
database_url = os.environ.get('DATABASE_URL', None)
engine = create_engine(database_url)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
for entry in import_entries():
populate_db(entry)
def import_entries():
json_entries = json.loads(get_response())
for json_entry in json_entries:
entry = Entry()
entry.title = json_entry['title']
entry.text = json_entry['text']
entry.created = json_entry['created']
with transaction.manager:
DBSession.add(entry)
def test_delete_entry(loaded_db_item, authorized_app):
from learning_journal.models import Entry, DBSession
check_db = DBSession.query(Entry).filter(
Entry.title == 'jill').first()
assert check_db
authorized_app.get('/delete_entry/{}'.format(loaded_db_item.id))
check_db = DBSession.query(Entry).filter(
Entry.title == 'jill').first()
assert not check_db
def test_detail_view(dbtransaction, dummy_request):
"""Test detail view function."""
from learning_journal.views import detail_view
new_model = Entry(title="scotist", text="haecceitas")
DBSession.add(new_model)
DBSession.flush()
dummy_request.matchdict = {'entry_id': new_model.id}
response_dict = detail_view(dummy_request)
assert response_dict['entry'].markdown_text == '<p>haecceitas</p>'
def test_add(authenticated_app):
results = DBSession.query(Entry).filter(
Entry.title == 'title' and Entry.text == 'text')
assert results.count() == 0
entry_dict = {'title': 'title', 'text': 'text'}
authenticated_app.post('/write', params=entry_dict, status='3*')
results = DBSession.query(Entry).filter(
Entry.title == 'title' and Entry.text == 'text')
assert results.count() == 1
def test_authenticated_edit_route(app):
"""Test if permissions allow admin."""
app.post('/login', AUTH_DATA)
app.get('/create')
new_model = Entry(title="new stuff", text="stuff goes here")
DBSession.add(new_model)
DBSession.flush()
edit = app.get('/edit/1')
assert edit.status_code == 200
def test_authenticated_edit_route(app):
"""Test if permissions allow admin."""
app.post('/login', AUTH_DATA)
app.get('/create')
new_model = Entry(title="new stuff", text="stuff goes here")
DBSession.add(new_model)
DBSession.flush()
edit = app.get('/edit/1')
assert edit.status_code == 200
def test_create_mymodel_entry(dbtransaction, dummy_request):
"""Test creation of model."""
new_model = Entry(title="Norton", text="waffles")
assert new_model.id is None
DBSession.add(new_model)
DBSession.flush()
assert new_model.id is not None
assert new_model.text == 'waffles'
assert new_model.title == 'Norton'
assert new_model.created is not None
def sqlengine(request):
engine = create_engine(TEST_DATABASE_URL)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
def teardown():
Base.metadata.drop_all(engine)
request.addfinalizer(teardown)
return engine
def edit_post(request):
entry_id = request.matchdict['id']
entry = DBSession.query(Entry).get(entry_id)
form = EntryForm(request.POST, entry)
if request.method == 'POST' and form.validate():
form.populate_obj(entry)
DBSession.add(entry)
DBSession.flush()
url = request.route_url('entry', id=entry_id)
return HTTPFound(url)
return {'form': form}
def new_entry(request):
new_entry = Entry(title='something', text='whatever')
DBSession.add(new_entry)
DBSession.flush()
def teardown():
DBSession.query(Entry).filter(Entry.id == new_entry.id).delete()
DBSession.flush()
request.addfinalizer(teardown)
return new_entry
def sqlengine(request):
"""Takes care of connection to DB."""
engine = create_engine(TESTDB_URL)
Base.metadata.create_all(engine)
connection = engine.connect()
DBSession.configure(bind=connection)
def teardown():
Base.metadata.drop_all(engine)
request.addfinalizer(teardown)
return connection
def sqlengine(request):
"""Takes care of connection to DB."""
engine = create_engine(TESTDB_URL)
Base.metadata.create_all(engine)
connection = engine.connect()
DBSession.configure(bind=connection)
def teardown():
Base.metadata.drop_all(engine)
request.addfinalizer(teardown)
return connection
def new_entry(request):
"""Create a fake entry."""
add_entry = Entry(title='new stuff', text='content')
DBSession.add(add_entry)
DBSession.flush()
def teardown():
DBSession.query(Entry).filter(Entry.id == add_entry.id).delete()
DBSession.flush()
request.addfinalizer(teardown)
return add_entry
def new_entry(request):
"""Create a fake entry."""
add_entry = Entry(title='heyheyhey', text='1111')
DBSession.add(add_entry)
DBSession.flush()
def teardown():
DBSession.delete(add_entry)
DBSession.flush()
request.addfinalizer(teardown)
return add_entry
def add_post(request):
form = EntryForm(request.POST)
if request.method == 'POST' and form.validate():
entry = Entry()
entry.title = form.title.data
entry.text = form.text.data
DBSession.add(entry)
DBSession.flush()
entry_id = entry.id
url = request.route_url('entry', id=entry_id)
return HTTPFound(url)
return {'form': form}
def dbtransaction(request, sqlengine):
connection = sqlengine.connect()
transaction = connection.begin()
DBSession.configure(bind=connection, expire_on_commit=False)
def teardown():
transaction.rollback()
connection.close()
DBSession.remove()
request.addfinalizer(teardown)
return connection
def new_entry(request, auth_env):
"""Create a fake entry."""
add_entry = Entry(title='heyheyhey', text='1111')
DBSession.add(add_entry)
DBSession.flush()
def teardown():
DBSession.query(Entry).filter(Entry.id == add_entry.id).delete()
DBSession.flush()
request.addfinalizer(teardown)
return add_entry
def test_edit_entry_view_functional(loaded_db_item, authenticated_app):
"""Test if the db updates upon request."""
from learning_journal.models import Entry, DBSession
authenticated_app.post('/edit_entry/{}'.format(loaded_db_item.id),
{'title': 'new title', 'text': 'new text'})
new = DBSession.query(Entry).filter(Entry.id == loaded_db_item.id).first()
assert new.title == 'new title'
assert new.text == 'new text'
def test_add_entry_view_functional(authenticated_app):
"""Test if the db updates upon request."""
from learning_journal.models import Entry, DBSession
authenticated_app.post('/add_entry', {'title': 'fancy title', 'text': 'new text'})
new_entry = DBSession.query(Entry).filter(
Entry.title == 'fancy title').first()
assert new_entry.id
assert new_entry.title == 'fancy title'
assert new_entry.text == 'new text'
def test_edit_entry_view_functional(loaded_db_item, authenticated_app):
"""Test if the db updates upon request."""
from learning_journal.models import Entry, DBSession
authenticated_app.post('/edit_entry/{}'.format(loaded_db_item.id), {
'title': 'new title',
'text': 'new text'
})
new = DBSession.query(Entry).filter(Entry.id == loaded_db_item.id).first()
assert new.title == 'new title'
assert new.text == 'new text'
def test_add_entry_view_functional(authenticated_app):
"""Test if the db updates upon request."""
from learning_journal.models import Entry, DBSession
authenticated_app.post('/add_entry', {
'title': 'fancy title',
'text': 'new text'
})
new_entry = DBSession.query(Entry).filter(
Entry.title == 'fancy title').first()
assert new_entry.id
assert new_entry.title == 'fancy title'
assert new_entry.text == 'new text'
def test_edit(dbtransaction, app, new_entry, auth_env):
"""Test that an entry was created by a person whose logged in."""
title = new_entry.title
text = new_entry.text
entry_dict = {'title': title,
'text': text,
'username': '******',
'password': '******'
}
app.post('/{}/edit'.format(new_entry.id), params=entry_dict, status='3*')
results = DBSession.query(Entry).filter(
Entry.title == title and Entry.text == text)
assert results.count() == 1
def test_edit_my_model_entry(dbtransaction, dummy_request):
"""Test editing of model."""
new_model = Entry(title="Norton", text="waffles")
DBSession.add(new_model)
DBSession.flush()
edit = "python3 is better than python2.7"
new_model.text = edit
DBSession.flush()
assert new_model.text == edit
def test_edit_my_model_entry(dbtransaction, dummy_request):
"""Test editing of model."""
new_model = Entry(title="new stuff", text="stuff goes here")
DBSession.add(new_model)
DBSession.flush()
edit = "yet more stuff for the place where stuff goes"
new_model.text = edit
DBSession.flush()
assert new_model.text == edit
def dbtransaction(request, sqlengine):
connection = sqlengine.connect()
transaction = connection.begin()
DBSession.configure(bind=connection)
entry = Entry(title="testing 1", text="this is a test")
DBSession.add(entry)
DBSession.flush()
def teardown():
transaction.rollback()
connection.close()
DBSession.remove()
request.addfinalizer(teardown)
return connection
def teardown():
DBSession.delete(add_entry)
DBSession.flush()
def teardown():
transaction.rollback()
connection.close()
DBSession.remove()
def loaded_db(dbtransaction):
my_entry = Entry(title="thefreshloaf", text="the text about fresh loaves")
DBSession.add(my_entry)
DBSession.flush()
return DBSession
def teardown():
DBSession.query(Entry).filter(Entry.id == new_entry.id).delete()
DBSession.flush()
