def tearDown(self):
testing.tearDown()
import transaction
from c2cgeoportal.models import FullTextSearch, User, Role
from c2cgeoportal.models import DBSession
DBSession.query(User).filter(User.username == '__test_user1').delete()
DBSession.query(User).filter(User.username == '__test_user2').delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == 'label1').delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == 'label2').delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == 'label3').delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == 'label4').delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == 'label5').delete()
DBSession.query(Role).filter(Role.name == '__test_role1').delete()
DBSession.query(Role).filter(Role.name == '__test_role2').delete()
transaction.commit()
def teardown_method(self, method):
self.session.rollback()
try:
self.patcher.stop()
except:
pass
testing.tearDown()
def tearDown(self):
# rollback - everything that happened with the
# Session above (including calls to commit())
# is rolled back.
testing.tearDown()
self.trans.rollback()
self.session.close()
def test_incomplete_config3(self):
config = testing.setUp(settings={
'google_client_id': '123',
'google_client_secret': 's3cr3t',
})
self.assertFalse(include_google(config))
testing.tearDown()
def tearDown(self):
session = temporary_session(DBSession.bind)
delete_tables = ('router', 'request')
for table in delete_tables:
session.execute('delete from {0}'.format(table))
session.commit()
testing.tearDown()
def tearDown(): # noqa
testing.tearDown()
from c2cgeoportal.models import DBSession, Shorturl
import transaction
DBSession.query(Shorturl).delete()
transaction.commit()
def tearDown(self):
from arachcurator.models.models import Claim
with transaction.manager:
cl = self.session.query(Claim).filter_by(publication_behavior='TestClaim1').first()
if cl:
self.session.delete(cl)
testing.tearDown()
def tearDown(self):
print ('TearDown')
testing.tearDown()
self.trans.rollback()
self.DBSession.rollback()
self.DBSession.close()
def tearDown(): # noqa
testing.tearDown()
import transaction
from c2cgeoportal.models import FullTextSearch, User, Role, Interface
from c2cgeoportal.models import DBSession
DBSession.query(User).filter(User.username == "__test_user1").delete()
DBSession.query(User).filter(User.username == "__test_user2").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label1").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label2").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label3").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label4").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label5").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label6").delete()
DBSession.query(Interface).filter(
Interface.name == "main").delete()
DBSession.query(Role).filter(Role.name == "__test_role1").delete()
DBSession.query(Role).filter(Role.name == "__test_role2").delete()
transaction.commit()
def tearDown(self):
if self.id == None:
res = self.testapp.delete(url='/delete/{0}'.format(self.id))
import logging
logging.debug('delete {0}'.format(self.id))
self.id = None
testing.tearDown()
def tearDown(self):
import twill
import twill.commands
twill.commands.reset_browser()
twill.remove_wsgi_intercept('localhost', 6543)
twill.set_output(None)
testing.tearDown()
def tearDown(self):
import transaction
from shootout.models import DBSession
transaction.abort()
DBSession.remove()
testing.tearDown()
def test_backup(dbsession, ini_settings):
"""Execute backup script with having our settings content."""
f = NamedTemporaryFile(delete=False)
temp_fname = f.name
f.close()
ini_settings["websauna.backup_script"] = "websauna.tests:backup_script.bash"
ini_settings["backup_test.filename"] = temp_fname
# We have some scoping issues with the dbsession here, make sure we close transaction at the end of the test
with transaction.manager:
init = get_init(dict(__file__=ini_settings["_ini_file"]), ini_settings)
init.run()
testing.setUp(registry=init.config.registry)
# Check we have faux AWS variable to export
secrets = get_secrets(get_current_registry())
assert "aws.access_key_id" in secrets
try:
# This will run the bash script above
backup_site()
# The result should be generated here
assert os.path.exists(temp_fname)
contents = io.open(temp_fname).read()
# test-secrets.ini, AWS access key
assert contents.strip() == "foo"
finally:
testing.tearDown()
def tearDown(self):
def clear_files():
for filename in glob.glob("%s/*.html" % (PHOTO_PATH, )):
os.remove(os.path.join(PHOTO_PATH, filename))
clear_files()
self.session.remove()
testing.tearDown()
def tearDown(self):
testing.tearDown()
from c2cgeoportal.models import DBSession, User, Role, Layer, \
RestrictionArea, Theme, LayerGroup
DBSession.query(User).filter(User.username == '__test_user1').delete()
DBSession.query(User).filter(User.username == '__test_user2').delete()
ra = DBSession.query(RestrictionArea).filter(
RestrictionArea.name == '__test_ra1').one()
ra.roles = []
DBSession.delete(ra)
ra = DBSession.query(RestrictionArea).filter(
RestrictionArea.name == '__test_ra2').one()
ra.roles = []
DBSession.delete(ra)
DBSession.query(Role).filter(Role.name == '__test_role1').delete()
DBSession.query(Role).filter(Role.name == '__test_role2').delete()
for t in DBSession.query(Theme).filter(Theme.name == '__test_theme').all():
DBSession.delete(t)
for layergroup in DBSession.query(LayerGroup).all():
DBSession.delete(layergroup) # pragma: nocover
for layer in DBSession.query(Layer).all():
DBSession.delete(layer) # pragma: nocover
transaction.commit()
def tearDown(self):
os.rmdir(self.test_repo.linux_path)
os.rmdir(self.test_repo.windows_path)
os.rmdir(self.test_repo.osx_path)
DBSession.remove()
testing.tearDown()
def teardown_method(self, _):
testing.tearDown()
import transaction
from c2cgeoportal_commons.models import DBSession
from c2cgeoportal_commons.models.main import FullTextSearch, Role, Interface
from c2cgeoportal_commons.models.static import User
DBSession.query(User).filter(User.username == "__test_user1").delete()
DBSession.query(User).filter(User.username == "__test_user2").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label1").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label2").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label3").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label4").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label5").delete()
DBSession.query(FullTextSearch).filter(
FullTextSearch.label == "label6").delete()
DBSession.query(Interface).filter(
Interface.name == "main").delete()
DBSession.query(Role).filter(Role.name == "__test_role1").delete()
DBSession.query(Role).filter(Role.name == "__test_role2").delete()
transaction.commit()
def tearDown(self):
"""
Tear down all test cases
"""
DBSession.close()
DBSession.remove()
testing.tearDown()
def tearDown(self): import transaction from .models.meta import DBSession transaction.abort() DBSession.remove() testing.tearDown()
def tearDown(self):
"""
Clean up database
"""
DBSession().close()
DBSession.remove()
testing.tearDown()
def test_cookie(self):
settings = {'pyramid.includes': '\n pyramid_kvs.testing',
'kvs.session': """{"kvs": "mock",
"key_name": "SessionId",
"session_type": "cookie",
"codec": "json",
"key_prefix": "cookie::",
"ttl": 20}"""}
testing.setUp(settings=settings)
factory = SessionFactory(settings)
MockCache.cached_data = {
b'cookie::chocolate': '{"anotherkey": "another val"}'
}
self.assertEqual(factory.session_class, CookieSession)
request = testing.DummyRequest(cookies={'SessionId': 'chocolate'})
session = factory(request)
client = session.client
self.assertIsInstance(client, MockCache)
self.assertEqual(client._serializer.dumps, serializer.json.dumps)
self.assertEqual(client.ttl, 20)
self.assertEqual(client.key_prefix, b'cookie::')
self.assertEqual(session['anotherkey'], 'another val')
self.assertEqual(request.response_callbacks,
deque([session.save_session]))
testing.tearDown()
def test_should_renew_session_on_invalidate(self):
settings = {'pyramid.includes': '\n pyramid_kvs.testing',
'kvs.session': """{"kvs": "mock",
"key_name": "SessionId",
"session_type": "cookie",
"codec": "json",
"key_prefix": "cookie::",
"ttl": 20}"""}
testing.setUp(settings=settings)
factory = SessionFactory(settings)
MockCache.cached_data = {
b'cookie::chocolate': '{"stuffing": "chocolate"}'
}
request = testing.DummyRequest(cookies={'SessionId': 'chocolate'})
session = factory(request)
# Ensure session is initialized
self.assertEqual(session['stuffing'], 'chocolate')
# Invalidate session
session.invalidate()
# session is invalidated
self.assertFalse('stuffing' in session)
# ensure it can be reused immediately
session['stuffing'] = 'macadamia'
self.assertEqual(session['stuffing'], 'macadamia')
testing.tearDown()
def tearDown(self):
super().tearDown()
if os.path.exists(self.__workspace):
shutil.rmtree(self.__workspace)
if os.path.exists(self.__staging):
shutil.rmtree(self.__staging)
testing.tearDown()
def tearDown(self):
self.request.userdb.users.delete_many({'username': '******'})
self.request.userdb.user_cache.delete_many({'username': '******'})
# Shutdown flush thread:
global rundb
rundb.stop()
testing.tearDown()
def tearDown(self):
self.event_results = None
testing.tearDown()
if CPDummyRequest.test_dir is not None:
CPDummyRequest.test_dir.rmtree()
CPDummyRequest.test_dir = None
CPDummyRequest._index_data = {}
def tearDown(self):
"""
clean up after a test case
"""
DBSession.close()
DBSession.remove()
testing.tearDown()
def tearDown(self):
user = User(u"test")
r = self.app.root()
r.Delete(self.context.id, user=user)
r.Delete(self.context2.id, user=user)
testing.tearDown()
pass
def tearDown(self):
"""
Close the transaction and rollback after each test case is called
"""
testing.tearDown()
self.transaction.rollback()
self.session.close()
def test_incomplete_config3(self):
config = testing.setUp(settings={
'facebook_app_id': '123',
'facebook_app_secret': 's3cr3t',
})
self.assertFalse(include_facebook(config))
testing.tearDown()
def tearDown(self):
DBSession.rollback()
testing.tearDown()
security.unauthenticated_userid = self._unauthenticated_userid
FileUpload.save_tmpfile = self._save_tmpfile
FileUpload.move = self._move
FileUpload.save_reference = self._save_reference
def tearDown(self): # noqa
self.cleanup()
DBSession.remove()
testing.tearDown()
def tearDown(self):
self.session.remove()
testing.tearDown()
def test_join_c3s(self):
# setup
self.config = testing.setUp()
self.config.include('pyramid_mailer.testing')
DBSession.close()
DBSession.remove()
my_settings = {
'sqlalchemy.url': 'sqlite:///:memory:',
'available_languages': 'da de en es fr',
'c3smembership.dashboard_number': '30'}
engine = engine_from_config(my_settings)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
# a group for accountants/staff
accountants_group = Group(name=u"staff")
DBSession.add(accountants_group)
DBSession.flush()
# staff personnel
staffer1 = C3sStaff(
login=u"rut",
password=u"berries",
email=u"*****@*****.**",
)
staffer1.groups = [accountants_group]
DBSession.add(accountants_group)
DBSession.add(staffer1)
DBSession.flush()
app = main({}, **my_settings)
self.testapp = TestApp(app)
# sucess for valid entry
res = self.testapp.get('/', status=200)
form = self._fill_form_valid_natural(res.form)
res = form.submit(u'submit', status=302)
res = res.follow()
self.assertTrue('information below to be correct' in res.body)
# success for 18th birthday
res = self.testapp.get('/', status=200)
form = self._fill_form_valid_natural(res.form)
afm.date = DummyDate(date(2018, 4, 29))
form['year'] = u'2000'
form['month'] = u'04'
form['day'] = u'29'
res = form.submit(u'submit', status=302)
res = res.follow()
self.assertTrue('information below to be correct' in res.body)
# failure on test one day before 18th birthday
res = self.testapp.get('/', status=200)
form = self._fill_form_valid_natural(res.form)
afm.date = DummyDate(date(2018, 4, 29))
form['year'] = u'2000'
form['month'] = u'04'
form['day'] = u'30'
res = form.submit(u'submit', status=200)
self.assertTrue('underaged person is currently not' in res.body)
# failure for statute not checked
res = self.testapp.get('/', status=200)
form = self._fill_form_valid_natural(res.form)
form['got_dues_regulations'].value__set(False)
res = form.submit(u'submit', status=200)
# failure for dues regulations not checked
res = self.testapp.get('/', status=200)
form = self._fill_form_valid_natural(res.form)
form['got_dues_regulations'].value__set(False)
res = form.submit(u'submit', status=200)
# teardown
DBSession.close()
DBSession.remove()
testing.tearDown()
def functional_config(request):
yield testing.setUp()
testing.tearDown()
def tearDown(self):
testing.tearDown()
transaction.abort()
def tearDown(self):
from .models.meta import Base
testing.tearDown()
transaction.abort()
Base.metadata.drop_all(self.engine)
def _callFUT(self, **kw):
from pyramid.testing import tearDown
return tearDown(**kw)
def tearDown(self):
self.__tempfolder.cleanup()
testing.tearDown()
def tearDown(self):
pyramid_testing.tearDown()
self.fixture.tearDown()
def tearDown(self):
import transaction
transaction.abort()
testing.tearDown()
def teardown():
testing.tearDown()
def tearDown(self):
super(I18nTests, self).tearDown()
testing.tearDown()
def tearDown(self):
stop_ioloop()
import shutil
testing.tearDown()
self.db.close()
shutil.rmtree(self.tmpdir)
def tearDown(self):
os.remove(self._tmp_db_file)
DBSession.remove()
testing.tearDown()
def tearDown(self): # noqa
self.clean()
testing.tearDown()
def test_it_config(self):
config = testing.setUp()
try:
config.include('pyramid_tm')
finally:
testing.tearDown()
def tearDown(self):
testing.tearDown()
from zope.deprecation import __show__
__show__.on()
def tearDown(self):
testing.tearDown()
self.root = None
self.challenge = None
def tearDown(self):
# Roll back everything and discard the threadlocal environment
testing.tearDown()
transaction.abort()
def tearDownClass(cls):
cls.clear_test_processes()
testing.tearDown()
cls.log("{}End of '{}': {}\n{}"
.format(cls.logger_separator_cases, cls.current_case_name(), now(), cls.logger_separator_cases))
def tearDown(self):
testing.tearDown()
Session.remove()
def tearDown(self):
user = User(u"test")
for r in self.root.GetObjsList(fields=["id"]):
self.root.Delete(r["id"], user)
self.app.Close()
testing.tearDown()
def tearDown(self):
tearDown()
AppTestCase.tearDown(self)
def tearDown(self):
"""Rollback and teardown transaction"""
self.testapp.get("/logout")
#self.sp.rollback()
testing.tearDown()
def tearDown(self):
tweens_handler.clear()
testing.tearDown()
def tearDown(self):
tearDown()
def tearDown(self):
DBSession.remove()
testing.tearDown()
def tearDown(self):
testing.tearDown()
for m in list(sys.modules):
if 'example' in m:
del sys.modules[m]
def tearDown(self):
testing.tearDown()
def tearDown(self):
self.rundb.userdb.users.delete_many({"username": "******"})
self.rundb.userdb.user_cache.delete_many({"username": "******"})
self.rundb.stop()
testing.tearDown()
