python类tearDown()的实例源码

def tearDown(self):
        """clean up the test
        """
        shutil.rmtree(defaults.server_side_storage_path)

        # remove generic_temp_folder
        shutil.rmtree(self.temp_test_data_folder, ignore_errors=True)

        # remove repository
        shutil.rmtree(self.test_repo_path, ignore_errors=True)

        # clean up test database
        # from stalker.db.declarative import Base
        # Base.metadata.drop_all(db.DBSession.connection())
        # db.DBSession.commit()
        db.DBSession.remove()
        testing.tearDown()

def tearDown(self):
        """clean up the test
        """
        import datetime
        import transaction
        from stalker import defaults
        from stalker.db.session import DBSession
        from stalker.db.declarative import Base
        from pyramid import testing

        testing.tearDown()

        # clean up test database
        connection = DBSession.connection()
        engine = connection.engine
        connection.close()
        Base.metadata.drop_all(engine)
        transaction.commit()
        DBSession.remove()

        defaults.timing_resolution = datetime.timedelta(hours=1)

def tearDown(self):
        """clean up the test
        """
        import datetime
        import transaction
        from stalker import defaults
        from stalker.db.declarative import Base
        from stalker.db.session import DBSession

        from pyramid import testing
        testing.tearDown()

        # clean up test database
        connection = DBSession.connection()
        engine = connection.engine
        connection.close()
        Base.metadata.drop_all(engine)
        transaction.commit()
        DBSession.remove()

        defaults.timing_resolution = datetime.timedelta(hours=1)

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
        database.
    It also includes the models from your app's model package.
    Finally it tears everything down, including the Postgres database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    settings = {
        'sqlalchemy.url': TEST_DB}
    config = testing.setUp(settings=settings)
    config.include('pylistener.models')
    config.include('pylistener.routes')

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def __init_database(self):
        """Initialize the database models.

        Define a method called `init_db` to initialize
        any database instance. This method will automatically
        be called at `setUp`.

        Caution: If `init_db` is defined, a `clean_db` method
        should also be defined which will be called at
        `tearDown`.
        """
        meta.Base.metadata.create_all(self.engine)

        try:
            __init_db = self.__getattribute__('init_db')
            if callable(__init_db):
                with transaction.manager:
                    __init_db()
        except AttributeError:
            pass

def tearDown(self):
        """Calls `pyramid.testing.tearDown` and `transaction.abort`.

        Prior to calling these methods if any `clean_db` method is
        defined, it will be called. Do database clean ups there.
        """
        try:
            __clean_db = self.__getattribute__('clean_db')
            if callable(__clean_db):
                with transaction.manager:
                    __clean_db()
        except AttributeError:
            pass

        testing.tearDown()
        transaction.abort()

def app(request):
    """py.test fixture to set up a dummy app for Redis testing.

    :param request: pytest's FixtureRequest (internal class, cannot be hinted on a signature)
    """

    config = testing.setUp()
    config.add_route("home", "/")
    config.add_route("redis_test", "/redis_test")
    config.add_view(redis_test, route_name="redis_test")

    # same is in test.ini
    config.registry.settings["redis.sessions.url"] = "redis://localhost:6379/14"

    def teardown():
        testing.tearDown()

    config.registry.redis = create_redis(config.registry)

    app = TestApp(config.make_wsgi_app())
    return app

def makePaper(self, arxiv_id):
        from ..models import Paper
        return Paper(arxiv_id=arxiv_id)


# class ViewWikiTests(unittest.TestCase):
#     def setUp(self):
#         self.config = testing.setUp()
#         self.config.include('..routes')

#     def tearDown(self):
#         testing.tearDown()

#     def _callFUT(self, request):
#         from papersummarize.views.default import view_wiki
#         return view_wiki(request)

#     def test_it(self):
#         request = testing.DummyRequest()
#         response = self._callFUT(request)
#         self.assertEqual(response.location, 'http://example.com/FrontPage')

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
    database. It also includes the models from the octojobs model package.
    Finally it tears everything down, including the in-memory database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    settings = {
        'sqlalchemy.url': 'postgres:///test_jobs'}
    config = testing.setUp(settings=settings)
    config.include('octojobs.models')
    config.include('octojobs.routes')

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def sqlengine(request):
    """Create an engine."""
    config = testing.setUp(settings=TEST_DB_SETTINGS)
    config.include("..models")
    config.include("..routes")
    settings = config.get_settings()
    engine = get_engine(settings)
    Base.metadata.create_all(engine)

    def teardown():
        testing.tearDown()
        transaction.abort()
        Base.metadata.drop_all(engine)

    request.addfinalizer(teardown)
    return engine

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
        database.
    It also includes the models from your app's model package.
    Finally it tears everything down, including the in-memory SQLite database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    config = testing.setUp(settings={
        'sqlalchemy.url': 'postgres://localhost:5432/test_expenses'
    })
    config.include("expense_tracker.models")
    config.include("expense_tracker.routes")

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
        database.
    It also includes the models from your app's model package.
    Finally it tears everything down, including the in-memory SQLite database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    config = testing.setUp(settings={
        'sqlalchemy.url': 'postgres://localhost:5432/test_moodybot'
    })
    config.include("mood_bot.models")
    config.include("mood_bot.routes")
    config.include("mood_bot.security")

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def tearDown(self):
        DBSession.remove()
        testing.tearDown()

def tearDown(self):
        DBSession.remove()
        testing.tearDown()

def teardown_class(cls):
        testing.tearDown()

def teardown_class(cls):
        testing.tearDown()

def sms_app(request):

    config = testing.setUp()
    config.set_default_csrf_options(require_csrf=True)
    config.add_route("test-sms", "/test-sms")
    config.add_view(sms_view_test, route_name="test-sms")
    config.registry.registerAdapter(factory=DummySMSService, required=(IRequest,), provided=ISMSService)
    config.registry.settings["sms.default_sender"] = "+15551231234"
    config.registry.settings["sms.async"] = "false"

    def teardown():
        testing.tearDown()

    app = TestApp(config.make_wsgi_app())
    return app

def tearDown(self):
        DBSession.remove()
        testing.tearDown()

def tearDown(self):
        DBSession.remove()
        testing.tearDown()

def tearDown(self):
        stop_ioloop()
        import shutil
        testing.tearDown()
        self.db.close()
        shutil.rmtree(self.tmpdir)

def tearDown(self):
        super(RobotLayer, self).tearDown()
        self.server.shutdown()

def tearDown(self):
        testing.tearDown()

def configuration(request):
    """Set up a configurator instance."""
    config = testing.setUp(settings={
        'sqlalchemy.url': os.environ.get('DATABASE_URL_TESTING')
    })
    config.include("turingtweets.models")
    config.include("turingtweets.routes")

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def test_app(request):
    """Instantiate a turing tweet app for testing."""
    from webtest import TestApp
    from pyramid.config import Configurator

    def main(global_config, **settings):
        """Return a Pyramid WSGI application."""
        settings['sqlalchemy.url'] = os.environ.get('DATABASE_URL_TESTING')
        config = Configurator(settings=settings)
        config.include('pyramid_jinja2')
        config.include('.models')
        config.include('.routes')
        config.scan()
        return config.make_wsgi_app()

    app = main({})
    testapp = TestApp(app)

    session_factory = app.registry["dbsession_factory"]
    engine = session_factory().bind
    Base.metadata.create_all(bind=engine)

    def tearDown():
        Base.metadata.drop_all(bind=engine)
    request.addfinalizer(tearDown)
    return testapp

def ptesting(xmllint):
    yield testing
    testing.tearDown()

def tearDown(self):
        testing.tearDown()

def tearDown(self):
        testing.tearDown()

def tearDown(self):
        testing.tearDown()

def pyramid_request(request):

    from pyramid import testing

    testing.setUp()
    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)

    _request = testing.DummyRequest()
    return _request

def tearDown(self):
        from .models.meta import Base

        testing.tearDown()
        transaction.abort()
        Base.metadata.drop_all(self.engine)