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():  # noqa
        testing.tearDown()

        from c2cgeoportal.models import DBSession, Shorturl
        import transaction
        DBSession.query(Shorturl).delete()
        transaction.commit()

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

        print ('TearDown')
        testing.tearDown()
        self.trans.rollback()
        self.DBSession.rollback()
        self.DBSession.close()

 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):
        import transaction
        from shootout.models import DBSession

        transaction.abort()
        DBSession.remove()
        testing.tearDown()

 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):
     """
     clean up after a test case
     """
     DBSession.close()
     DBSession.remove()
     testing.tearDown()

 def tearDown(self):
   self.request.userdb.users.delete_many({'username': 'JoeUser'})
   self.request.userdb.user_cache.delete_many({'username': 'JoeUser'})
   # 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):
     """
     Close the transaction and rollback after each test case is called
     """
     testing.tearDown()
     self.transaction.rollback()
     self.session.close()

 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):
        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 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_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 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):
     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 .models.meta import DBSession
		
		transaction.abort()
		DBSession.remove()
		testing.tearDown()

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