submitted bug fix does have a unit test, be sure to add a new one that fails
without the patch and passes with the patch.
-All unittest classes must ultimately inherit from testtools.TestCase.
+All unittest classes must ultimately inherit from testtools.TestCase. In the
+Quantum test suite, this should be done by inheriting from
+quantum.tests.base.BaseTestCase.
+
All setUp and tearDown methods must upcall using the super() method.
tearDown methods should be avoided and addCleanup calls should be preferred.
Never manually create tempfiles. Always use the tempfile fixtures from
import os.path
import routes
-import testtools
import webob
from webtest import TestApp
from quantum.plugins.cisco.db import api as db
from quantum.plugins.cisco import l2network_plugin
from quantum.plugins.cisco.l2network_plugin import L2Network
+from quantum.tests import base
from quantum.tests.unit.extension_stubs import StubBaseAppController
from quantum import wsgi
self._delete_network(net_id)
-class QosExtensionTest(testtools.TestCase):
+class QosExtensionTest(base.BaseTestCase):
def setUp(self):
db.clear_db()
-class CredentialExtensionTest(testtools.TestCase):
+class CredentialExtensionTest(base.BaseTestCase):
def setUp(self):
import logging as LOG
-import testtools
-
from quantum.openstack.common import log as logging
from quantum.plugins.cisco.common import cisco_constants as const
import quantum.plugins.cisco.db.api as db
import quantum.plugins.cisco.db.l2network_db as l2network_db
import quantum.plugins.cisco.db.nexus_db_v2 as nexus_db
+from quantum.tests import base
LOG = logging.getLogger(__name__)
raise Exception("Failed to unplug interface: %s" % str(exc))
-class NexusDBTest(testtools.TestCase):
+class NexusDBTest(base.BaseTestCase):
"""Class conisting of nexus DB unit tests"""
def setUp(self):
super(NexusDBTest, self).setUp()
self.dbtest.delete_nexusportbinding(vlan_id)
-class L2networkDBTest(testtools.TestCase):
+class L2networkDBTest(base.BaseTestCase):
"""Class conisting of L2network DB unit tests"""
def setUp(self):
"""Setup for tests"""
self.dbtest.delete_vlan_binding(netid)
-class QuantumDBTest(testtools.TestCase):
+class QuantumDBTest(base.BaseTestCase):
"""Class conisting of Quantum DB unit tests"""
def setUp(self):
"""Setup for tests"""
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack, LLC
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""Base Test Case for all Unit Tests"""
+
+import os
+
+import fixtures
+from oslo.config import cfg
+import testtools
+
+CONF = cfg.CONF
+TRUE_STRING = ['True', '1']
+
+
+class BaseTestCase(testtools.TestCase):
+
+ def setUp(self):
+ super(BaseTestCase, self).setUp()
+
+ self.useFixture(fixtures.FakeLogger(
+ format="%(asctime)s %(levelname)8s [%(name)s] %(message)s"))
+
+ test_timeout = int(os.environ.get('OS_TEST_TIMEOUT', 0))
+ if test_timeout == -1:
+ test_timeout = 0
+ if test_timeout > 0:
+ self.useFixture(fixtures.Timeout(test_timeout, gentle=True))
+
+ # If someone does use tempfile directly, ensure that it's cleaned up
+ self.useFixture(fixtures.NestedTempfile())
+ self.useFixture(fixtures.TempHomeDir())
+
+ self.addCleanup(CONF.reset)
+
+ if os.environ.get('OS_STDOUT_NOCAPTURE') not in TRUE_STRING:
+ stdout = self.useFixture(fixtures.StringStream('stdout')).stream
+ self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout))
+ if os.environ.get('OS_STDERR_NOCAPTURE') not in TRUE_STRING:
+ stderr = self.useFixture(fixtures.StringStream('stderr')).stream
+ self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr))
+
+ def config(self, **kw):
+ """
+ Override some configuration values.
+
+ The keyword arguments are the names of configuration options to
+ override and their values.
+
+ If a group argument is supplied, the overrides are applied to
+ the specified configuration option group.
+
+ All overrides are automatically cleared at the end of the current
+ test by the fixtures cleanup process.
+ """
+ group = kw.pop('group', None)
+ for k, v in kw.iteritems():
+ CONF.set_override(k, v, group)
import __builtin__
import os
-import testtools
-
setattr(__builtin__, '_', lambda x: x)
from oslo.config import cfg
# An empty lock path forces lockutils.synchronized to use a temporary
# location for lock files that will be cleaned up automatically.
cfg.CONF.lock_path = ''
+cfg.CONF.use_stderr = False
import os
import fixtures
-import testtools
from quantum.agent.linux import utils
from quantum.openstack.common import log as logging
+from quantum.tests import base
LOG = logging.getLogger(__name__)
-class RootwrapTestExec(testtools.TestCase):
+class RootwrapTestExec(base.BaseTestCase):
"""Simple unit test to test the basic rootwrap mechanism
Essentially hello-world. Just run a command as root and check that
"""
Test vlans alloc/dealloc.
"""
-import testtools
from quantum.db import api as db
from quantum.openstack.common import context
from quantum.plugins.brocade import vlanbm as vlan_bitmap
+from quantum.tests import base
-class TestVlanBitmap(testtools.TestCase):
+class TestVlanBitmap(base.BaseTestCase):
"""exercise Vlan bitmap ."""
def setUp(self):
# limitations under the License.
import mock
-import testtools
from quantum.db import api as db
from quantum.openstack.common import importutils
from quantum.plugins.cisco.common import cisco_constants as const
from quantum.plugins.cisco.db import network_models_v2
from quantum.plugins.cisco.nexus import cisco_nexus_plugin_v2
+from quantum.tests import base
NEXUS_IP_ADDRESS = '1.1.1.1'
'fake_nexus_driver.CiscoNEXUSFakeDriver')
-class TestCiscoNexusPlugin(testtools.TestCase):
+class TestCiscoNexusPlugin(base.BaseTestCase):
def setUp(self):
"""
import mock
from oslo.config import cfg
-import testtools
from quantum.plugins.hyperv.agent import hyperv_quantum_agent
+from quantum.tests import base
-class TestHyperVQuantumAgent(testtools.TestCase):
+class TestHyperVQuantumAgent(base.BaseTestCase):
def setUp(self):
super(TestHyperVQuantumAgent, self).setUp()
"""
import mock
-import testtools
from quantum.agent import rpc as agent_rpc
from quantum.common import topics
from quantum.openstack.common import rpc
from quantum.plugins.hyperv import agent_notifier_api as ana
from quantum.plugins.hyperv.common import constants
+from quantum.tests import base
-class rpcHyperVApiTestCase(testtools.TestCase):
+class rpcHyperVApiTestCase(base.BaseTestCase):
def _test_hyperv_quantum_api(
self, rpcapi, topic, method, rpc_method, **kwargs):
# limitations under the License.
from oslo.config import cfg
-import testtools
#NOTE this import loads tests required options
from quantum.plugins.linuxbridge.common import config
+from quantum.tests import base
-class ConfigurationTest(testtools.TestCase):
+class ConfigurationTest(base.BaseTestCase):
def test_defaults(self):
self.assertEqual(-1,
from quantum.common import exceptions as q_exc
from quantum.db import api as db
from quantum.plugins.linuxbridge.db import l2network_db_v2 as lb_db
+from quantum.tests import base
from quantum.tests.unit import test_db_plugin as test_plugin
PHYS_NET = 'physnet1'
PHYS_NET_2: [(VLAN_MIN + 20, VLAN_MAX + 20)]}
-class NetworkStatesTest(testtools.TestCase):
+class NetworkStatesTest(base.BaseTestCase):
def setUp(self):
super(NetworkStatesTest, self).setUp()
lb_db.initialize()
from quantum.plugins.linuxbridge.agent import linuxbridge_quantum_agent
from quantum.plugins.linuxbridge.common import constants as lconst
+from quantum.tests import base
-class TestLinuxBridge(testtools.TestCase):
+class TestLinuxBridge(base.BaseTestCase):
def setUp(self):
super(TestLinuxBridge, self).setUp()
self.assertTrue(vlan_bridge_func.called)
-class TestLinuxBridgeAgent(testtools.TestCase):
+class TestLinuxBridgeAgent(base.BaseTestCase):
def setUp(self):
super(TestLinuxBridgeAgent, self).setUp()
"""
import stubout
-import testtools
from quantum.agent import rpc as agent_rpc
from quantum.common import topics
from quantum.openstack.common import context
from quantum.openstack.common import rpc
from quantum.plugins.linuxbridge import lb_quantum_plugin as plb
+from quantum.tests import base
-class rpcApiTestCase(testtools.TestCase):
+class rpcApiTestCase(base.BaseTestCase):
def _test_lb_api(self, rpcapi, topic, method, rpc_method, **kwargs):
ctxt = context.RequestContext('fake_user', 'fake_project')
from quantum.openstack.common import uuidutils
from quantum.plugins.metaplugin.meta_quantum_plugin import FlavorNotFound
from quantum.plugins.metaplugin.meta_quantum_plugin import MetaPluginV2
+from quantum.tests import base
CONF_FILE = ""
ROOTDIR = os.path.dirname(os.path.dirname(__file__))
'quantum.openstack.common.rpc.impl_fake')
-class MetaQuantumPluginV2Test(testtools.TestCase):
+class MetaQuantumPluginV2Test(base.BaseTestCase):
"""Class conisting of MetaQuantumPluginV2 unit tests"""
def setUp(self):
# @author: Ryu Ishimoto, Midokura Japan KK
# @author: Tomoe Sugihara, Midokura Japan KK
-import testtools
import uuid
import mock
from quantum.plugins.midonet import midonet_lib
+from quantum.tests import base
-class MidonetLibTestCase(testtools.TestCase):
+class MidonetLibTestCase(base.BaseTestCase):
def setUp(self):
super(MidonetLibTestCase, self).setUp()
# under the License.
# @author: Ryota MIBU
-import testtools
-
from quantum.plugins.nec.common import config
+from quantum.tests import base
-class ConfigurationTest(testtools.TestCase):
+class ConfigurationTest(base.BaseTestCase):
def test_defaults(self):
self.assertEqual(-1, config.CONF.DATABASE.sql_max_retries)
# @author: Ryota MIBU
import random
-import testtools
from quantum.db import api as db_api
from quantum.openstack.common import uuidutils
from quantum.plugins.nec.common import exceptions as nexc
from quantum.plugins.nec.db import api as ndb
from quantum.plugins.nec.db import models as nmodels
+from quantum.tests import base
-class NECPluginV2DBTestBase(testtools.TestCase):
+class NECPluginV2DBTestBase(base.BaseTestCase):
"""Class conisting of NECPluginV2 DB unit tests"""
def setUp(self):
# under the License.
# @author: Ryota MIBU
-import testtools
-
from quantum import context
from quantum.openstack.common import uuidutils
from quantum.plugins.nec.common import config
from quantum.plugins.nec.db import api as ndb
from quantum.plugins.nec.db import models as nmodels
from quantum.plugins.nec import ofc_manager
+from quantum.tests import base
-class OFCManagerTestBase(testtools.TestCase):
+class OFCManagerTestBase(base.BaseTestCase):
"""Class conisting of OFCManager unit tests"""
def setUp(self):
import string
import mox
-import testtools
from quantum import context
from quantum.openstack.common import uuidutils
from quantum.plugins.nec.db import api as ndb
from quantum.plugins.nec.db import models as nmodels
from quantum.plugins.nec import drivers
+from quantum.tests import base
class TestConfig(object):
return "ofc-%s" % id
-class PFCDriverTestBase(testtools.TestCase):
+class PFCDriverTestBase(base.BaseTestCase):
driver = 'quantum.plugins.nec.drivers.pfc.PFCDriverBase'
driver = 'pfc_v4'
-class PFCDriverStringTest(testtools.TestCase):
+class PFCDriverStringTest(base.BaseTestCase):
driver = 'quantum.plugins.nec.drivers.pfc.PFCDriverBase'
self.assertEqual(exp_str, ret_str)
-class PFCIdConvertTest(testtools.TestCase):
+class PFCIdConvertTest(base.BaseTestCase):
driver = 'quantum.plugins.nec.drivers.pfc.PFCDriverBase'
def setUp(self):
# @author: Ryota MIBU
import mox
-import testtools
from quantum import context
from quantum.openstack.common import uuidutils
from quantum.plugins.nec.db import api as ndb
from quantum.plugins.nec.db import models as nmodels
from quantum.plugins.nec import drivers
+from quantum.tests import base
class TestConfig(object):
port = 8888
-class TremaDriverTestBase(testtools.TestCase):
+class TremaDriverTestBase(base.BaseTestCase):
driver_name = "trema"
return [uuidutils.generate_uuid() for i in xrange(count)]
-class TremaIdConvertTest(testtools.TestCase):
+class TremaIdConvertTest(base.BaseTestCase):
driver_name = 'trema'
def setUp(self):
self.assertEqual(ret, ofc_f_id)
-class TremaIdConvertTestBase(testtools.TestCase):
+class TremaIdConvertTestBase(base.BaseTestCase):
def setUp(self):
super(TremaIdConvertTestBase, self).setUp()
self.mox = mox.Mox()
# under the License.
#
-import testtools
-
from oslo.config import cfg
from quantum.plugins.nicira.nicira_nvp_plugin.common import config
+from quantum.tests import base
-class ConfigurationTest(testtools.TestCase):
+class ConfigurationTest(base.BaseTestCase):
def test_defaults(self):
self.assertEqual(-1, cfg.CONF.DATABASE.sql_max_retries)
from quantum.plugins.nicira.nicira_nvp_plugin.extensions import (nvp_networkgw
as networkgw)
from quantum.plugins.nicira.nicira_nvp_plugin import nicira_networkgw_db
+from quantum.tests import base
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import test_db_plugin
from quantum.tests.unit import test_extensions
return []
-class NetworkGatewayExtensionTestCase(testtools.TestCase):
+class NetworkGatewayExtensionTestCase(base.BaseTestCase):
def setUp(self):
super(NetworkGatewayExtensionTestCase, self).setUp()
# System
import httplib
-# Third party
-import testtools
-
# Local
import quantum.plugins.nicira.nicira_nvp_plugin.api_client.common as naco
+from quantum.tests import base
-class NvpApiCommonTest(testtools.TestCase):
+class NvpApiCommonTest(base.BaseTestCase):
def test_conn_str(self):
conn = httplib.HTTPSConnection('localhost', 4242, timeout=0)
import logging
import urllib2
-import testtools
+from quantum.tests import base
logging.basicConfig(level=logging.DEBUG)
lg = logging.getLogger("test_nvp_api_request")
return urllib2.urlopen(url).read()
-class NvpApiRequestTest(testtools.TestCase):
+class NvpApiRequestTest(base.BaseTestCase):
pass
from eventlet.green import urllib2
from mock import Mock
from mock import patch
-import testtools
from quantum.plugins.nicira.nicira_nvp_plugin.api_client import (
client_eventlet as nace,
request_eventlet as nare,
)
+from quantum.tests import base
logging.basicConfig(level=logging.DEBUG)
return urllib2.urlopen(url).read()
-class NvpApiRequestEventletTest(testtools.TestCase):
+class NvpApiRequestEventletTest(base.BaseTestCase):
def setUp(self):
import mock
import os
-import testtools
-
from quantum.openstack.common import jsonutils as json
import quantum.plugins.nicira.nicira_nvp_plugin as nvp_plugin
from quantum.plugins.nicira.nicira_nvp_plugin import nvp_cluster
from quantum.plugins.nicira.nicira_nvp_plugin import NvpApiClient
from quantum.plugins.nicira.nicira_nvp_plugin import nvplib
+from quantum.tests import base
from quantum.tests.unit.nicira import fake_nvpapiclient
from quantum.tests.unit import test_api_v2
_uuid = test_api_v2._uuid
-class NvplibTestCase(testtools.TestCase):
+class NvplibTestCase(base.BaseTestCase):
def setUp(self):
# mock nvp api client
from quantum.common import exceptions as q_exc
from quantum.db import api as db
from quantum.plugins.openvswitch import ovs_db_v2
+from quantum.tests import base
from quantum.tests.unit import test_db_plugin as test_plugin
PHYS_NET = 'physnet1'
UPDATED_TUNNEL_RANGES = [(TUN_MIN + 5, TUN_MAX + 5)]
-class VlanAllocationsTest(testtools.TestCase):
+class VlanAllocationsTest(base.BaseTestCase):
def setUp(self):
super(VlanAllocationsTest, self).setUp()
ovs_db_v2.initialize()
ovs_db_v2.sync_vlan_allocations({})
-class TunnelAllocationsTest(testtools.TestCase):
+class TunnelAllocationsTest(base.BaseTestCase):
def setUp(self):
super(TunnelAllocationsTest, self).setUp()
ovs_db_v2.initialize()
# See the License for the specific language governing permissions and
# limitations under the License.
-import testtools
-
from oslo.config import cfg
#NOTE this import loads tests required options
from quantum.plugins.openvswitch.common import config
+from quantum.tests import base
-class ConfigurationTest(testtools.TestCase):
+class ConfigurationTest(base.BaseTestCase):
def test_defaults(self):
self.assertEqual('br-int', cfg.CONF.OVS.integration_bridge)
# @author: Dan Wendlandt, Nicira, Inc.
import mox
-import testtools
from quantum.agent.linux import ovs_lib, utils
from quantum.openstack.common import uuidutils
+from quantum.tests import base
-class OVS_Lib_Test(testtools.TestCase):
+class OVS_Lib_Test(base.BaseTestCase):
"""
A test suite to excercise the OVS libraries shared by Quantum agents.
Note: these tests do not actually execute ovs-* utilities, and thus
import testtools
from quantum.plugins.openvswitch.agent import ovs_quantum_agent
+from quantum.tests import base
NOTIFIER = ('quantum.plugins.openvswitch.'
'ovs_quantum_plugin.AgentNotifierApi')
-class CreateAgentConfigMap(testtools.TestCase):
+class CreateAgentConfigMap(base.BaseTestCase):
def test_create_agent_config_map_succeeds(self):
self.assertTrue(ovs_quantum_agent.create_agent_config_map(cfg.CONF))
ovs_quantum_agent.create_agent_config_map(cfg.CONF)
-class TestOvsQuantumAgent(testtools.TestCase):
+class TestOvsQuantumAgent(base.BaseTestCase):
def setUp(self):
super(TestOvsQuantumAgent, self).setUp()
"""
import stubout
-import testtools
from quantum.agent import rpc as agent_rpc
from quantum.common import topics
from quantum.openstack.common import rpc
from quantum.plugins.openvswitch.common import constants
from quantum.plugins.openvswitch import ovs_quantum_plugin as povs
+from quantum.tests import base
-class rpcApiTestCase(testtools.TestCase):
+class rpcApiTestCase(base.BaseTestCase):
def _test_ovs_api(self, rpcapi, topic, method, rpc_method, **kwargs):
ctxt = context.RequestContext('fake_user', 'fake_project')
import mox
from oslo.config import cfg
-import testtools
from quantum.agent.linux import ip_lib
from quantum.agent.linux import ovs_lib
from quantum.openstack.common import log
from quantum.plugins.openvswitch.agent import ovs_quantum_agent
from quantum.plugins.openvswitch.common import constants
+from quantum.tests import base
# Useful global dummy variables.
self.vlan_id = vlan_id
-class TunnelTest(testtools.TestCase):
+class TunnelTest(base.BaseTestCase):
def setUp(self):
super(TunnelTest, self).setUp()
# under the License.
from oslo.config import cfg
-import testtools
#NOTE this import loads tests required options
from quantum.plugins.ryu.common import config
+from quantum.tests import base
-class ConfigurationTest(testtools.TestCase):
+class ConfigurationTest(base.BaseTestCase):
"""Configuration file Tests"""
def test_defaults(self):
self.assertEqual('br-int', cfg.CONF.OVS.integration_bridge)
import httplib
import mock
-from oslo.config import cfg
-import testtools
from quantum.openstack.common import importutils
+from quantum.tests import base
from quantum.tests.unit.ryu import fake_ryu
-class RyuAgentTestCase(testtools.TestCase):
+class RyuAgentTestCase(base.BaseTestCase):
_AGENT_NAME = 'quantum.plugins.ryu.agent.ryu_quantum_agent'
# @author: Mark McClain, DreamHost
import mock
-import testtools
from quantum.plugins.services.agent_loadbalancer.agent import api
+from quantum.tests import base
-class TestApiCache(testtools.TestCase):
+class TestApiCache(base.BaseTestCase):
def setUp(self):
super(TestApiCache, self).setUp()
self.addCleanup(mock.patch.stopall)
import testtools
from quantum.plugins.services.agent_loadbalancer import agent
+from quantum.tests import base
-class TestLbaasService(testtools.TestCase):
+class TestLbaasService(base.BaseTestCase):
def setUp(self):
super(TestLbaasService, self).setUp()
self.addCleanup(cfg.CONF.reset)
import contextlib
import mock
-import testtools
from quantum.plugins.services.agent_loadbalancer.agent import manager
+from quantum.tests import base
-class TestLogicalDeviceCache(testtools.TestCase):
+class TestLogicalDeviceCache(base.BaseTestCase):
def setUp(self):
super(TestLogicalDeviceCache, self).setUp()
self.cache = manager.LogicalDeviceCache()
self.assertEqual(self.cache.get_pool_ids(), ['pool_id'])
-class TestManager(testtools.TestCase):
+class TestManager(base.BaseTestCase):
def setUp(self):
super(TestManager, self).setUp()
self.addCleanup(mock.patch.stopall)
import contextlib
import mock
-import testtools
from oslo.config import cfg as config
from quantum.plugins.services.agent_loadbalancer.drivers.haproxy import cfg
+from quantum.tests import base
-class TestHaproxyCfg(testtools.TestCase):
+class TestHaproxyCfg(base.BaseTestCase):
def test_save_config(self):
with contextlib.nested(
mock.patch('quantum.plugins.services.agent_loadbalancer.'
import contextlib
import mock
-import testtools
from quantum.common import exceptions
from quantum.plugins.services.agent_loadbalancer.drivers.haproxy import (
namespace_driver
)
+from quantum.tests import base
-class TestHaproxyNSDriver(testtools.TestCase):
+class TestHaproxyNSDriver(base.BaseTestCase):
def setUp(self):
super(TestHaproxyNSDriver, self).setUp()
# @author: Mark McClain, DreamHost
import mock
-import testtools
from quantum import context
from quantum import manager
from quantum.plugins.common import constants
from quantum.plugins.services.agent_loadbalancer import plugin
+from quantum.tests import base
from quantum.tests.unit.db.loadbalancer import test_db_loadbalancer
)
-class TestLoadBalancerAgentApi(testtools.TestCase):
+class TestLoadBalancerAgentApi(base.BaseTestCase):
def setUp(self):
super(TestLoadBalancerAgentApi, self).setUp()
self.addCleanup(mock.patch.stopall)
# License for the specific language governing permissions and limitations
# under the License.
-import testtools
-
from quantum.agent.common import config
+from quantum.tests import base
def test_setup_conf():
assert conf.state_path.endswith('/var/lib/quantum')
-class TestRootHelper(testtools.TestCase):
+class TestRootHelper(base.BaseTestCase):
def test_agent_root_helper(self):
conf = config.setup_conf()
import fixtures
import mock
-import testtools
from quantum.agent.linux import utils
+from quantum.tests import base
-class AgentUtilsExecuteTest(testtools.TestCase):
+class AgentUtilsExecuteTest(base.BaseTestCase):
def setUp(self):
super(AgentUtilsExecuteTest, self).setUp()
self.root_helper = "echo"
self.assertEqual(result, "%s\n" % self.test_file)
-class AgentUtilsGetInterfaceMAC(testtools.TestCase):
+class AgentUtilsGetInterfaceMAC(base.BaseTestCase):
def test_get_interface_mac(self):
expect_val = '01:02:03:04:05:06'
with mock.patch('fcntl.ioctl') as ioctl:
self.assertEqual(actual_val, expect_val)
-class AgentUtilsReplaceFile(testtools.TestCase):
+class AgentUtilsReplaceFile(base.BaseTestCase):
def test_replace_file(self):
# make file to replace
with mock.patch('tempfile.NamedTemporaryFile') as ntf:
import mock
from oslo.config import cfg
-import testtools
from quantum.agent import netns_cleanup_util as util
+from quantum.tests import base
-class TestNullDelegate(testtools.TestCase):
+class TestNullDelegate(base.BaseTestCase):
def test_getattribute(self):
null_delegate = util.NullDelegate()
self.assertIsNone(null_delegate.test())
-class TestNetnsCleanup(testtools.TestCase):
+class TestNetnsCleanup(base.BaseTestCase):
def setUp(self):
super(TestNetnsCleanup, self).setUp()
self.addCleanup(cfg.CONF.reset)
import itertools
import mock
from oslo.config import cfg
-import testtools
from quantum.agent.linux import ip_lib
from quantum.agent.linux import ovs_lib
from quantum.agent import ovs_cleanup_util as util
from quantum.openstack.common import uuidutils
+from quantum.tests import base
-class TestOVSCleanup(testtools.TestCase):
+class TestOVSCleanup(base.BaseTestCase):
def setUp(self):
super(TestOVSCleanup, self).setUp()
self.addCleanup(cfg.CONF.reset)
import mock
from oslo.config import cfg
-import testtools
from quantum.agent import rpc
from quantum.openstack.common import context
+from quantum.tests import base
-class AgentRPCPluginApi(testtools.TestCase):
+class AgentRPCPluginApi(base.BaseTestCase):
def _test_rpc_call(self, method):
agent = rpc.PluginApi('fake_topic')
ctxt = context.RequestContext('fake_user', 'fake_project')
self._test_rpc_call('tunnel_sync')
-class AgentRPCMethods(testtools.TestCase):
+class AgentRPCMethods(base.BaseTestCase):
def test_create_consumers(self):
dispatcher = mock.Mock()
expected = [
# @author: Zhongyue Luo, Intel Corporation.
#
-import testtools
from testtools import matchers
from webob import exc
from quantum.api import api_common as common
+from quantum.tests import base
class FakeController(common.QuantumController):
_resource_name = 'fake'
-class APICommonTestCase(testtools.TestCase):
+class APICommonTestCase(base.BaseTestCase):
def setUp(self):
super(APICommonTestCase, self).setUp()
self.controller = FakeController(None)
import mock
from oslo.config import cfg
-import testtools
from testtools import matchers
import webob
from webob import exc
from quantum.api import api_common
from quantum.api.extensions import PluginAwareExtensionManager
from quantum.api.v2 import attributes
-from quantum.api.v2 import base
+from quantum.api.v2 import base as v2_base
from quantum.api.v2 import router
from quantum.common import config
from quantum.common import constants
from quantum.manager import QuantumManager
from quantum.openstack.common.notifier import api as notifer_api
from quantum.openstack.common import uuidutils
+from quantum.tests import base
from quantum.tests.unit import testlib_api
from quantum import wsgi
return path
-class ResourceIndexTestCase(testtools.TestCase):
+class ResourceIndexTestCase(base.BaseTestCase):
def test_index_json(self):
index = webtest.TestApp(router.Index({'foo': 'bar'}))
res = index.get('')
self.assertTrue(link['rel'] == 'self')
-class APIv2TestBase(testtools.TestCase):
+class APIv2TestBase(base.BaseTestCase):
def setUp(self):
super(APIv2TestBase, self).setUp()
self.assertEqual(res.status_int, 400)
-class SubresourceTest(testtools.TestCase):
+class SubresourceTest(base.BaseTestCase):
def setUp(self):
super(SubresourceTest, self).setUp()
fmt = 'xml'
-class V2Views(testtools.TestCase):
+class V2Views(base.BaseTestCase):
def _view(self, keys, collection, resource):
data = dict((key, 'value') for key in keys)
data['fake'] = 'value'
attr_info = attributes.RESOURCE_ATTRIBUTE_MAP[collection]
- controller = base.Controller(None, collection, resource, attr_info)
+ controller = v2_base.Controller(None, collection, resource, attr_info)
res = controller._view(data)
self.assertTrue('fake' not in res)
for key in keys:
self.assertEqual(res.status_int, exc.HTTPCreated.code)
-class ExtensionTestCase(testtools.TestCase):
+class ExtensionTestCase(base.BaseTestCase):
def setUp(self):
super(ExtensionTestCase, self).setUp()
plugin = 'quantum.quantum_plugin_base_v2.QuantumPluginBaseV2'
return
-class ListArgsTestCase(testtools.TestCase):
+class ListArgsTestCase(base.BaseTestCase):
def test_list_args(self):
path = '/?fields=4&foo=3&fields=2&bar=1'
request = webob.Request.blank(path)
self.assertEqual([], api_common.list_args(request, 'fields'))
-class FiltersTestCase(testtools.TestCase):
+class FiltersTestCase(base.BaseTestCase):
def test_all_skip_args(self):
path = '/?fields=4&fields=3&fields=2&fields=1'
request = webob.Request.blank(path)
self.assertEqual(actual_val, expect_val)
-class CreateResourceTestCase(testtools.TestCase):
+class CreateResourceTestCase(base.BaseTestCase):
def test_resource_creation(self):
- resource = base.create_resource('fakes', 'fake', None, {})
+ resource = v2_base.create_resource('fakes', 'fake', None, {})
self.assertIsInstance(resource, webob.dec.wsgify)
#
import mock
-import testtools
from webob import exc
import webtest
from quantum.api.v2 import resource as wsgi_resource
from quantum.common import exceptions as q_exc
from quantum import context
+from quantum.tests import base
from quantum import wsgi
-class RequestTestCase(testtools.TestCase):
+class RequestTestCase(base.BaseTestCase):
def setUp(self):
super(RequestTestCase, self).setUp()
self.req = wsgi_resource.Request({'foo': 'bar'})
self.assertTrue(self.req.context.is_admin)
-class ResourceTestCase(testtools.TestCase):
+class ResourceTestCase(base.BaseTestCase):
def test_unmapped_quantum_error(self):
controller = mock.MagicMock()
controller.test.side_effect = q_exc.QuantumException()
from quantum.api.v2 import attributes
from quantum.common import exceptions as q_exc
+from quantum.tests import base
-class TestAttributes(testtools.TestCase):
+class TestAttributes(base.BaseTestCase):
def _construct_dict_and_constraints(self):
""" Constructs a test dictionary and a definition of constraints.
self.assertIsNone(msg)
-class TestConvertToBoolean(testtools.TestCase):
+class TestConvertToBoolean(base.BaseTestCase):
def test_convert_to_boolean_bool(self):
self.assertIs(attributes.convert_to_boolean(True), True)
'7')
-class TestConvertToInt(testtools.TestCase):
+class TestConvertToInt(base.BaseTestCase):
def test_convert_to_int_int(self):
self.assertEqual(attributes.convert_to_int(-1), -1)
value, attributes.convert_none_to_empty_list(value))
-class TestConvertKvp(testtools.TestCase):
+class TestConvertKvp(base.BaseTestCase):
def test_convert_kvp_list_to_dict_succeeds_for_missing_values(self):
result = attributes.convert_kvp_list_to_dict(['True'])
self.assertEqual(['a', 'a=a'], result)
-class TestConvertToList(testtools.TestCase):
+class TestConvertToList(base.BaseTestCase):
def test_convert_to_empty_list(self):
for item in (None, [], (), {}):
-import testtools
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2012 OpenStack LLC
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
import webob
from quantum import auth
+from quantum.tests import base
-class QuantumKeystoneContextTestCase(testtools.TestCase):
+class QuantumKeystoneContextTestCase(base.BaseTestCase):
def setUp(self):
super(QuantumKeystoneContextTestCase, self).setUp()
import testtools
from quantum.common import utils
+from quantum.tests import base
-class TestParseMappings(testtools.TestCase):
+class TestParseMappings(base.BaseTestCase):
def parse(self, mapping_list, unique_values=True):
return utils.parse_mappings(mapping_list, unique_values)
# limitations under the License.
import os
-import testtools
from oslo.config import cfg
from quantum.common import config
+from quantum.tests import base
-class ConfigurationTest(testtools.TestCase):
+class ConfigurationTest(base.BaseTestCase):
def test_defaults(self):
self.assertEqual('0.0.0.0', cfg.CONF.bind_host)
import fixtures
import mock
from oslo.config import cfg
-import testtools
import quantum.db.api as db
+from quantum.tests import base
-class DBTestCase(testtools.TestCase):
+class DBTestCase(base.BaseTestCase):
def setUp(self):
super(DBTestCase, self).setUp()
cfg.CONF.set_override('sql_max_retries', 1, 'DATABASE')
import sys
import mock
-import testtools
from quantum.db import migration
from quantum.db.migration import cli
+from quantum.tests import base
-class TestDbMigration(testtools.TestCase):
+class TestDbMigration(base.BaseTestCase):
def test_should_run_plugin_in_list(self):
self.assertTrue(migration.should_run('foo', ['foo', 'bar']))
self.assertFalse(migration.should_run('foo', ['bar']))
self.assertTrue(migration.should_run('foo', ['*']))
-class TestCli(testtools.TestCase):
+class TestCli(base.BaseTestCase):
def setUp(self):
super(TestCli, self).setUp()
self.do_alembic_cmd_p = mock.patch.object(cli, 'do_alembic_command')
from quantum.db import models_v2
from quantum.manager import QuantumManager
from quantum.openstack.common import timeutils
+from quantum.tests import base
from quantum.tests.unit import test_extensions
from quantum.tests.unit import testlib_api
def setUp(self, plugin=None, service_plugins=None):
super(QuantumDbPluginV2TestCase, self).setUp()
+
# NOTE(jkoelker) for a 'pluggable' framework, Quantum sure
# doesn't like when the plugin changes ;)
db._ENGINE = None
self.assertEqual(res.status_int, 204)
-class DbModelTestCase(testtools.TestCase):
+class DbModelTestCase(base.BaseTestCase):
""" DB model tests """
def test_repr(self):
""" testing the string representation of 'model' classes """
# limitations under the License.
import mock
-import testtools
from quantum.db import dhcp_rpc_base
+from quantum.tests import base
-class TestDhcpRpcCallackMixin(testtools.TestCase):
+class TestDhcpRpcCallackMixin(base.BaseTestCase):
def setUp(self):
super(TestDhcpRpcCallackMixin, self).setUp()
import mock
from oslo.config import cfg
-import testtools
from quantum.agent.common import config
from quantum.agent.linux import interface
from quantum.debug import commands
from quantum.debug.debug_agent import DEVICE_OWNER_PROBE, QuantumDebugAgent
+from quantum.tests import base
class MyApp(object):
self.stdout = _stdout
-class TestDebugCommands(testtools.TestCase):
+class TestDebugCommands(base.BaseTestCase):
def setUp(self):
super(TestDebugCommands, self).setUp()
cfg.CONF.register_opts(interface.OPTS)
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
+
import os
import socket
import sys
from quantum.common import constants
from quantum.common import exceptions
from quantum.openstack.common import jsonutils
+from quantum.tests import base
ROOTDIR = os.path.dirname(os.path.dirname(__file__))
ports=[])
-class TestDhcpAgent(testtools.TestCase):
+class TestDhcpAgent(base.BaseTestCase):
def setUp(self):
super(TestDhcpAgent, self).setUp()
cfg.CONF.register_opts(dhcp_agent.DeviceManager.OPTS)
self.assertFalse(dhcp.needs_resync)
-class TestDhcpAgentEventHandler(testtools.TestCase):
+class TestDhcpAgentEventHandler(base.BaseTestCase):
def setUp(self):
super(TestDhcpAgentEventHandler, self).setUp()
cfg.CONF.register_opts(dhcp_agent.DeviceManager.OPTS)
self.assertEqual(self.call_driver.call_count, 0)
-class TestDhcpPluginApiProxy(testtools.TestCase):
+class TestDhcpPluginApiProxy(base.BaseTestCase):
def setUp(self):
super(TestDhcpPluginApiProxy, self).setUp()
self.proxy = dhcp_agent.DhcpPluginApi('foo', {})
host='foo')
-class TestNetworkCache(testtools.TestCase):
+class TestNetworkCache(base.BaseTestCase):
def test_put_network(self):
nc = dhcp_agent.NetworkCache()
nc.put(fake_network)
self.assertEqual(nc.get_port_by_id(fake_port1.id), fake_port1)
-class TestDeviceManager(testtools.TestCase):
+class TestDeviceManager(base.BaseTestCase):
def setUp(self):
super(TestDeviceManager, self).setUp()
cfg.CONF.register_opts(dhcp_agent.DeviceManager.OPTS)
self.assertEqual(dh.get_device_id(fake_network), expected)
-class TestDhcpLeaseRelay(testtools.TestCase):
+class TestDhcpLeaseRelay(base.BaseTestCase):
def setUp(self):
super(TestDhcpLeaseRelay, self).setUp()
cfg.CONF.register_opts(dhcp_agent.DhcpLeaseRelay.OPTS)
relay._handler)])
-class TestDictModel(testtools.TestCase):
+class TestDictModel(base.BaseTestCase):
def test_basic_dict(self):
d = dict(a=1, b=2)
"""
from oslo.config import cfg
-import testtools
import webob.exc as webexc
import quantum
from quantum import manager
from quantum.plugins.common import constants
from quantum.plugins.openvswitch import ovs_quantum_plugin
+from quantum.tests import base
from quantum.tests.unit.extensions import extendedattribute as extattr
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import testlib_api
return self.objh[id]
-class ExtensionExtendedAttributeTestCase(testtools.TestCase):
+class ExtensionExtendedAttributeTestCase(base.BaseTestCase):
def setUp(self):
super(ExtensionExtendedAttributeTestCase, self).setUp()
plugin = (
import os
import routes
-import testtools
import webob
import webtest
from quantum.openstack.common import jsonutils
from quantum.openstack.common import log as logging
from quantum.plugins.common import constants
+from quantum.tests import base
from quantum.tests.unit import extension_stubs as ext_stubs
import quantum.tests.unit.extensions
from quantum.tests.unit import testlib_api
self._log("method_to_support_foxnsox_extension", context)
-class ResourceExtensionTest(testtools.TestCase):
+class ResourceExtensionTest(base.BaseTestCase):
class ResourceExtensionController(wsgi.Controller):
self.assertEqual(404, response.status_int)
-class ActionExtensionTest(testtools.TestCase):
+class ActionExtensionTest(base.BaseTestCase):
def setUp(self):
super(ActionExtensionTest, self).setUp()
self.assertEqual(404, response.status_int)
-class RequestExtensionTest(testtools.TestCase):
+class RequestExtensionTest(base.BaseTestCase):
def test_headers_can_be_extended(self):
def extend_headers(req, res):
return _setup_extensions_test_app(manager)
-class ExtensionManagerTest(testtools.TestCase):
+class ExtensionManagerTest(base.BaseTestCase):
def test_invalid_extensions_are_not_registered(self):
self.assertFalse('invalid_extension' in ext_mgr.extensions)
-class PluginAwareExtensionManagerTest(testtools.TestCase):
+class PluginAwareExtensionManagerTest(base.BaseTestCase):
def test_unsupported_extensions_are_not_loaded(self):
stub_plugin = ext_stubs.StubPlugin(supported_extensions=["e1", "e3"])
import mock
from mock import call
-import testtools
from quantum.agent.linux.iptables_firewall import IptablesFirewallDriver
from quantum.tests.unit import test_api_v2
+from quantum.tests import base
_uuid = test_api_v2._uuid
FAKE_PREFIX = {'IPv4': '10.0.0.0/24',
'IPv6': 'fe80::1'}
-class IptablesFirewallTestCase(testtools.TestCase):
+class IptablesFirewallTestCase(base.BaseTestCase):
def setUp(self):
super(IptablesFirewallTestCase, self).setUp()
self.utils_exec_p = mock.patch(
import os
import mox
-import testtools
from quantum.agent.linux import iptables_manager
+from quantum.tests import base
-class IptablesManagerStateFulTestCase(testtools.TestCase):
+class IptablesManagerStateFulTestCase(base.BaseTestCase):
def setUp(self):
super(IptablesManagerStateFulTestCase, self).setUp()
self.mox.VerifyAll()
-class IptablesManagerStateLessTestCase(testtools.TestCase):
+class IptablesManagerStateLessTestCase(base.BaseTestCase):
def setUp(self):
super(IptablesManagerStateLessTestCase, self).setUp()
import mock
from oslo.config import cfg
-import testtools
from quantum.agent.common import config as agent_config
from quantum.agent import l3_agent
from quantum.common import config as base_config
from quantum.common import constants as l3_constants
from quantum.openstack.common import uuidutils
+from quantum.tests import base
_uuid = uuidutils.generate_uuid
HOSTNAME = 'myhost'
-class TestBasicRouterOperations(testtools.TestCase):
+class TestBasicRouterOperations(base.BaseTestCase):
def setUp(self):
super(TestBasicRouterOperations, self).setUp()
from quantum.openstack.common.notifier import api as notifier_api
from quantum.openstack.common.notifier import test_notifier
from quantum.openstack.common import uuidutils
+from quantum.tests import base
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import test_db_plugin
from quantum.tests.unit import test_extensions
import testtools
from quantum.agent.linux import daemon
+from quantum.tests import base
FAKE_FD = 8
-class TestPidfile(testtools.TestCase):
+class TestPidfile(base.BaseTestCase):
def setUp(self):
super(TestPidfile, self).setUp()
self.os_p = mock.patch.object(daemon, 'os')
['cat', '/proc/34/cmdline'], 'sudo')
-class TestDaemon(testtools.TestCase):
+class TestDaemon(base.BaseTestCase):
def setUp(self):
super(TestDaemon, self).setUp()
self.os_p = mock.patch.object(daemon, 'os')
import mock
from oslo.config import cfg
-import testtools
from quantum.agent.common import config
from quantum.agent.linux import dhcp
from quantum.openstack.common import jsonutils
+from quantum.tests import base
class FakeIPAllocation:
ports = [FakePort1()]
-class TestDhcpBase(testtools.TestCase):
+class TestDhcpBase(base.BaseTestCase):
def test_base_abc_error(self):
self.assertRaises(TypeError, dhcp.DhcpBase, None)
self.called.append('spawn')
-class TestBase(testtools.TestCase):
+class TestBase(base.BaseTestCase):
def setUp(self):
super(TestBase, self).setUp()
root = os.path.dirname(os.path.dirname(__file__))
# @author: Mark McClain, DreamHost
import mock
-import testtools
from quantum.agent.linux import external_process as ep
+from quantum.tests import base
-class TestProcessManager(testtools.TestCase):
+class TestProcessManager(base.BaseTestCase):
def setUp(self):
super(TestProcessManager, self).setUp()
self.execute_p = mock.patch('quantum.agent.linux.utils.execute')
import mock
from oslo.config import cfg
-import testtools
from quantum.agent.common import config
from quantum.agent.dhcp_agent import DeviceManager
from quantum.agent.linux import ip_lib
from quantum.agent.linux import utils
from quantum.extensions.flavor import (FLAVOR_NETWORK)
+from quantum.tests import base
class BaseChild(interface.LinuxInterfaceDriver):
network_id = network.id
-class TestBase(testtools.TestCase):
+class TestBase(base.BaseTestCase):
def setUp(self):
super(TestBase, self).setUp()
root_helper_opt = [
# under the License.
import mock
-import testtools
from quantum.agent.linux import ip_lib
from quantum.common import exceptions
+from quantum.tests import base
NETNS_SAMPLE = [
'12345678-1234-5678-abcd-1234567890ab',
"10.0.0.0/24 dev qr-23380d11-d2 scope link src 10.0.0.1")
-class TestSubProcessBase(testtools.TestCase):
+class TestSubProcessBase(base.BaseTestCase):
def setUp(self):
super(TestSubProcessBase, self).setUp()
self.execute_p = mock.patch('quantum.agent.linux.utils.execute')
[], 'link', ('list',))
-class TestIpWrapper(testtools.TestCase):
+class TestIpWrapper(base.BaseTestCase):
def setUp(self):
super(TestIpWrapper, self).setUp()
self.execute_p = mock.patch.object(ip_lib.IPWrapper, '_execute')
self.assertEqual(dev.mock_calls, [])
-class TestIPDevice(testtools.TestCase):
+class TestIPDevice(base.BaseTestCase):
def test_eq_same_name(self):
dev1 = ip_lib.IPDevice('tap0')
dev2 = ip_lib.IPDevice('tap0')
self.assertEqual(str(ip_lib.IPDevice('tap0')), 'tap0')
-class TestIPCommandBase(testtools.TestCase):
+class TestIPCommandBase(base.BaseTestCase):
def setUp(self):
super(TestIPCommandBase, self).setUp()
self.ip = mock.Mock()
[mock.call._as_root('o', 'foo', ('link', ), False)])
-class TestIPDeviceCommandBase(testtools.TestCase):
+class TestIPDeviceCommandBase(base.BaseTestCase):
def setUp(self):
super(TestIPDeviceCommandBase, self).setUp()
self.ip_dev = mock.Mock()
self.assertEqual(self.ip_cmd.name, 'eth0')
-class TestIPCmdBase(testtools.TestCase):
+class TestIPCmdBase(base.BaseTestCase):
def setUp(self):
super(TestIPCmdBase, self).setUp()
self.parent = mock.Mock()
root_helper='sudo', check_exit_code=True)
-class TestDeviceExists(testtools.TestCase):
+class TestDeviceExists(base.BaseTestCase):
def test_device_exists(self):
with mock.patch.object(ip_lib.IPDevice, '_execute') as _execute:
_execute.return_value = LINK_SAMPLE[1]
import mock
from oslo.config import cfg
-import testtools
from webob import exc
import webtest
from quantum import manager
from quantum.openstack.common import uuidutils
from quantum.plugins.common import constants
+from quantum.tests import base
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import test_extensions
from quantum.tests.unit import testlib_api
import webob
from quantum.agent.metadata import agent
+from quantum.tests import base
class FakeConf(object):
metadata_proxy_shared_secret = 'secret'
-class TestMetadataProxyHandler(testtools.TestCase):
+class TestMetadataProxyHandler(base.BaseTestCase):
def setUp(self):
super(TestMetadataProxyHandler, self).setUp()
self.qclient_p = mock.patch('quantumclient.v2_0.client.Client')
)
-class TestUnixDomainHttpProtocol(testtools.TestCase):
+class TestUnixDomainHttpProtocol(base.BaseTestCase):
def test_init_empty_client(self):
u = agent.UnixDomainHttpProtocol(mock.Mock(), '', mock.Mock())
self.assertEqual(u.client_address, ('<local>', 0))
self.assertEqual(u.client_address, 'foo')
-class TestUnixDomainWSGIServer(testtools.TestCase):
+class TestUnixDomainWSGIServer(base.BaseTestCase):
def setUp(self):
super(TestUnixDomainWSGIServer, self).setUp()
self.eventlet_p = mock.patch.object(agent, 'eventlet')
self.assertTrue(len(logging.mock_calls))
-class TestUnixDomainMetadataProxy(testtools.TestCase):
+class TestUnixDomainMetadataProxy(base.BaseTestCase):
def setUp(self):
super(TestUnixDomainMetadataProxy, self).setUp()
self.cfg_p = mock.patch.object(agent, 'cfg')
import webob
from quantum.agent.metadata import namespace_proxy as ns_proxy
+from quantum.tests import base
class FakeConf(object):
metadata_proxy_shared_secret = 'secret'
-class TestUnixDomainHttpConnection(testtools.TestCase):
+class TestUnixDomainHttpConnection(base.BaseTestCase):
def test_connect(self):
with mock.patch.object(ns_proxy, 'cfg') as cfg:
cfg.CONF.metadata_proxy_socket = '/the/path'
self.assertEqual(conn.timeout, 3)
-class TestNetworkMetadataProxyHandler(testtools.TestCase):
+class TestNetworkMetadataProxyHandler(base.BaseTestCase):
def setUp(self):
super(TestNetworkMetadataProxyHandler, self).setUp()
self.log_p = mock.patch.object(ns_proxy, 'LOG')
)
-class TestProxyDaemon(testtools.TestCase):
+class TestProxyDaemon(base.BaseTestCase):
def test_init(self):
with mock.patch('quantum.agent.linux.daemon.Pidfile') as pf:
pd = ns_proxy.ProxyDaemon('pidfile', 9697, 'net_id', 'router_id')
import fixtures
import mock
-import testtools
import quantum
from quantum.common import exceptions
from quantum.openstack.common import importutils
from quantum.openstack.common import policy as common_policy
from quantum import policy
+from quantum.tests import base
-class PolicyFileTestCase(testtools.TestCase):
+class PolicyFileTestCase(base.BaseTestCase):
def setUp(self):
super(PolicyFileTestCase, self).setUp()
policy.reset()
self.target)
-class PolicyTestCase(testtools.TestCase):
+class PolicyTestCase(base.BaseTestCase):
def setUp(self):
super(PolicyTestCase, self).setUp()
policy.reset()
policy.enforce(admin_context, uppercase_action, self.target)
-class DefaultPolicyTestCase(testtools.TestCase):
+class DefaultPolicyTestCase(base.BaseTestCase):
def setUp(self):
super(DefaultPolicyTestCase, self).setUp()
self.context, "example:noexist", {})
-class QuantumPolicyTestCase(testtools.TestCase):
+class QuantumPolicyTestCase(base.BaseTestCase):
def setUp(self):
super(QuantumPolicyTestCase, self).setUp()
# under the License.
import mock
-import testtools
from quantum import context
+from quantum.tests import base
-class TestQuantumContext(testtools.TestCase):
+class TestQuantumContext(base.BaseTestCase):
def setUp(self):
super(TestQuantumContext, self).setUp()
import types
import fixtures
-import testtools
from oslo.config import cfg
from quantum.manager import QuantumManager
from quantum.openstack.common import log as logging
from quantum.plugins.common import constants
+from quantum.tests import base
from quantum.tests.unit import dummy_plugin
return os.path.join(ETCDIR, *p)
-class QuantumManagerTestCase(testtools.TestCase):
+class QuantumManagerTestCase(base.BaseTestCase):
def setUp(self):
super(QuantumManagerTestCase, self).setUp()
from quantum import manager
from quantum.plugins.linuxbridge.db import l2network_db_v2
from quantum import quota
+from quantum.tests import base
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import test_extensions
from quantum.tests.unit import testlib_api
import os
import mock
-import testtools
from quantum.common import utils
from quantum.rootwrap import filters
from quantum.rootwrap import wrapper
+from quantum.tests import base
-class RootwrapTestCase(testtools.TestCase):
+class RootwrapTestCase(base.BaseTestCase):
def setUp(self):
super(RootwrapTestCase, self).setUp()
from quantum.extensions import routedserviceinsertion as rsi
from quantum.extensions import routerservicetype as rst
from quantum.plugins.common import constants
+from quantum.tests import base
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import testlib_api
from quantum import wsgi
pass
-class RouterServiceInsertionTestCase(testtools.TestCase):
+class RouterServiceInsertionTestCase(base.BaseTestCase):
def setUp(self):
super(RouterServiceInsertionTestCase, self).setUp()
plugin = (
from mock import call
import mox
from oslo.config import cfg
-import testtools
from quantum.agent import firewall as firewall_base
from quantum.agent.linux import iptables_manager
from quantum.db import securitygroups_rpc_base as sg_db_rpc
from quantum.extensions import securitygroup as ext_sg
from quantum.openstack.common.rpc import proxy
+from quantum.tests import base
from quantum.tests.unit import test_extension_security_group as test_sg
from quantum.tests.unit import test_iptables_firewall as test_fw
fmt = 'xml'
-class SGAgentRpcCallBackMixinTestCase(testtools.TestCase):
+class SGAgentRpcCallBackMixinTestCase(base.BaseTestCase):
def setUp(self):
super(SGAgentRpcCallBackMixinTestCase, self).setUp()
self.rpc = sg_rpc.SecurityGroupAgentRpcCallbackMixin()
[call.security_groups_provider_updated()])
-class SecurityGroupAgentRpcTestCase(testtools.TestCase):
+class SecurityGroupAgentRpcTestCase(base.BaseTestCase):
def setUp(self):
super(SecurityGroupAgentRpcTestCase, self).setUp()
self.agent = sg_rpc.SecurityGroupAgentRpcMixin()
pass
-class SecurityGroupServerRpcApiTestCase(testtools.TestCase):
+class SecurityGroupServerRpcApiTestCase(base.BaseTestCase):
def setUp(self):
super(SecurityGroupServerRpcApiTestCase, self).setUp()
self.rpc = FakeSGRpcApi('fake_topic')
pass
-class SecurityGroupAgentRpcApiTestCase(testtools.TestCase):
+class SecurityGroupAgentRpcApiTestCase(base.BaseTestCase):
def setUp(self):
super(SecurityGroupAgentRpcApiTestCase, self).setUp()
self.notifier = FakeSGNotifierAPI(topic='fake',
FIREWALL_BASE_PACKAGE = 'quantum.agent.linux.iptables_firewall.'
-class TestSecurityGroupAgentWithIptables(testtools.TestCase):
+class TestSecurityGroupAgentWithIptables(base.BaseTestCase):
FIREWALL_DRIVER = FIREWALL_BASE_PACKAGE + 'IptablesFirewallDriver'
PHYSDEV_INGRESS = 'physdev-out'
PHYSDEV_EGRESS = 'physdev-in'
import mock
from oslo.config import cfg
-import testtools
import webob.exc as webexc
import webtest
from quantum.extensions import servicetype
from quantum import manager
from quantum.plugins.common import constants
+from quantum.tests import base
from quantum.tests.unit import dummy_plugin as dp
from quantum.tests.unit import test_api_v2
from quantum.tests.unit import test_db_plugin
# License for the specific language governing permissions and limitations
# under the License.
-import socket
-
import mock
-import testtools
+import socket
from quantum.api.v2 import attributes
from quantum.common import constants
from quantum.common import exceptions as exception
+from quantum.tests import base
from quantum import wsgi
-class TestWSGIServer(testtools.TestCase):
+class TestWSGIServer(base.BaseTestCase):
"""WSGI server tests."""
def test_start_random_port(self):
])
-class SerializerTest(testtools.TestCase):
+class SerializerTest(base.BaseTestCase):
def test_serialize_unknown_content_type(self):
"""
Test serialize verifies that exception InvalidContentType is raised
serializer.get_deserialize_handler, content_type)
-class RequestDeserializerTest(testtools.TestCase):
+class RequestDeserializerTest(base.BaseTestCase):
def test_get_body_deserializer_unknown_content_type(self):
"""
Test get body deserializer verifies
deserializer.get_body_deserializer, content_type)
-class ResponseSerializerTest(testtools.TestCase):
+class ResponseSerializerTest(base.BaseTestCase):
def setUp(self):
super(ResponseSerializerTest, self).setUp()
self.serializer.get_body_serializer, 'application/unknown')
-class XMLDeserializerTest(testtools.TestCase):
+class XMLDeserializerTest(base.BaseTestCase):
def test_default_raise_Maiformed_Exception(self):
"""
Test verifies that exception MalformedRequestBody is raised
exception.MalformedRequestBody, deserializer.default, data_string)
-class JSONDeserializerTest(testtools.TestCase):
+class JSONDeserializerTest(base.BaseTestCase):
def test_default_raise_Maiformed_Exception(self):
"""
Test verifies JsonDeserializer.default
exception.MalformedRequestBody, deserializer.default, data_string)
-class ResourceTest(testtools.TestCase):
+class ResourceTest(base.BaseTestCase):
def test_dispatch_unknown_controller_action(self):
class Controller(object):
def index(self, request, pants=None):
self.assertEqual(400, result.status_int)
-class XMLDictSerializerTest(testtools.TestCase):
+class XMLDictSerializerTest(base.BaseTestCase):
def test_xml(self):
NETWORK = {'network': {'test': None,
'tenant_id': 'test-tenant',
# License for the specific language governing permissions and limitations
# under the License.
-import testtools
-
from quantum.api.v2 import attributes
+from quantum.tests import base
from quantum import wsgi
return req
-class WebTestCase(testtools.TestCase):
+class WebTestCase(base.BaseTestCase):
fmt = 'json'
def setUp(self):
Code Review / openstack-build / neutron-build.git / commitdiff