python-openstackclient 6.6.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

openstackclient/tests/unit/api/test_compute_v2.py

@@ -13,746 +13,561 @@
 
 """Compute v2 API Library Tests"""
 
-from keystoneauth1 import session
+import http
+from unittest import mock
+import uuid
+
+from openstack.compute.v2 import _proxy
 from osc_lib import exceptions as osc_lib_exceptions
-from requests_mock.contrib import fixture
 
 from openstackclient.api import compute_v2 as compute
+from openstackclient.tests.unit import fakes
 from openstackclient.tests.unit import utils
 
 
-FAKE_PROJECT = 'xyzpdq'
-FAKE_URL = 'http://gopher.com/v2'
-
+class TestSecurityGroup(utils.TestCase):
 
-class TestComputeAPIv2(utils.TestCase):
     def setUp(self):
-        super(TestComputeAPIv2, self).setUp()
-        sess = session.Session()
-        self.api = compute.APIv2(session=sess, endpoint=FAKE_URL)
-        self.requests_mock = self.useFixture(fixture.Fixture())
-
-
-class TestFloatingIP(TestComputeAPIv2):
-    FAKE_FLOATING_IP_RESP = {
-        'id': 1,
-        'ip': '203.0.113.11',  # TEST-NET-3
-        'fixed_ip': '198.51.100.11',  # TEST-NET-2
-        'pool': 'nova',
-        'instance_id': None,
-    }
-    FAKE_FLOATING_IP_RESP_2 = {
-        'id': 2,
-        'ip': '203.0.113.12',  # TEST-NET-3
-        'fixed_ip': '198.51.100.12',  # TEST-NET-2
-        'pool': 'nova',
-        'instance_id': None,
-    }
-    LIST_FLOATING_IP_RESP = [
-        FAKE_FLOATING_IP_RESP,
-        FAKE_FLOATING_IP_RESP_2,
-    ]
-
-    FAKE_SERVER_RESP_1 = {
-        'id': 1,
-        'name': 'server1',
-    }
-
-    def test_floating_ip_add_id(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/servers/1/action',
-            json={'server': {}},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/servers/1',
-            json={'server': self.FAKE_SERVER_RESP_1},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_add('1', '1.0.1.0')
-        self.assertEqual(200, ret.status_code)
-
-    def test_floating_ip_add_name(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/servers/1/action',
-            json={'server': {}},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/servers/server1',
-            json={'server': self.FAKE_SERVER_RESP_1},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_add('server1', '1.0.1.0')
-        self.assertEqual(200, ret.status_code)
-
-    def test_floating_ip_create(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-floating-ips',
-            json={'floating_ip': self.FAKE_FLOATING_IP_RESP},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_create('nova')
-        self.assertEqual(self.FAKE_FLOATING_IP_RESP, ret)
-
-    def test_floating_ip_create_not_found(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-floating-ips',
-            status_code=404,
+        super().setUp()
+
+        self.compute_sdk_client = mock.Mock(_proxy.Proxy)
+
+    def test_create_security_group(self):
+        sg_name = 'name-' + uuid.uuid4().hex
+        sg_description = 'description-' + uuid.uuid4().hex
+        data = {
+            'security_group': {
+                'id': uuid.uuid4().hex,
+                'name': sg_name,
+                'description': sg_description,
+                'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                'rules': [],
+            }
+        }
+        self.compute_sdk_client.post.return_value = fakes.FakeResponse(
+            data=data
         )
-        self.assertRaises(
-            osc_lib_exceptions.NotFound,
-            self.api.floating_ip_create,
-            'not-nova',
-        )
-
-    def test_floating_ip_delete(self):
-        self.requests_mock.register_uri(
-            'DELETE',
-            FAKE_URL + '/os-floating-ips/1',
-            status_code=202,
-        )
-        ret = self.api.floating_ip_delete('1')
-        self.assertEqual(202, ret.status_code)
-        self.assertEqual("", ret.text)
-
-    def test_floating_ip_delete_none(self):
-        ret = self.api.floating_ip_delete()
-        self.assertIsNone(ret)
-
-    def test_floating_ip_find_id(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ips/1',
-            json={'floating_ip': self.FAKE_FLOATING_IP_RESP},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_find('1')
-        self.assertEqual(self.FAKE_FLOATING_IP_RESP, ret)
-
-    def test_floating_ip_find_ip(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ips/' + self.FAKE_FLOATING_IP_RESP['ip'],
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ips',
-            json={'floating_ips': self.LIST_FLOATING_IP_RESP},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_find(self.FAKE_FLOATING_IP_RESP['ip'])
-        self.assertEqual(self.FAKE_FLOATING_IP_RESP, ret)
-
-    def test_floating_ip_find_not_found(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ips/1.2.3.4',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ips',
-            json={'floating_ips': self.LIST_FLOATING_IP_RESP},
-            status_code=200,
+
+        result = compute.create_security_group(
+            self.compute_sdk_client, sg_name, sg_description
         )
-        self.assertRaises(
-            osc_lib_exceptions.NotFound,
-            self.api.floating_ip_find,
-            '1.2.3.4',
-        )
-
-    def test_floating_ip_list(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ips',
-            json={'floating_ips': self.LIST_FLOATING_IP_RESP},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_list()
-        self.assertEqual(self.LIST_FLOATING_IP_RESP, ret)
-
-    def test_floating_ip_remove_id(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/servers/1/action',
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/servers/1',
-            json={'server': self.FAKE_SERVER_RESP_1},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_remove('1', '1.0.1.0')
-        self.assertEqual(200, ret.status_code)
-
-    def test_floating_ip_remove_name(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/servers/1/action',
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/servers/server1',
-            json={'server': self.FAKE_SERVER_RESP_1},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_remove('server1', '1.0.1.0')
-        self.assertEqual(200, ret.status_code)
-
-
-class TestFloatingIPPool(TestComputeAPIv2):
-    LIST_FLOATING_IP_POOL_RESP = [
-        {"name": "tide"},
-        {"name": "press"},
-    ]
-
-    def test_floating_ip_pool_list(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-floating-ip-pools',
-            json={'floating_ip_pools': self.LIST_FLOATING_IP_POOL_RESP},
-            status_code=200,
-        )
-        ret = self.api.floating_ip_pool_list()
-        self.assertEqual(self.LIST_FLOATING_IP_POOL_RESP, ret)
-
-
-class TestHost(TestComputeAPIv2):
-    FAKE_HOST_RESP_1 = {
-        "zone": "internal",
-        "host_name": "myhost",
-        "service": "conductor",
-    }
-
-    FAKE_HOST_RESP_2 = {
-        "zone": "internal",
-        "host_name": "myhost",
-        "service": "scheduler",
-    }
-
-    FAKE_HOST_RESP_3 = {
-        "zone": "nova",
-        "host_name": "myhost",
-        "service": "compute",
-    }
-
-    LIST_HOST_RESP = [
-        FAKE_HOST_RESP_1,
-        FAKE_HOST_RESP_2,
-        FAKE_HOST_RESP_3,
-    ]
-
-    def test_host_list_no_options(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-hosts',
-            json={'hosts': self.LIST_HOST_RESP},
-            status_code=200,
-        )
-        ret = self.api.host_list()
-        self.assertEqual(self.LIST_HOST_RESP, ret)
-
-    def test_host_list_zone(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-hosts?zone=nova',
-            json={'hosts': [self.FAKE_HOST_RESP_3]},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-hosts',
-            json={'hosts': [self.FAKE_HOST_RESP_3]},
-            status_code=200,
-        )
-        ret = self.api.host_list(zone='nova')
-        self.assertEqual([self.FAKE_HOST_RESP_3], ret)
-
-    def test_host_set_none(self):
-        ret = self.api.host_set(host='myhost')
-        self.assertIsNone(ret)
-
-    def test_host_set(self):
-        self.requests_mock.register_uri(
-            'PUT',
-            FAKE_URL + '/os-hosts/myhost',
-            json={},
-            status_code=200,
-        )
-        ret = self.api.host_set(host='myhost', status='enabled')
-        self.assertEqual({}, ret)
-
-    def test_host_show(self):
-        FAKE_RESOURCE_1 = {
-            "cpu": 2,
-            "disk_gb": 1028,
-            "host": "c1a7de0ac9d94e4baceae031d05caae3",
-            "memory_mb": 8192,
-            "project": "(total)",
-        }
-        FAKE_RESOURCE_2 = {
-            "cpu": 0,
-            "disk_gb": 0,
-            "host": "c1a7de0ac9d94e4baceae031d05caae3",
-            "memory_mb": 512,
-            "project": "(used_now)",
+
+        self.compute_sdk_client.post.assert_called_once_with(
+            '/os-security-groups',
+            data={'name': sg_name, 'description': sg_description},
+            microversion='2.1',
+        )
+        self.assertEqual(data['security_group'], result)
+
+    def test_list_security_groups(self):
+        data = {
+            'security_groups': [
+                {
+                    'id': uuid.uuid4().hex,
+                    'name': uuid.uuid4().hex,
+                    'description': 'description-' + uuid.uuid4().hex,
+                    'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                    'rules': [],
+                }
+            ],
         }
-        FAKE_RESOURCE_3 = {
-            "cpu": 0,
-            "disk_gb": 0,
-            "host": "c1a7de0ac9d94e4baceae031d05caae3",
-            "memory_mb": 0,
-            "project": "(used_max)",
+        self.compute_sdk_client.get.return_value = fakes.FakeResponse(
+            data=data
+        )
+
+        result = compute.list_security_groups(self.compute_sdk_client)
+
+        self.compute_sdk_client.get.assert_called_once_with(
+            '/os-security-groups', microversion='2.1'
+        )
+        self.assertEqual(data['security_groups'], result)
+
+    def test_find_security_group_by_id(self):
+        sg_id = uuid.uuid4().hex
+        sg_name = 'name-' + uuid.uuid4().hex
+        data = {
+            'security_group': {
+                'id': sg_id,
+                'name': sg_name,
+                'description': 'description-' + uuid.uuid4().hex,
+                'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                'rules': [],
+            }
         }
-        FAKE_HOST_RESP = [
-            {'resource': FAKE_RESOURCE_1},
-            {'resource': FAKE_RESOURCE_2},
-            {'resource': FAKE_RESOURCE_3},
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(data=data),
         ]
-        FAKE_HOST_LIST = [
-            FAKE_RESOURCE_1,
-            FAKE_RESOURCE_2,
-            FAKE_RESOURCE_3,
+
+        result = compute.find_security_group(self.compute_sdk_client, sg_id)
+
+        self.compute_sdk_client.get.assert_has_calls(
+            [
+                mock.call(f'/os-security-groups/{sg_id}', microversion='2.1'),
+            ]
+        )
+        self.assertEqual(data['security_group'], result)
+
+    def test_find_security_group_by_name(self):
+        sg_id = uuid.uuid4().hex
+        sg_name = 'name-' + uuid.uuid4().hex
+        data = {
+            'security_groups': [
+                {
+                    'id': sg_id,
+                    'name': sg_name,
+                    'description': 'description-' + uuid.uuid4().hex,
+                    'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                    'rules': [],
+                }
+            ],
+        }
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(status_code=http.HTTPStatus.NOT_FOUND),
+            fakes.FakeResponse(data=data),
         ]
 
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-hosts/myhost',
-            json={'host': FAKE_HOST_RESP},
-            status_code=200,
-        )
-        ret = self.api.host_show(host='myhost')
-        self.assertEqual(FAKE_HOST_LIST, ret)
-
-
-class TestNetwork(TestComputeAPIv2):
-    FAKE_NETWORK_RESP = {
-        'id': '1',
-        'label': 'label1',
-        'cidr': '1.2.3.0/24',
-    }
-
-    FAKE_NETWORK_RESP_2 = {
-        'id': '2',
-        'label': 'label2',
-        'cidr': '4.5.6.0/24',
-    }
-
-    LIST_NETWORK_RESP = [
-        FAKE_NETWORK_RESP,
-        FAKE_NETWORK_RESP_2,
-    ]
-
-    def test_network_create_default(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-networks',
-            json={'network': self.FAKE_NETWORK_RESP},
-            status_code=200,
-        )
-        ret = self.api.network_create('label1')
-        self.assertEqual(self.FAKE_NETWORK_RESP, ret)
-
-    def test_network_create_options(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-networks',
-            json={'network': self.FAKE_NETWORK_RESP},
-            status_code=200,
-        )
-        ret = self.api.network_create(
-            name='label1',
-            subnet='1.2.3.0/24',
-        )
-        self.assertEqual(self.FAKE_NETWORK_RESP, ret)
-
-    def test_network_delete_id(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks/1',
-            json={'network': self.FAKE_NETWORK_RESP},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'DELETE',
-            FAKE_URL + '/os-networks/1',
-            status_code=202,
-        )
-        ret = self.api.network_delete('1')
-        self.assertEqual(202, ret.status_code)
-        self.assertEqual("", ret.text)
-
-    def test_network_delete_name(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks/label1',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks',
-            json={'networks': self.LIST_NETWORK_RESP},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'DELETE',
-            FAKE_URL + '/os-networks/1',
-            status_code=202,
-        )
-        ret = self.api.network_delete('label1')
-        self.assertEqual(202, ret.status_code)
-        self.assertEqual("", ret.text)
-
-    def test_network_delete_not_found(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks/label3',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks',
-            json={'networks': self.LIST_NETWORK_RESP},
-            status_code=200,
+        result = compute.find_security_group(self.compute_sdk_client, sg_name)
+
+        self.compute_sdk_client.get.assert_has_calls(
+            [
+                mock.call(
+                    f'/os-security-groups/{sg_name}', microversion='2.1'
+                ),
+                mock.call('/os-security-groups', microversion='2.1'),
+            ]
         )
+        self.assertEqual(data['security_groups'][0], result)
+
+    def test_find_security_group_not_found(self):
+        data = {'security_groups': []}
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(status_code=http.HTTPStatus.NOT_FOUND),
+            fakes.FakeResponse(data=data),
+        ]
         self.assertRaises(
             osc_lib_exceptions.NotFound,
-            self.api.network_delete,
-            'label3',
-        )
-
-    def test_network_find_id(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks/1',
-            json={'network': self.FAKE_NETWORK_RESP},
-            status_code=200,
-        )
-        ret = self.api.network_find('1')
-        self.assertEqual(self.FAKE_NETWORK_RESP, ret)
-
-    def test_network_find_name(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks/label2',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks',
-            json={'networks': self.LIST_NETWORK_RESP},
-            status_code=200,
-        )
-        ret = self.api.network_find('label2')
-        self.assertEqual(self.FAKE_NETWORK_RESP_2, ret)
-
-    def test_network_find_not_found(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks/label3',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks',
-            json={'networks': self.LIST_NETWORK_RESP},
-            status_code=200,
-        )
+            compute.find_security_group,
+            self.compute_sdk_client,
+            'invalid-sg',
+        )
+
+    def test_find_security_group_by_name_duplicate(self):
+        sg_name = 'name-' + uuid.uuid4().hex
+        data = {
+            'security_groups': [
+                {
+                    'id': uuid.uuid4().hex,
+                    'name': sg_name,
+                    'description': 'description-' + uuid.uuid4().hex,
+                    'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                    'rules': [],
+                },
+                {
+                    'id': uuid.uuid4().hex,
+                    'name': sg_name,
+                    'description': 'description-' + uuid.uuid4().hex,
+                    'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                    'rules': [],
+                },
+            ],
+        }
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(status_code=http.HTTPStatus.NOT_FOUND),
+            fakes.FakeResponse(data=data),
+        ]
+
         self.assertRaises(
             osc_lib_exceptions.NotFound,
-            self.api.network_find,
-            'label3',
-        )
-
-    def test_network_list_no_options(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-networks',
-            json={'networks': self.LIST_NETWORK_RESP},
-            status_code=200,
-        )
-        ret = self.api.network_list()
-        self.assertEqual(self.LIST_NETWORK_RESP, ret)
-
-
-class TestSecurityGroup(TestComputeAPIv2):
-    FAKE_SECURITY_GROUP_RESP = {
-        'id': '1',
-        'name': 'sg1',
-        'description': 'test security group',
-        'tenant_id': '0123456789',
-        'rules': [],
-    }
-    FAKE_SECURITY_GROUP_RESP_2 = {
-        'id': '2',
-        'name': 'sg2',
-        'description': 'another test security group',
-        'tenant_id': '0123456789',
-        'rules': [],
-    }
-    LIST_SECURITY_GROUP_RESP = [
-        FAKE_SECURITY_GROUP_RESP_2,
-        FAKE_SECURITY_GROUP_RESP,
-    ]
-
-    def test_security_group_create_default(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-security-groups',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_create('sg1')
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RESP, ret)
-
-    def test_security_group_create_options(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-security-groups',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_create(
-            name='sg1',
-            description='desc',
-        )
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RESP, ret)
-
-    def test_security_group_delete_id(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/1',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'DELETE',
-            FAKE_URL + '/os-security-groups/1',
-            status_code=202,
-        )
-        ret = self.api.security_group_delete('1')
-        self.assertEqual(202, ret.status_code)
-        self.assertEqual("", ret.text)
-
-    def test_security_group_delete_name(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/sg1',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups',
-            json={'security_groups': self.LIST_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'DELETE',
-            FAKE_URL + '/os-security-groups/1',
-            status_code=202,
-        )
-        ret = self.api.security_group_delete('sg1')
-        self.assertEqual(202, ret.status_code)
-        self.assertEqual("", ret.text)
-
-    def test_security_group_delete_not_found(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/sg3',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups',
-            json={'security_groups': self.LIST_SECURITY_GROUP_RESP},
-            status_code=200,
+            compute.find_security_group,
+            self.compute_sdk_client,
+            sg_name,
+        )
+
+    def test_update_security_group(self):
+        sg_id = uuid.uuid4().hex
+        sg_name = 'name-' + uuid.uuid4().hex
+        sg_description = 'description-' + uuid.uuid4().hex
+        data = {
+            'security_group': {
+                'id': sg_id,
+                'name': sg_name,
+                'description': sg_description,
+                'tenant_id': 'project-id-' + uuid.uuid4().hex,
+                'rules': [],
+            }
+        }
+        self.compute_sdk_client.put.return_value = fakes.FakeResponse(
+            data=data
         )
-        self.assertRaises(
-            osc_lib_exceptions.NotFound,
-            self.api.security_group_delete,
-            'sg3',
-        )
-
-    def test_security_group_find_id(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/1',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_find('1')
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RESP, ret)
-
-    def test_security_group_find_name(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/sg2',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups',
-            json={'security_groups': self.LIST_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_find('sg2')
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RESP_2, ret)
-
-    def test_security_group_find_not_found(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/sg3',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups',
-            json={'security_groups': self.LIST_SECURITY_GROUP_RESP},
-            status_code=200,
+
+        result = compute.update_security_group(
+            self.compute_sdk_client, sg_id, sg_name, sg_description
         )
-        self.assertRaises(
-            osc_lib_exceptions.NotFound,
-            self.api.security_group_find,
-            'sg3',
-        )
-
-    def test_security_group_list_no_options(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups',
-            json={'security_groups': self.LIST_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_list()
-        self.assertEqual(self.LIST_SECURITY_GROUP_RESP, ret)
-
-    def test_security_group_set_options_id(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/1',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'PUT',
-            FAKE_URL + '/os-security-groups/1',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_set(
-            security_group='1', description='desc2'
-        )
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RESP, ret)
-
-    def test_security_group_set_options_name(self):
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups/sg2',
-            status_code=404,
-        )
-        self.requests_mock.register_uri(
-            'GET',
-            FAKE_URL + '/os-security-groups',
-            json={'security_groups': self.LIST_SECURITY_GROUP_RESP},
-            status_code=200,
-        )
-        self.requests_mock.register_uri(
-            'PUT',
-            FAKE_URL + '/os-security-groups/2',
-            json={'security_group': self.FAKE_SECURITY_GROUP_RESP_2},
-            status_code=200,
-        )
-        ret = self.api.security_group_set(
-            security_group='sg2', description='desc2'
-        )
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RESP_2, ret)
-
-
-class TestSecurityGroupRule(TestComputeAPIv2):
-    FAKE_SECURITY_GROUP_RULE_RESP = {
-        'id': '1',
-        'name': 'sgr1',
-        'tenant_id': 'proj-1',
-        'ip_protocol': 'TCP',
-        'from_port': 1,
-        'to_port': 22,
-        'group': {},
-        # 'ip_range': ,
-        # 'cidr': ,
-        # 'parent_group_id': ,
-    }
-
-    def test_security_group_create_no_options(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-security-group-rules',
-            json={'security_group_rule': self.FAKE_SECURITY_GROUP_RULE_RESP},
-            status_code=200,
-        )
-        ret = self.api.security_group_rule_create(
-            security_group_id='1',
-            ip_protocol='tcp',
+
+        self.compute_sdk_client.put.assert_called_once_with(
+            f'/os-security-groups/{sg_id}',
+            data={'name': sg_name, 'description': sg_description},
+            microversion='2.1',
+        )
+        self.assertEqual(data['security_group'], result)
+
+    def test_delete_security_group(self):
+        sg_id = uuid.uuid4().hex
+        self.compute_sdk_client.delete.return_value = fakes.FakeResponse(
+            status_code=http.HTTPStatus.NO_CONTENT
         )
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RULE_RESP, ret)
 
-    def test_security_group_create_options(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-security-group-rules',
-            json={'security_group_rule': self.FAKE_SECURITY_GROUP_RULE_RESP},
-            status_code=200,
+        result = compute.delete_security_group(self.compute_sdk_client, sg_id)
+
+        self.compute_sdk_client.delete.assert_called_once_with(
+            f'/os-security-groups/{sg_id}',
+            microversion='2.1',
         )
-        ret = self.api.security_group_rule_create(
-            security_group_id='1',
+        self.assertIsNone(result)
+
+
+class TestSecurityGroupRule(utils.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+        self.compute_sdk_client = mock.Mock(_proxy.Proxy)
+
+    def test_create_security_group_rule(self):
+        sg_id = uuid.uuid4().hex
+        data = {
+            'security_group_rule': {
+                'parent_group_id': sg_id,
+                'ip_protocol': 'tcp',
+                'from_port': 22,
+                'to_port': 22,
+                'cidr': '10.0.0.0/24',
+            }
+        }
+        self.compute_sdk_client.post.return_value = fakes.FakeResponse(
+            data=data
+        )
+
+        result = compute.create_security_group_rule(
+            self.compute_sdk_client,
+            security_group_id=sg_id,
             ip_protocol='tcp',
             from_port=22,
             to_port=22,
-            remote_ip='1.2.3.4/24',
+            remote_ip='10.0.0.0/24',
+            remote_group=None,
         )
-        self.assertEqual(self.FAKE_SECURITY_GROUP_RULE_RESP, ret)
 
-    def test_security_group_create_port_errors(self):
-        self.requests_mock.register_uri(
-            'POST',
-            FAKE_URL + '/os-security-group-rules',
-            json={'security_group_rule': self.FAKE_SECURITY_GROUP_RULE_RESP},
-            status_code=200,
+        self.compute_sdk_client.post.assert_called_once_with(
+            '/os-security-group-rules',
+            data={
+                'parent_group_id': sg_id,
+                'ip_protocol': 'tcp',
+                'from_port': 22,
+                'to_port': 22,
+                'cidr': '10.0.0.0/24',
+                'group_id': None,
+            },
+            microversion='2.1',
         )
-        self.assertRaises(
-            compute.InvalidValue,
-            self.api.security_group_rule_create,
-            security_group_id='1',
-            ip_protocol='tcp',
-            from_port='',
-            to_port=22,
-            remote_ip='1.2.3.4/24',
+        self.assertEqual(data['security_group_rule'], result)
+
+    def test_delete_security_group_rule(self):
+        sg_id = uuid.uuid4().hex
+        self.compute_sdk_client.delete.return_value = fakes.FakeResponse(
+            status_code=http.HTTPStatus.NO_CONTENT
+        )
+
+        result = compute.delete_security_group_rule(
+            self.compute_sdk_client, sg_id
         )
+
+        self.compute_sdk_client.delete.assert_called_once_with(
+            f'/os-security-group-rules/{sg_id}',
+            microversion='2.1',
+        )
+        self.assertIsNone(result)
+
+
+class TestNetwork(utils.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+        self.compute_sdk_client = mock.Mock(_proxy.Proxy)
+
+    def test_create_network(self):
+        net_name = 'name-' + uuid.uuid4().hex
+        net_subnet = '10.0.0.0/24'
+        data = {
+            'network': {
+                'id': uuid.uuid4().hex,
+                'label': net_name,
+                'cidr': net_subnet,
+                'share_address': True,
+                # other fields omitted for brevity
+            }
+        }
+        self.compute_sdk_client.post.return_value = fakes.FakeResponse(
+            data=data
+        )
+
+        result = compute.create_network(
+            self.compute_sdk_client,
+            name=net_name,
+            subnet=net_subnet,
+            share_subnet=True,
+        )
+
+        self.compute_sdk_client.post.assert_called_once_with(
+            '/os-networks',
+            data={
+                'label': net_name,
+                'cidr': net_subnet,
+                'share_address': True,
+            },
+            microversion='2.1',
+        )
+        self.assertEqual(data['network'], result)
+
+    def test_list_networks(self):
+        data = {
+            'networks': [
+                {
+                    'id': uuid.uuid4().hex,
+                    'label': f'name-{uuid.uuid4().hex}',
+                    # other fields omitted for brevity
+                }
+            ],
+        }
+        self.compute_sdk_client.get.return_value = fakes.FakeResponse(
+            data=data
+        )
+
+        result = compute.list_networks(self.compute_sdk_client)
+
+        self.compute_sdk_client.get.assert_called_once_with(
+            '/os-networks', microversion='2.1'
+        )
+        self.assertEqual(data['networks'], result)
+
+    def test_find_network_by_id(self):
+        net_id = uuid.uuid4().hex
+        net_name = 'name-' + uuid.uuid4().hex
+        data = {
+            'network': {
+                'id': net_id,
+                'label': net_name,
+                # other fields omitted for brevity
+            }
+        }
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(data=data),
+        ]
+
+        result = compute.find_network(self.compute_sdk_client, net_id)
+
+        self.compute_sdk_client.get.assert_has_calls(
+            [
+                mock.call(f'/os-networks/{net_id}', microversion='2.1'),
+            ]
+        )
+        self.assertEqual(data['network'], result)
+
+    def test_find_network_by_name(self):
+        net_id = uuid.uuid4().hex
+        net_name = 'name-' + uuid.uuid4().hex
+        data = {
+            'networks': [
+                {
+                    'id': net_id,
+                    'label': net_name,
+                    # other fields omitted for brevity
+                }
+            ],
+        }
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(status_code=http.HTTPStatus.NOT_FOUND),
+            fakes.FakeResponse(data=data),
+        ]
+
+        result = compute.find_network(self.compute_sdk_client, net_name)
+
+        self.compute_sdk_client.get.assert_has_calls(
+            [
+                mock.call(f'/os-networks/{net_name}', microversion='2.1'),
+                mock.call('/os-networks', microversion='2.1'),
+            ]
+        )
+        self.assertEqual(data['networks'][0], result)
+
+    def test_find_network_not_found(self):
+        data = {'networks': []}
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(status_code=http.HTTPStatus.NOT_FOUND),
+            fakes.FakeResponse(data=data),
+        ]
         self.assertRaises(
-            compute.InvalidValue,
-            self.api.security_group_rule_create,
-            security_group_id='1',
-            ip_protocol='tcp',
-            from_port=0,
-            to_port=[],
-            remote_ip='1.2.3.4/24',
+            osc_lib_exceptions.NotFound,
+            compute.find_network,
+            self.compute_sdk_client,
+            'invalid-net',
+        )
+
+    def test_find_network_by_name_duplicate(self):
+        net_name = 'name-' + uuid.uuid4().hex
+        data = {
+            'networks': [
+                {
+                    'id': uuid.uuid4().hex,
+                    'label': net_name,
+                    # other fields omitted for brevity
+                },
+                {
+                    'id': uuid.uuid4().hex,
+                    'label': net_name,
+                    # other fields omitted for brevity
+                },
+            ],
+        }
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(status_code=http.HTTPStatus.NOT_FOUND),
+            fakes.FakeResponse(data=data),
+        ]
+
+        self.assertRaises(
+            osc_lib_exceptions.NotFound,
+            compute.find_network,
+            self.compute_sdk_client,
+            net_name,
+        )
+
+    def test_delete_network(self):
+        net_id = uuid.uuid4().hex
+        self.compute_sdk_client.delete.return_value = fakes.FakeResponse(
+            status_code=http.HTTPStatus.NO_CONTENT
+        )
+
+        result = compute.delete_network(self.compute_sdk_client, net_id)
+
+        self.compute_sdk_client.delete.assert_called_once_with(
+            f'/os-networks/{net_id}', microversion='2.1'
+        )
+        self.assertIsNone(result)
+
+
+class TestFloatingIP(utils.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+        self.compute_sdk_client = mock.Mock(_proxy.Proxy)
+
+    def test_create_floating_ip(self):
+        network = 'network-' + uuid.uuid4().hex
+        data = {
+            'floating_ip': {
+                'fixed_ip': None,
+                'id': uuid.uuid4().hex,
+                'instance_id': None,
+                'ip': '172.24.4.17',
+                'pool': network,
+            }
+        }
+        self.compute_sdk_client.post.return_value = fakes.FakeResponse(
+            data=data
         )
 
-    def test_security_group_rule_delete(self):
-        self.requests_mock.register_uri(
-            'DELETE',
-            FAKE_URL + '/os-security-group-rules/1',
-            status_code=202,
+        result = compute.create_floating_ip(
+            self.compute_sdk_client, network=network
+        )
+
+        self.compute_sdk_client.post.assert_called_once_with(
+            '/os-floating-ips', data={'pool': network}, microversion='2.1'
+        )
+        self.assertEqual(data['floating_ip'], result)
+
+    def test_list_floating_ips(self):
+        data = {
+            'floating_ips': [
+                {
+                    'fixed_ip': None,
+                    'id': uuid.uuid4().hex,
+                    'instance_id': None,
+                    'ip': '172.24.4.17',
+                    'pool': f'network-{uuid.uuid4().hex}',
+                }
+            ],
+        }
+        self.compute_sdk_client.get.return_value = fakes.FakeResponse(
+            data=data
+        )
+
+        result = compute.list_floating_ips(self.compute_sdk_client)
+
+        self.compute_sdk_client.get.assert_called_once_with(
+            '/os-floating-ips', microversion='2.1'
+        )
+        self.assertEqual(data['floating_ips'], result)
+
+    def test_get_floating_ip(self):
+        fip_id = uuid.uuid4().hex
+        data = {
+            'floating_ip': {
+                'fixed_ip': None,
+                'id': fip_id,
+                'instance_id': None,
+                'ip': '172.24.4.17',
+                'pool': f'network-{uuid.uuid4().hex}',
+            }
+        }
+        self.compute_sdk_client.get.side_effect = [
+            fakes.FakeResponse(data=data),
+        ]
+
+        result = compute.get_floating_ip(self.compute_sdk_client, fip_id)
+
+        self.compute_sdk_client.get.assert_called_once_with(
+            f'/os-floating-ips/{fip_id}', microversion='2.1'
+        )
+        self.assertEqual(data['floating_ip'], result)
+
+    def test_delete_floating_ip(self):
+        fip_id = uuid.uuid4().hex
+        self.compute_sdk_client.delete.return_value = fakes.FakeResponse(
+            status_code=http.HTTPStatus.NO_CONTENT
+        )
+
+        result = compute.delete_floating_ip(self.compute_sdk_client, fip_id)
+
+        self.compute_sdk_client.delete.assert_called_once_with(
+            f'/os-floating-ips/{fip_id}', microversion='2.1'
+        )
+        self.assertIsNone(result)
+
+
+class TestFloatingIPPool(utils.TestCase):
+
+    def setUp(self):
+        super().setUp()
+
+        self.compute_sdk_client = mock.Mock(_proxy.Proxy)
+
+    def test_list_floating_ip_pools(self):
+        data = {
+            'floating_ip_pools': [
+                {
+                    'name': f'pool-{uuid.uuid4().hex}',
+                }
+            ],
+        }
+        self.compute_sdk_client.get.return_value = fakes.FakeResponse(
+            data=data
+        )
+
+        result = compute.list_floating_ip_pools(self.compute_sdk_client)
+
+        self.compute_sdk_client.get.assert_called_once_with(
+            '/os-floating-ip-pools', microversion='2.1'
         )
-        ret = self.api.security_group_rule_delete('1')
-        self.assertEqual(202, ret.status_code)
-        self.assertEqual("", ret.text)
+        self.assertEqual(data['floating_ip_pools'], result)