How to use debtcollector - 10 common examples

self.test.engine = self.test.transaction_engine
            self.test.sessionmaker = session.get_maker(
                self.test.transaction_engine)
        else:
            self.test.engine = self.test.db.engine
            self.test.sessionmaker = session.get_maker(self.test.engine)

        self.addCleanup(setattr, self.test, 'sessionmaker', None)
        self.addCleanup(setattr, self.test, 'engine', None)

        self.test.enginefacade = enginefacade._TestTransactionFactory(
            self.test.engine, self.test.sessionmaker, apply_global=True)
        self.addCleanup(self.test.enginefacade.dispose_global)


@debtcollector.removals.removed_class(
    "DbTestCase",
    message="Please use oslo_db.sqlalchemy.test_fixtures directly")
class DbTestCase(test_base.BaseTestCase):
    """Base class for testing of DB code.

    """

    FIXTURE = DbFixture
    SCHEMA_SCOPE = None
    SKIP_ON_UNAVAILABLE_DB = True

    _db_not_available = {}
    _schema_resources = {}
    _database_resources = {}

    def _get_db_resource_not_available_reason(self):

'only on %s. Current engine is %s.')
                args = (reflection.get_callable_name(f), ', '.join(dialects),
                        self.engine.name)
                self.skipTest(msg % args)
            else:
                return f(self)
        return ins_wrap
    return wrap


@debtcollector.removals.removed_class("MySQLOpportunisticFixture")
class MySQLOpportunisticFixture(DbFixture):
    DRIVER = 'mysql'


@debtcollector.removals.removed_class("PostgreSQLOpportunisticFixture")
class PostgreSQLOpportunisticFixture(DbFixture):
    DRIVER = 'postgresql'


@debtcollector.removals.removed_class("MySQLOpportunisticTestCase")
class MySQLOpportunisticTestCase(OpportunisticTestCase):
    FIXTURE = MySQLOpportunisticFixture


@debtcollector.removals.removed_class("PostgreSQLOpportunisticTestCase")
class PostgreSQLOpportunisticTestCase(OpportunisticTestCase):
    FIXTURE = PostgreSQLOpportunisticFixture

try:
    from oslotest import base as test_base
except ImportError:
    raise NameError('Oslotest is not installed. Please add oslotest in your'
                    ' test-requirements')


from oslo_utils import reflection

from oslo_db import exception
from oslo_db.sqlalchemy import enginefacade
from oslo_db.sqlalchemy import provision
from oslo_db.sqlalchemy import session


@debtcollector.removals.removed_class(
    "DbFixture",
    message="Please use oslo_db.sqlalchemy.test_fixtures directly")
class DbFixture(fixtures.Fixture):
    """Basic database fixture.

    Allows to run tests on various db backends, such as SQLite, MySQL and
    PostgreSQL. By default use sqlite backend. To override default backend
    uri set env variable OS_TEST_DBAPI_ADMIN_CONNECTION with database admin
    credentials for specific backend.
    """

    DRIVER = "sqlite"

    # these names are deprecated, and are not used by DbFixture.
    # they are here for backwards compatibility with test suites that
    # are referring to them directly.

def main():
    utils.read_config('designate', sys.argv)
    logging.setup(CONF, 'designate')
    gmr.TextGuruMeditation.setup_autorun(version)

    # NOTE(timsim): This is to ensure people don't start the wrong
    #               services when the worker model is enabled.

    if CONF['service:worker'].enabled:
        LOG.error('You have designate-worker enabled, starting '
                  'designate-zone-manager is incompatible with '
                  'designate-worker. You need to start '
                  'designate-producer instead.')
        sys.exit(1)

    debtcollector.deprecate('designate-zone-manager Is deprecated in '
                            'favor of the designate-producer',
                            version='newton',
                            removal_version='rocky')

    LOG.warning('Starting designate-producer under the zone-manager name')

    server = producer_service.Service(
        threads=CONF['service:zone_manager'].threads)
    service.serve(server, workers=CONF['service:zone_manager'].workers)
    server.heartbeat_emitter.start()
    service.wait()

def _cls_decorator(cls):
        _check_it(cls)
        out_message = _utils.generate_message(
            "Using class '%s' (either directly or via inheritance)"
            " is deprecated" % cls_name, postfix=None, message=message,
            version=version, removal_version=removal_version)
        cls.__init__ = _wrap_it(cls.__init__, out_message)
        return cls

def _check_it(cls):
        if not inspect.isclass(cls):
            _qual, type_name = _utils.get_qualified_name(type(cls))
            raise TypeError("Unexpected class type '%s' (expected"
                            " class type only)" % type_name)

resp, body = self.get(url, headers={})
        if params and params.get('format') == 'json':
            body = json.loads(body)
        elif params and params.get('format') == 'xml':
            body = etree.fromstring(body)
        # Else the content-type is plain/text
        else:
            body = [
                obj_name for obj_name in body.decode().split('\n') if obj_name
            ]

        self.expected_success([200, 204], resp.status)
        return resp, body

    list_container_contents = debtcollector.moves.moved_function(
        list_container_objects, 'list_container_contents', __name__,
        version='Queens', removal_version='Rocky')

        @six.wraps(old_init, assigned=_utils.get_assigned(old_init))
        def new_init(self, *args, **kwargs):
            _utils.deprecation(out_message, stacklevel=stacklevel,
                               category=category)
            return old_init(self, *args, **kwargs)

    @removals.remove(version='1.7.0', removal_version='2.0.0')
    def post(self, url, **kwargs):
        """Perform an authenticate POST request.

        This calls :py:meth:`.request()` with ``method`` set to ``POST`` and an
        authentication token if one is available.

        .. warning::

            *DEPRECATED*: This function is no longer used and is deprecated as
            of the 1.7.0 release and may be removed in the 2.0.0 release. It
            was designed to be used by the managers and the managers now
            receive an adapter so this function is no longer on the standard
            request path.
        """
        return self._cs_request(url, 'POST', **kwargs)

    @removals.remove(
        message='Configuration of notifier is available through oslo.cfg',
        version='1.9.0',
        removal_version='3.0.0'
    )
    def config(self, config_dict):
        pass