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