Completed first-draft nvp_driver tests.

quark/drivers/nvp_driver.py

@@ -68,9 +68,9 @@ class NVPDriver(base.BaseDriver):
             conn["connection"] = aiclib.nvp.Connection(uri)
         return conn["connection"]
 
-    def create_network(self, tenant_id, network_name, tags=None,
+    def create_network(self, context, network_name, tags=None,
                        network_id=None, **kwargs):
-        return self._lswitch_create(tenant_id, network_name, tags,
+        return self._lswitch_create(context, network_name, tags,
                                     network_id, **kwargs)
 
     def delete_network(self, context, network_id):
@@ -84,8 +84,6 @@ class NVPDriver(base.BaseDriver):
         tenant_id = context.tenant_id
         lswitch = self._create_or_choose_lswitch(context, network_id)
         connection = self.get_connection()
-        if not connection:
-            raise
         port = connection.lswitch_port(lswitch)
         port.admin_status_enabled(status)
         tags = [dict(tag=network_id, scope="quantum_net_id"),

quark/tests/test_nvp_driver.py

@@ -32,27 +32,43 @@ class TestNVPDriver(test_base.TestBase):
         self.context = context.get_admin_context()
         self.driver = quark.drivers.nvp_driver.NVPDriver()
         self.lswitch_uuid = "12345678-1234-1234-1234-123456781234"
+        self.context.tenant_id = "tid"
         self.lport_uuid = "12345678-0000-0000-0000-123456781234"
         self.net_id = "12345678-1234-1234-1234-123412341234"
         self.port_id = "12345678-0000-0000-0000-123412341234"
+        self.d_pkg = "quark.drivers.nvp_driver.NVPDriver"
 
-    def _create_connection(self):
+    def _create_connection(self, switch_count=1):
         connection = mock.Mock()
         lswitch = self._create_lswitch()
-        lswitchport = self._create_lswitch_port(self.lswitch_uuid)
+        lswitchport = self._create_lswitch_port(self.lswitch_uuid,
+                                                switch_count)
         connection.lswitch_port = mock.Mock(return_value=lswitchport)
         connection.lswitch = mock.Mock(return_value=lswitch)
         return connection
 
-    def _create_lswitch_port(self, switch_uuid):
+    def _create_lswitch_port(self, switch_uuid, switch_count):
         port = mock.Mock()
         port.create = mock.Mock(return_value={'uuid': self.lport_uuid})
+        port_query = self._create_lport_query(switch_count)
+        port.query = mock.Mock(return_value=port_query)
+        port.delete = mock.Mock(return_value=None)
         return port
 
+    def _create_lport_query(self, switch_count):
+        query = mock.Mock()
+        port_list = {"_relations":
+                    {"LogicalSwitchConfig":
+                    {"uuid": self.lswitch_uuid}}}
+        port_query = {"results": [port_list], "result_count": switch_count}
+        query.results = mock.Mock(return_value=port_query)
+        return query
+
     def _create_lswitch(self):
         lswitch = mock.Mock()
         lswitch.query = mock.Mock(return_value=self._create_lswitch_query())
         lswitch.create = mock.Mock(return_value={'uuid': self.lswitch_uuid})
+        lswitch.delete = mock.Mock(return_value=None)
         return lswitch
 
     def _create_lswitch_query(self):
@@ -67,13 +83,55 @@ class TestNVPDriver(test_base.TestBase):
         db_api.clear_db()
 
 
+class TestNVPDriverCreateNetwork(TestNVPDriver):
+    @contextlib.contextmanager
+    def _stubs(self):
+        with contextlib.nested(
+            mock.patch("%s.get_connection" % self.d_pkg),
+        ) as (get_connection,):
+            connection = self._create_connection()
+            get_connection.return_value = connection
+            yield connection
+
+    def test_create_network(self):
+        with self._stubs() as (connection):
+            self.driver.create_network(self.context, "test")
+            self.assertTrue(connection.lswitch().create.called)
+
+
+class TestNVPDriverDeleteNetwork(TestNVPDriver):
+    @contextlib.contextmanager
+    def _stubs(self, network_exists=True):
+        with contextlib.nested(
+            mock.patch("%s.get_connection" % self.d_pkg),
+            mock.patch("%s._lswitches_for_network" % self.d_pkg),
+        ) as (get_connection, switch_list):
+            connection = self._create_connection()
+            get_connection.return_value = connection
+            if network_exists:
+                ret = {"results": [{"uuid": self.lswitch_uuid}]}
+            else:
+                ret = {"results": []}
+            switch_list().results = mock.Mock(return_value=ret)
+            yield connection
+
+    def test_delete_network(self):
+        with self._stubs() as (connection):
+            self.driver.delete_network(self.context, "test")
+            self.assertTrue(connection.lswitch().delete.called)
+
+    def test_delete_network_not_exists(self):
+        with self._stubs(network_exists=False) as (connection):
+            self.driver.delete_network(self.context, "test")
+            self.assertFalse(connection.lswitch().delete.called)
+
+
 class TestNVPDriverCreatePort(TestNVPDriver):
     @contextlib.contextmanager
     def _stubs(self, has_lswitch=True):
-        driver = "quark.drivers.nvp_driver.NVPDriver"
         with contextlib.nested(
-            mock.patch("%s.get_connection" % driver),
-            mock.patch("%s._lswitch_select_open" % driver),
+            mock.patch("%s.get_connection" % self.d_pkg),
+            mock.patch("%s._lswitch_select_open" % self.d_pkg),
         ) as (get_connection, select_open):
             connection = self._create_connection()
             get_connection.return_value = connection
@@ -115,3 +173,34 @@ class TestNVPDriverCreatePort(TestNVPDriver):
             status_args, kwargs = connection.lswitch_port().\
                 admin_status_enabled.call_args
             self.assertTrue(False in status_args)
+
+
+class TestNVPDriverDeletePort(TestNVPDriver):
+    @contextlib.contextmanager
+    def _stubs(self, single_switch=True):
+        with contextlib.nested(
+            mock.patch("%s.get_connection" % self.d_pkg),
+        ) as (get_connection,):
+            if not single_switch:
+                connection = self._create_connection(switch_count=2)
+            else:
+                connection = self._create_connection(switch_count=1)
+            get_connection.return_value = connection
+            yield connection
+
+    def test_delete_port(self):
+        with self._stubs() as (connection):
+            self.driver.delete_port(self.context, self.port_id)
+            self.assertTrue(connection.lswitch_port().delete.called)
+
+    def test_delete_port_switch_given(self):
+        with self._stubs() as (connection):
+            self.driver.delete_port(self.context, self.port_id,
+                                    self.lswitch_uuid)
+            self.assertFalse(connection.lswitch_port().query.called)
+            self.assertTrue(connection.lswitch_port().delete.called)
+
+    def test_delete_port_many_switches(self):
+        with self._stubs(single_switch=False):
+            with self.assertRaises(Exception):
+                self.driver.delete_port(self.context, self.port_id)