tests: Remove unnecessary nesting of compute resources

Change-Id: I27326b8f2e0d84d3ef2c2fbdcb5c96a5ac1d79e4
Signed-off-by: Stephen Finucane <sfinucan@redhat.com>

26 files changed, 1132 insertions, 1282 deletions

diff --git a/openstackclient/tests/unit/common/test_availability_zone.py b/openstackclient/tests/unit/common/test_availability_zone.py
index 99315eae..2ee6e2c4 100644
--- a/openstackclient/tests/unit/common/test_availability_zone.py
+++ b/openstackclient/tests/unit/common/test_availability_zone.py
@@ -114,9 +114,7 @@ class TestAvailabilityZone(utils.TestCommand):
 
 
 class TestAvailabilityZoneList(TestAvailabilityZone):
-    compute_azs = (
-        compute_fakes.FakeAvailabilityZone.create_availability_zones()
-    )
+    compute_azs = compute_fakes.create_availability_zones()
     volume_azs = volume_fakes.create_availability_zones(count=1)
     network_azs = network_fakes.create_availability_zones()
 
diff --git a/openstackclient/tests/unit/common/test_extension.py b/openstackclient/tests/unit/common/test_extension.py
index 56b2ccea..0771036f 100644
--- a/openstackclient/tests/unit/common/test_extension.py
+++ b/openstackclient/tests/unit/common/test_extension.py
@@ -72,7 +72,7 @@ class TestExtensionList(TestExtension):
 
     volume_extension = volume_fakes.create_one_extension()
     identity_extension = identity_fakes.FakeExtension.create_one_extension()
-    compute_extension = compute_fakes.FakeExtension.create_one_extension()
+    compute_extension = compute_fakes.create_one_extension()
     network_extension = network_fakes.FakeExtension.create_one_extension()
 
     def setUp(self):
diff --git a/openstackclient/tests/unit/common/test_project_purge.py b/openstackclient/tests/unit/common/test_project_purge.py
index ae3f58ec..850adb5b 100644
--- a/openstackclient/tests/unit/common/test_project_purge.py
+++ b/openstackclient/tests/unit/common/test_project_purge.py
@@ -67,7 +67,7 @@ class TestProjectPurgeInit(tests_utils.TestCommand):
 
 class TestProjectPurge(TestProjectPurgeInit):
     project = identity_fakes.FakeProject.create_one_project()
-    server = compute_fakes.FakeServer.create_one_server()
+    server = compute_fakes.create_one_server()
     image = image_fakes.create_one_image()
     volume = volume_fakes.create_one_volume()
     backup = volume_fakes.create_one_backup()
diff --git a/openstackclient/tests/unit/common/test_quota.py b/openstackclient/tests/unit/common/test_quota.py
index 4487014c..766599c9 100644
--- a/openstackclient/tests/unit/common/test_quota.py
+++ b/openstackclient/tests/unit/common/test_quota.py
@@ -123,12 +123,12 @@ class TestQuotaList(TestQuota):
         self.projects_mock.list.return_value = self.projects
 
         self.compute_quotas = [
-            compute_fakes.FakeQuota.create_one_comp_quota(),
-            compute_fakes.FakeQuota.create_one_comp_quota(),
+            compute_fakes.create_one_comp_quota(),
+            compute_fakes.create_one_comp_quota(),
         ]
         self.compute_default_quotas = [
-            compute_fakes.FakeQuota.create_one_default_comp_quota(),
-            compute_fakes.FakeQuota.create_one_default_comp_quota(),
+            compute_fakes.create_one_default_comp_quota(),
+            compute_fakes.create_one_default_comp_quota(),
         ]
         self.compute = self.app.client_manager.compute
         self.compute.quotas.defaults = mock.Mock(
@@ -216,9 +216,7 @@ class TestQuotaList(TestQuota):
         return reference_data
 
     def test_quota_list_details_compute(self):
-        detailed_quota = (
-            compute_fakes.FakeQuota.create_one_comp_detailed_quota()
-        )
+        detailed_quota = compute_fakes.create_one_comp_detailed_quota()
 
         detailed_column_header = (
             'Resource',
@@ -338,7 +336,7 @@ class TestQuotaList(TestQuota):
         self.compute.quotas.get = mock.Mock(
             side_effect=[
                 self.compute_quotas[0],
-                compute_fakes.FakeQuota.create_one_default_comp_quota(),
+                compute_fakes.create_one_default_comp_quota(),
             ],
         )
 
@@ -1087,10 +1085,10 @@ class TestQuotaShow(TestQuota):
     def setUp(self):
         super().setUp()
 
-        self.compute_quota = compute_fakes.FakeQuota.create_one_comp_quota()
+        self.compute_quota = compute_fakes.create_one_comp_quota()
         self.compute_quotas_mock.get.return_value = self.compute_quota
         self.compute_default_quota = (
-            compute_fakes.FakeQuota.create_one_default_comp_quota()
+            compute_fakes.create_one_default_comp_quota()
         )
         self.compute_quotas_mock.defaults.return_value = (
             self.compute_default_quota
@@ -1269,9 +1267,7 @@ class TestQuotaShow(TestQuota):
 
     def test_quota_show__with_usage(self):
         # update mocks to return detailed quota instead
-        self.compute_quota = (
-            compute_fakes.FakeQuota.create_one_comp_detailed_quota()
-        )
+        self.compute_quota = compute_fakes.create_one_comp_detailed_quota()
         self.compute_quotas_mock.get.return_value = self.compute_quota
         self.volume_quota = volume_fakes.create_one_detailed_quota()
         self.volume_quotas_mock.get.return_value = self.volume_quota
diff --git a/openstackclient/tests/unit/compute/v2/fakes.py b/openstackclient/tests/unit/compute/v2/fakes.py
index 17418c66..f73b6927 100644
--- a/openstackclient/tests/unit/compute/v2/fakes.py
+++ b/openstackclient/tests/unit/compute/v2/fakes.py
@@ -184,416 +184,388 @@ class TestComputev2(utils.TestCommand):
         )
 
 
-class FakeAggregate(object):
-    """Fake one aggregate."""
-
-    @staticmethod
-    def create_one_aggregate(attrs=None):
-        """Create a fake aggregate.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id and other attributes
-        """
-        attrs = attrs or {}
-
-        # Set default attribute
-        aggregate_info = {
-            "name": "aggregate-name-" + uuid.uuid4().hex,
+def create_one_aggregate(attrs=None):
+    """Create a fake aggregate.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with id and other attributes
+    """
+    attrs = attrs or {}
+
+    # Set default attribute
+    aggregate_info = {
+        "name": "aggregate-name-" + uuid.uuid4().hex,
+        "availability_zone": "ag_zone",
+        "hosts": [],
+        "id": "aggregate-id-" + uuid.uuid4().hex,
+        "metadata": {
             "availability_zone": "ag_zone",
-            "hosts": [],
-            "id": "aggregate-id-" + uuid.uuid4().hex,
-            "metadata": {
-                "availability_zone": "ag_zone",
-                "key1": "value1",
-            },
-        }
+            "key1": "value1",
+        },
+    }
 
-        # Overwrite default attributes.
-        aggregate_info.update(attrs)
+    # Overwrite default attributes.
+    aggregate_info.update(attrs)
 
-        aggregate = fakes.FakeResource(
-            info=copy.deepcopy(aggregate_info), loaded=True
-        )
-        return aggregate
-
-    @staticmethod
-    def create_aggregates(attrs=None, count=2):
-        """Create multiple fake aggregates.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of aggregates to fake
-        :return:
-            A list of FakeResource objects faking the aggregates
-        """
-        aggregates = []
-        for i in range(0, count):
-            aggregates.append(FakeAggregate.create_one_aggregate(attrs))
-
-        return aggregates
-
-    @staticmethod
-    def get_aggregates(aggregates=None, count=2):
-        """Get an iterable MagicMock object with a list of faked aggregates.
-
-        If aggregates list is provided, then initialize the Mock object
-        with the list. Otherwise create one.
-
-        :param List aggregates:
-            A list of FakeResource objects faking aggregates
-        :param int count:
-            The number of aggregates to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            aggregates
-        """
-        if aggregates is None:
-            aggregates = FakeAggregate.create_aggregates(count)
-        return mock.Mock(side_effect=aggregates)
-
-
-class FakeAgent(object):
-    """Fake one or more agent."""
-
-    @staticmethod
-    def create_one_agent(attrs=None):
-        """Create a fake agent.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with agent_id, os, and so on
-        """
-
-        attrs = attrs or {}
-
-        # set default attributes.
-        agent_info = {
-            'agent_id': 'agent-id-' + uuid.uuid4().hex,
-            'os': 'agent-os-' + uuid.uuid4().hex,
-            'architecture': 'agent-architecture',
-            'version': '8.0',
-            'url': 'http://127.0.0.1',
-            'md5hash': 'agent-md5hash',
-            'hypervisor': 'hypervisor',
-        }
+    aggregate = fakes.FakeResource(
+        info=copy.deepcopy(aggregate_info), loaded=True
+    )
+    return aggregate
 
-        # Overwrite default attributes.
-        agent_info.update(attrs)
-
-        agent = fakes.FakeResource(info=copy.deepcopy(agent_info), loaded=True)
-        return agent
-
-    @staticmethod
-    def create_agents(attrs=None, count=2):
-        """Create multiple fake agents.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of agents to fake
-        :return:
-            A list of FakeResource objects faking the agents
-        """
-        agents = []
-        for i in range(0, count):
-            agents.append(FakeAgent.create_one_agent(attrs))
-
-        return agents
-
-
-class FakeExtension(object):
-    """Fake one or more extension."""
-
-    @staticmethod
-    def create_one_extension(attrs=None):
-        """Create a fake extension.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object with name, namespace, etc.
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        extension_info = {
-            'name': 'name-' + uuid.uuid4().hex,
-            'namespace': (
-                'http://docs.openstack.org/compute/ext/multinic/api/v1.1'
-            ),
-            'description': 'description-' + uuid.uuid4().hex,
-            'updated': '2014-01-07T12:00:0-00:00',
-            'alias': 'NMN',
-            'links': (
-                '[{"href":'
-                '"https://github.com/openstack/compute-api", "type":'
-                ' "text/html", "rel": "describedby"}]'
-            ),
-        }
 
-        # Overwrite default attributes.
-        extension_info.update(attrs)
+def create_aggregates(attrs=None, count=2):
+    """Create multiple fake aggregates.
 
-        extension = fakes.FakeResource(
-            info=copy.deepcopy(extension_info), loaded=True
-        )
-        return extension
-
-
-class FakeSecurityGroup(object):
-    """Fake one or more security groups."""
-
-    @staticmethod
-    def create_one_security_group(attrs=None):
-        """Create a fake security group.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, etc.
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        security_group_attrs = {
-            'id': 'security-group-id-' + uuid.uuid4().hex,
-            'name': 'security-group-name-' + uuid.uuid4().hex,
-            'description': 'security-group-description-' + uuid.uuid4().hex,
-            'tenant_id': 'project-id-' + uuid.uuid4().hex,
-            'rules': [],
-        }
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of aggregates to fake
+    :return:
+        A list of FakeResource objects faking the aggregates
+    """
+    aggregates = []
+    for i in range(0, count):
+        aggregates.append(create_one_aggregate(attrs))
 
-        # Overwrite default attributes.
-        security_group_attrs.update(attrs)
-        return security_group_attrs
-
-    @staticmethod
-    def create_security_groups(attrs=None, count=2):
-        """Create multiple fake security groups.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of security groups to fake
-        :return:
-            A list of FakeResource objects faking the security groups
-        """
-        security_groups = []
-        for i in range(0, count):
-            security_groups.append(
-                FakeSecurityGroup.create_one_security_group(attrs)
-            )
-
-        return security_groups
-
-    @staticmethod
-    def get_security_groups(security_groups=None, count=2):
-        """Get an iterable MagicMock with a list of faked security groups.
-
-        If security groups list is provided, then initialize the Mock object
-        with the list. Otherwise create one.
-
-        :param List security_groups:
-            A list of FakeResource objects faking security groups
-        :param int count:
-            The number of security groups to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            security groups
-        """
-        if security_groups is None:
-            security_groups = FakeSecurityGroup.create_security_groups(count)
-        return mock.Mock(side_effect=security_groups)
-
-
-class FakeSecurityGroupRule(object):
-    """Fake one or more security group rules."""
-
-    @staticmethod
-    def create_one_security_group_rule(attrs=None):
-        """Create a fake security group rule.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, etc.
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        security_group_rule_attrs = {
-            'from_port': 0,
-            'group': {},
-            'id': 'security-group-rule-id-' + uuid.uuid4().hex,
-            'ip_protocol': 'tcp',
-            'ip_range': {'cidr': '0.0.0.0/0'},
-            'parent_group_id': 'security-group-id-' + uuid.uuid4().hex,
-            'to_port': 0,
-        }
+    return aggregates
 
-        # Overwrite default attributes.
-        security_group_rule_attrs.update(attrs)
-
-        return security_group_rule_attrs
-
-    @staticmethod
-    def create_security_group_rules(attrs=None, count=2):
-        """Create multiple fake security group rules.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of security group rules to fake
-        :return:
-            A list of FakeResource objects faking the security group rules
-        """
-        security_group_rules = []
-        for i in range(0, count):
-            security_group_rules.append(
-                FakeSecurityGroupRule.create_one_security_group_rule(attrs)
-            )
-
-        return security_group_rules
-
-
-class FakeServer(object):
-    """Fake one or more compute servers."""
-
-    @staticmethod
-    def create_one_server(attrs=None, methods=None):
-        """Create a fake server.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param dict methods:
-            A dictionary with all methods
-        :return:
-            A FakeResource object, with id, name, metadata, and so on
-        """
-        attrs = attrs or {}
-        methods = methods or {}
-
-        # Set default attributes.
-        server_info = {
-            'id': 'server-id-' + uuid.uuid4().hex,
-            'name': 'server-name-' + uuid.uuid4().hex,
-            'metadata': {},
-            'image': {
-                'id': 'image-id-' + uuid.uuid4().hex,
-            },
-            'flavor': {
-                'id': 'flavor-id-' + uuid.uuid4().hex,
-            },
-            'OS-EXT-STS:power_state': 1,
-        }
 
-        # Overwrite default attributes.
-        server_info.update(attrs)
+def get_aggregates(aggregates=None, count=2):
+    """Get an iterable MagicMock object with a list of faked aggregates.
+
+    If aggregates list is provided, then initialize the Mock object
+    with the list. Otherwise create one.
+
+    :param List aggregates:
+        A list of FakeResource objects faking aggregates
+    :param int count:
+        The number of aggregates to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        aggregates
+    """
+    if aggregates is None:
+        aggregates = create_aggregates(count)
+    return mock.Mock(side_effect=aggregates)
+
+
+def create_one_agent(attrs=None):
+    """Create a fake agent.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with agent_id, os, and so on
+    """
+
+    attrs = attrs or {}
+
+    # set default attributes.
+    agent_info = {
+        'agent_id': 'agent-id-' + uuid.uuid4().hex,
+        'os': 'agent-os-' + uuid.uuid4().hex,
+        'architecture': 'agent-architecture',
+        'version': '8.0',
+        'url': 'http://127.0.0.1',
+        'md5hash': 'agent-md5hash',
+        'hypervisor': 'hypervisor',
+    }
+
+    # Overwrite default attributes.
+    agent_info.update(attrs)
+
+    agent = fakes.FakeResource(info=copy.deepcopy(agent_info), loaded=True)
+    return agent
+
+
+def create_agents(attrs=None, count=2):
+    """Create multiple fake agents.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of agents to fake
+    :return:
+        A list of FakeResource objects faking the agents
+    """
+    agents = []
+    for i in range(0, count):
+        agents.append(create_one_agent(attrs))
+
+    return agents
+
+
+def create_one_extension(attrs=None):
+    """Create a fake extension.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object with name, namespace, etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    extension_info = {
+        'name': 'name-' + uuid.uuid4().hex,
+        'namespace': (
+            'http://docs.openstack.org/compute/ext/multinic/api/v1.1'
+        ),
+        'description': 'description-' + uuid.uuid4().hex,
+        'updated': '2014-01-07T12:00:0-00:00',
+        'alias': 'NMN',
+        'links': (
+            '[{"href":'
+            '"https://github.com/openstack/compute-api", "type":'
+            ' "text/html", "rel": "describedby"}]'
+        ),
+    }
+
+    # Overwrite default attributes.
+    extension_info.update(attrs)
+
+    extension = fakes.FakeResource(
+        info=copy.deepcopy(extension_info), loaded=True
+    )
+    return extension
+
+
+def create_one_security_group(attrs=None):
+    """Create a fake security group.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with id, name, etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    security_group_attrs = {
+        'id': 'security-group-id-' + uuid.uuid4().hex,
+        'name': 'security-group-name-' + uuid.uuid4().hex,
+        'description': 'security-group-description-' + uuid.uuid4().hex,
+        'tenant_id': 'project-id-' + uuid.uuid4().hex,
+        'rules': [],
+    }
+
+    # Overwrite default attributes.
+    security_group_attrs.update(attrs)
+    return security_group_attrs
+
+
+def create_security_groups(attrs=None, count=2):
+    """Create multiple fake security groups.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of security groups to fake
+    :return:
+        A list of FakeResource objects faking the security groups
+    """
+    security_groups = []
+    for i in range(0, count):
+        security_groups.append(create_one_security_group(attrs))
+
+    return security_groups
+
+
+def get_security_groups(security_groups=None, count=2):
+    """Get an iterable MagicMock with a list of faked security groups.
+
+    If security groups list is provided, then initialize the Mock object
+    with the list. Otherwise create one.
+
+    :param List security_groups:
+        A list of FakeResource objects faking security groups
+    :param int count:
+        The number of security groups to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        security groups
+    """
+    if security_groups is None:
+        security_groups = create_security_groups(count)
+    return mock.Mock(side_effect=security_groups)
+
+
+def create_one_security_group_rule(attrs=None):
+    """Create a fake security group rule.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with id, etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    security_group_rule_attrs = {
+        'from_port': 0,
+        'group': {},
+        'id': 'security-group-rule-id-' + uuid.uuid4().hex,
+        'ip_protocol': 'tcp',
+        'ip_range': {'cidr': '0.0.0.0/0'},
+        'parent_group_id': 'security-group-id-' + uuid.uuid4().hex,
+        'to_port': 0,
+    }
+
+    # Overwrite default attributes.
+    security_group_rule_attrs.update(attrs)
+
+    return security_group_rule_attrs
 
-        server = fakes.FakeResource(
-            info=copy.deepcopy(server_info), methods=methods, loaded=True
-        )
-        return server
-
-    @staticmethod
-    def create_servers(attrs=None, methods=None, count=2):
-        """Create multiple fake servers.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param dict methods:
-            A dictionary with all methods
-        :param int count:
-            The number of servers to fake
-        :return:
-            A list of FakeResource objects faking the servers
-        """
-        servers = []
-        for i in range(0, count):
-            servers.append(FakeServer.create_one_server(attrs, methods))
-
-        return servers
-
-    @staticmethod
-    def create_one_sdk_server(attrs=None, methods=None):
-        """Create a fake server for testing migration to sdk
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param dict methods:
-            A dictionary with all methods
-        :return:
-            A openstack.compute.v2.server.Server object,
-            with id, name, metadata, and so on
-        """
-        attrs = attrs or {}
-        methods = methods or {}
-
-        # Set default attributes.
-        server_info = {
-            'id': 'server-id-' + uuid.uuid4().hex,
-            'name': 'server-name-' + uuid.uuid4().hex,
-            'metadata': {},
-            'image': {
-                'id': 'image-id-' + uuid.uuid4().hex,
-            },
-            'flavor': {
-                'id': 'flavor-id-' + uuid.uuid4().hex,
-            },
-            'OS-EXT-STS:power_state': 1,
-        }
 
-        # Overwrite default attributes.
-        server_info.update(attrs)
-        server = _server.Server(**server_info)
-
-        # Override methods
-        server.trigger_crash_dump = mock.MagicMock()
-
-        return server
-
-    @staticmethod
-    def create_sdk_servers(attrs=None, methods=None, count=2):
-        """Create multiple fake servers for testing migration to sdk
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param dict methods:
-            A dictionary with all methods
-        :param int count:
-            The number of servers to fake
-        :return:
-            A list of openstack.compute.v2.server.Server objects
-            faking the servers
-        """
-        servers = []
-        for i in range(0, count):
-            servers.append(FakeServer.create_one_sdk_server(attrs, methods))
-
-        return servers
-
-    @staticmethod
-    def get_servers(servers=None, count=2):
-        """Get an iterable MagicMock object with a list of faked servers.
-
-        If servers list is provided, then initialize the Mock object with the
-        list. Otherwise create one.
-
-        :param List servers:
-            A list of FakeResource objects faking servers
-        :param int count:
-            The number of servers to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            servers
-        """
-        if servers is None:
-            servers = FakeServer.create_servers(count)
-        return mock.Mock(side_effect=servers)
+def create_security_group_rules(attrs=None, count=2):
+    """Create multiple fake security group rules.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of security group rules to fake
+    :return:
+        A list of FakeResource objects faking the security group rules
+    """
+    security_group_rules = []
+    for i in range(0, count):
+        security_group_rules.append(create_one_security_group_rule(attrs))
+
+    return security_group_rules
+
+
+def create_one_server(attrs=None, methods=None):
+    """Create a fake server.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param dict methods:
+        A dictionary with all methods
+    :return:
+        A FakeResource object, with id, name, metadata, and so on
+    """
+    attrs = attrs or {}
+    methods = methods or {}
+
+    # Set default attributes.
+    server_info = {
+        'id': 'server-id-' + uuid.uuid4().hex,
+        'name': 'server-name-' + uuid.uuid4().hex,
+        'metadata': {},
+        'image': {
+            'id': 'image-id-' + uuid.uuid4().hex,
+        },
+        'flavor': {
+            'id': 'flavor-id-' + uuid.uuid4().hex,
+        },
+        'OS-EXT-STS:power_state': 1,
+    }
+
+    # Overwrite default attributes.
+    server_info.update(attrs)
+
+    server = fakes.FakeResource(
+        info=copy.deepcopy(server_info), methods=methods, loaded=True
+    )
+    return server
+
+
+def create_servers(attrs=None, methods=None, count=2):
+    """Create multiple fake servers.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param dict methods:
+        A dictionary with all methods
+    :param int count:
+        The number of servers to fake
+    :return:
+        A list of FakeResource objects faking the servers
+    """
+    servers = []
+    for i in range(0, count):
+        servers.append(create_one_server(attrs, methods))
+
+    return servers
+
+
+def create_one_sdk_server(attrs=None, methods=None):
+    """Create a fake server for testing migration to sdk
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param dict methods:
+        A dictionary with all methods
+    :return:
+        A openstack.compute.v2.server.Server object,
+        with id, name, metadata, and so on
+    """
+    attrs = attrs or {}
+    methods = methods or {}
+
+    # Set default attributes.
+    server_info = {
+        'id': 'server-id-' + uuid.uuid4().hex,
+        'name': 'server-name-' + uuid.uuid4().hex,
+        'metadata': {},
+        'image': {
+            'id': 'image-id-' + uuid.uuid4().hex,
+        },
+        'flavor': {
+            'id': 'flavor-id-' + uuid.uuid4().hex,
+        },
+        'OS-EXT-STS:power_state': 1,
+    }
+
+    # Overwrite default attributes.
+    server_info.update(attrs)
+    server = _server.Server(**server_info)
+
+    # Override methods
+    server.trigger_crash_dump = mock.MagicMock()
+
+    return server
+
+
+def create_sdk_servers(attrs=None, methods=None, count=2):
+    """Create multiple fake servers for testing migration to sdk
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param dict methods:
+        A dictionary with all methods
+    :param int count:
+        The number of servers to fake
+    :return:
+        A list of openstack.compute.v2.server.Server objects
+        faking the servers
+    """
+    servers = []
+    for i in range(0, count):
+        servers.append(create_one_sdk_server(attrs, methods))
+
+    return servers
+
+
+def get_servers(servers=None, count=2):
+    """Get an iterable MagicMock object with a list of faked servers.
+
+    If servers list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
+
+    :param List servers:
+        A list of FakeResource objects faking servers
+    :param int count:
+        The number of servers to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        servers
+    """
+    if servers is None:
+        servers = create_servers(count)
+    return mock.Mock(side_effect=servers)
 
 
 def create_one_server_action(attrs=None):
@@ -639,708 +611,652 @@ def create_one_server_action(attrs=None):
     return server_action
 
 
-class FakeService(object):
-    """Fake one or more services."""
-
-    @staticmethod
-    def create_one_service(attrs=None):
-        """Create a fake service.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A fake Service object, with id, host, binary, and so on
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        service_info = {
-            'id': 'id-' + uuid.uuid4().hex,
-            'host': 'host-' + uuid.uuid4().hex,
-            'binary': 'binary-' + uuid.uuid4().hex,
-            'status': 'enabled',
-            'availability_zone': 'zone-' + uuid.uuid4().hex,
-            'state': 'state-' + uuid.uuid4().hex,
-            'updated_at': 'time-' + uuid.uuid4().hex,
-            'disabled_reason': 'earthquake',
-            # Introduced in API microversion 2.11
-            'is_forced_down': False,
-        }
+def create_one_service(attrs=None):
+    """Create a fake service.
 
-        # Overwrite default attributes.
-        service_info.update(attrs)
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A fake Service object, with id, host, binary, and so on
+    """
+    attrs = attrs or {}
 
-        return service.Service(**service_info)
+    # Set default attributes.
+    service_info = {
+        'id': 'id-' + uuid.uuid4().hex,
+        'host': 'host-' + uuid.uuid4().hex,
+        'binary': 'binary-' + uuid.uuid4().hex,
+        'status': 'enabled',
+        'availability_zone': 'zone-' + uuid.uuid4().hex,
+        'state': 'state-' + uuid.uuid4().hex,
+        'updated_at': 'time-' + uuid.uuid4().hex,
+        'disabled_reason': 'earthquake',
+        # Introduced in API microversion 2.11
+        'is_forced_down': False,
+    }
 
-    @staticmethod
-    def create_services(attrs=None, count=2):
-        """Create multiple fake services.
+    # Overwrite default attributes.
+    service_info.update(attrs)
 
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of services to fake
-        :return:
-            A list of FakeResource objects faking the services
-        """
-        services = []
-        for i in range(0, count):
-            services.append(FakeService.create_one_service(attrs))
+    return service.Service(**service_info)
 
-        return services
 
+def create_services(attrs=None, count=2):
+    """Create multiple fake services.
 
-class FakeFlavor(object):
-    """Fake one or more flavors."""
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of services to fake
+    :return:
+        A list of FakeResource objects faking the services
+    """
+    services = []
+    for i in range(0, count):
+        services.append(create_one_service(attrs))
 
-    @staticmethod
-    def create_one_flavor(attrs=None):
-        """Create a fake flavor.
+    return services
 
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, name, ram, vcpus, and so on
-        """
-        attrs = attrs or {}
 
-        # Set default attributes.
-        flavor_info = {
-            'id': 'flavor-id-' + uuid.uuid4().hex,
-            'name': 'flavor-name-' + uuid.uuid4().hex,
-            'ram': 8192,
-            'vcpus': 4,
-            'disk': 128,
-            'swap': 0,
-            'rxtx_factor': 1.0,
-            'OS-FLV-DISABLED:disabled': False,
-            'os-flavor-access:is_public': True,
-            'description': 'description',
-            'OS-FLV-EXT-DATA:ephemeral': 0,
-            'extra_specs': {'property': 'value'},
-        }
+def create_one_flavor(attrs=None):
+    """Create a fake flavor.
 
-        # Overwrite default attributes.
-        flavor_info.update(attrs)
-
-        flavor = _flavor.Flavor(**flavor_info)
-
-        return flavor
-
-    @staticmethod
-    def create_flavors(attrs=None, count=2):
-        """Create multiple fake flavors.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of flavors to fake
-        :return:
-            A list of FakeResource objects faking the flavors
-        """
-        flavors = []
-        for i in range(0, count):
-            flavors.append(FakeFlavor.create_one_flavor(attrs))
-
-        return flavors
-
-    @staticmethod
-    def get_flavors(flavors=None, count=2):
-        """Get an iterable MagicMock object with a list of faked flavors.
-
-        If flavors list is provided, then initialize the Mock object with the
-        list. Otherwise create one.
-
-        :param List flavors:
-            A list of FakeResource objects faking flavors
-        :param int count:
-            The number of flavors to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            flavors
-        """
-        if flavors is None:
-            flavors = FakeFlavor.create_flavors(count)
-        return mock.Mock(side_effect=flavors)
-
-
-class FakeFlavorAccess(object):
-    """Fake one or more flavor accesses."""
-
-    @staticmethod
-    def create_one_flavor_access(attrs=None):
-        """Create a fake flavor access.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with flavor_id, tenat_id
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        flavor_access_info = {
-            'flavor_id': 'flavor-id-' + uuid.uuid4().hex,
-            'tenant_id': 'tenant-id-' + uuid.uuid4().hex,
-        }
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with id, name, ram, vcpus, and so on
+    """
+    attrs = attrs or {}
 
-        # Overwrite default attributes.
-        flavor_access_info.update(attrs)
+    # Set default attributes.
+    flavor_info = {
+        'id': 'flavor-id-' + uuid.uuid4().hex,
+        'name': 'flavor-name-' + uuid.uuid4().hex,
+        'ram': 8192,
+        'vcpus': 4,
+        'disk': 128,
+        'swap': 0,
+        'rxtx_factor': 1.0,
+        'OS-FLV-DISABLED:disabled': False,
+        'os-flavor-access:is_public': True,
+        'description': 'description',
+        'OS-FLV-EXT-DATA:ephemeral': 0,
+        'extra_specs': {'property': 'value'},
+    }
 
-        flavor_access = fakes.FakeResource(
-            info=copy.deepcopy(flavor_access_info), loaded=True
-        )
+    # Overwrite default attributes.
+    flavor_info.update(attrs)
+
+    flavor = _flavor.Flavor(**flavor_info)
 
-        return flavor_access
+    return flavor
 
 
-class FakeKeypair(object):
-    """Fake one or more keypairs."""
+def create_flavors(attrs=None, count=2):
+    """Create multiple fake flavors.
 
-    @staticmethod
-    def create_one_keypair(attrs=None):
-        """Create a fake keypair
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of flavors to fake
+    :return:
+        A list of FakeResource objects faking the flavors
+    """
+    flavors = []
+    for i in range(0, count):
+        flavors.append(create_one_flavor(attrs))
 
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, name, fingerprint, and so on
-        """
-        attrs = attrs or {}
+    return flavors
 
-        # Set default attributes.
-        keypair_info = {
-            'name': 'keypair-name-' + uuid.uuid4().hex,
-            'type': 'ssh',
-            'fingerprint': 'dummy',
-            'public_key': 'dummy',
-            'user_id': 'user',
-        }
 
-        # Overwrite default attributes.
-        keypair_info.update(attrs)
+def get_flavors(flavors=None, count=2):
+    """Get an iterable MagicMock object with a list of faked flavors.
 
-        keypair = fakes.FakeResource(
-            info=copy.deepcopy(keypair_info), loaded=True
-        )
+    If flavors list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
 
-        return keypair
-
-    @staticmethod
-    def create_keypairs(attrs=None, count=2):
-        """Create multiple fake keypairs.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of keypairs to fake
-        :return:
-            A list of FakeResource objects faking the keypairs
-        """
-
-        keypairs = []
-        for i in range(0, count):
-            keypairs.append(FakeKeypair.create_one_keypair(attrs))
-
-        return keypairs
-
-    @staticmethod
-    def get_keypairs(keypairs=None, count=2):
-        """Get an iterable MagicMock object with a list of faked keypairs.
-
-        If keypairs list is provided, then initialize the Mock object with the
-        list. Otherwise create one.
-
-        :param List keypairs:
-            A list of FakeResource objects faking keypairs
-        :param int count:
-            The number of keypairs to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            keypairs
-        """
-        if keypairs is None:
-            keypairs = FakeKeypair.create_keypairs(count)
-        return mock.Mock(side_effect=keypairs)
-
-
-class FakeAvailabilityZone(object):
-    """Fake one or more compute availability zones (AZs)."""
-
-    @staticmethod
-    def create_one_availability_zone(attrs=None):
-        """Create a fake AZ.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object with zoneName, zoneState, etc.
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        host_name = uuid.uuid4().hex
-        service_name = uuid.uuid4().hex
-        service_updated_at = uuid.uuid4().hex
-        availability_zone = {
-            'zoneName': uuid.uuid4().hex,
-            'zoneState': {'available': True},
-            'hosts': {
-                host_name: {
-                    service_name: {
-                        'available': True,
-                        'active': True,
-                        'updated_at': service_updated_at,
-                    }
-                }
-            },
-        }
+    :param List flavors:
+        A list of FakeResource objects faking flavors
+    :param int count:
+        The number of flavors to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        flavors
+    """
+    if flavors is None:
+        flavors = create_flavors(count)
+    return mock.Mock(side_effect=flavors)
 
-        # Overwrite default attributes.
-        availability_zone.update(attrs)
 
-        availability_zone = fakes.FakeResource(
-            info=copy.deepcopy(availability_zone), loaded=True
-        )
-        return availability_zone
-
-    @staticmethod
-    def create_availability_zones(attrs=None, count=2):
-        """Create multiple fake AZs.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of AZs to fake
-        :return:
-            A list of FakeResource objects faking the AZs
-        """
-        availability_zones = []
-        for i in range(0, count):
-            availability_zone = (
-                FakeAvailabilityZone.create_one_availability_zone(attrs)
-            )
-            availability_zones.append(availability_zone)
-
-        return availability_zones
-
-
-class FakeFloatingIP(object):
-    """Fake one or more floating ip."""
-
-    @staticmethod
-    def create_one_floating_ip(attrs=None):
-        """Create a fake floating ip.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, ip, and so on
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        floating_ip_attrs = {
-            'id': 'floating-ip-id-' + uuid.uuid4().hex,
-            'ip': '1.0.9.0',
-            'fixed_ip': '2.0.9.0',
-            'instance_id': 'server-id-' + uuid.uuid4().hex,
-            'pool': 'public',
-        }
+def create_one_flavor_access(attrs=None):
+    """Create a fake flavor access.
 
-        # Overwrite default attributes.
-        floating_ip_attrs.update(attrs)
-
-        return floating_ip_attrs
-
-    @staticmethod
-    def create_floating_ips(attrs=None, count=2):
-        """Create multiple fake floating ips.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of floating ips to fake
-        :return:
-            A list of FakeResource objects faking the floating ips
-        """
-        floating_ips = []
-        for i in range(0, count):
-            floating_ips.append(FakeFloatingIP.create_one_floating_ip(attrs))
-        return floating_ips
-
-    @staticmethod
-    def get_floating_ips(floating_ips=None, count=2):
-        """Get an iterable MagicMock object with a list of faked floating ips.
-
-        If floating_ips list is provided, then initialize the Mock object
-        with the list. Otherwise create one.
-
-        :param List floating_ips:
-            A list of FakeResource objects faking floating ips
-        :param int count:
-            The number of floating ips to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            floating ips
-        """
-        if floating_ips is None:
-            floating_ips = FakeFloatingIP.create_floating_ips(count)
-        return mock.Mock(side_effect=floating_ips)
-
-
-class FakeFloatingIPPool(object):
-    """Fake one or more floating ip pools."""
-
-    @staticmethod
-    def create_one_floating_ip_pool(attrs=None):
-        """Create a fake floating ip pool.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with name, etc
-        """
-        if attrs is None:
-            attrs = {}
-
-        # Set default attributes.
-        floating_ip_pool_attrs = {
-            'name': 'floating-ip-pool-name-' + uuid.uuid4().hex,
-        }
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with flavor_id, tenat_id
+    """
+    attrs = attrs or {}
 
-        # Overwrite default attributes.
-        floating_ip_pool_attrs.update(attrs)
-
-        return floating_ip_pool_attrs
-
-    @staticmethod
-    def create_floating_ip_pools(attrs=None, count=2):
-        """Create multiple fake floating ip pools.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of floating ip pools to fake
-        :return:
-            A list of FakeResource objects faking the floating ip pools
-        """
-        floating_ip_pools = []
-        for i in range(0, count):
-            floating_ip_pools.append(
-                FakeFloatingIPPool.create_one_floating_ip_pool(attrs)
-            )
-        return floating_ip_pools
-
-
-class FakeNetwork(object):
-    """Fake one or more networks."""
-
-    @staticmethod
-    def create_one_network(attrs=None):
-        """Create a fake network.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with id, label, cidr and so on
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        network_attrs = {
-            'bridge': 'br100',
-            'bridge_interface': None,
-            'broadcast': '10.0.0.255',
-            'cidr': '10.0.0.0/24',
-            'cidr_v6': None,
-            'created_at': '2016-02-11T11:17:37.000000',
-            'deleted': False,
-            'deleted_at': None,
-            'dhcp_server': '10.0.0.1',
-            'dhcp_start': '10.0.0.2',
-            'dns1': '8.8.4.4',
-            'dns2': None,
-            'enable_dhcp': True,
-            'gateway': '10.0.0.1',
-            'gateway_v6': None,
-            'host': None,
-            'id': 'network-id-' + uuid.uuid4().hex,
-            'injected': False,
-            'label': 'network-label-' + uuid.uuid4().hex,
-            'mtu': None,
-            'multi_host': False,
-            'netmask': '255.255.255.0',
-            'netmask_v6': None,
-            'priority': None,
-            'project_id': 'project-id-' + uuid.uuid4().hex,
-            'rxtx_base': None,
-            'share_address': False,
-            'updated_at': None,
-            'vlan': None,
-            'vpn_private_address': None,
-            'vpn_public_address': None,
-            'vpn_public_port': None,
-        }
+    # Set default attributes.
+    flavor_access_info = {
+        'flavor_id': 'flavor-id-' + uuid.uuid4().hex,
+        'tenant_id': 'tenant-id-' + uuid.uuid4().hex,
+    }
 
-        # Overwrite default attributes.
-        network_attrs.update(attrs)
-
-        return network_attrs
-
-    @staticmethod
-    def create_networks(attrs=None, count=2):
-        """Create multiple fake networks.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of networks to fake
-        :return:
-            A list of FakeResource objects faking the networks
-        """
-        networks = []
-        for i in range(0, count):
-            networks.append(FakeNetwork.create_one_network(attrs))
-
-        return networks
-
-    @staticmethod
-    def get_networks(networks=None, count=2):
-        """Get an iterable MagicMock object with a list of faked networks.
-
-        If networks list is provided, then initialize the Mock object with the
-        list. Otherwise create one.
-
-        :param List networks:
-            A list of FakeResource objects faking networks
-        :param int count:
-            The number of networks to fake
-        :return:
-            An iterable Mock object with side_effect set to a list of faked
-            networks
-        """
-        if networks is None:
-            networks = FakeNetwork.create_networks(count=count)
-        return mock.Mock(side_effect=networks)
-
-
-class FakeHost(object):
-    """Fake one host."""
-
-    @staticmethod
-    def create_one_host(attrs=None):
-        """Create a fake host.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with uuid and other attributes
-        """
-        attrs = attrs or {}
-
-        # Set default attributes.
-        host_info = {
-            "service_id": 1,
-            "host": "host1",
-            "uuid": 'host-id-' + uuid.uuid4().hex,
-            "vcpus": 10,
-            "memory_mb": 100,
-            "local_gb": 100,
-            "vcpus_used": 5,
-            "memory_mb_used": 50,
-            "local_gb_used": 10,
-            "hypervisor_type": "xen",
-            "hypervisor_version": 1,
-            "hypervisor_hostname": "devstack1",
-            "free_ram_mb": 50,
-            "free_disk_gb": 50,
-            "current_workload": 10,
-            "running_vms": 1,
-            "cpu_info": "",
-            "disk_available_least": 1,
-            "host_ip": "10.10.10.10",
-            "supported_instances": "",
-            "metrics": "",
-            "pci_stats": "",
-            "extra_resources": "",
-            "stats": "",
-            "numa_topology": "",
-            "ram_allocation_ratio": 1.0,
-            "cpu_allocation_ratio": 1.0,
-            "zone": 'zone-' + uuid.uuid4().hex,
-            "host_name": 'name-' + uuid.uuid4().hex,
-            "service": 'service-' + uuid.uuid4().hex,
-            "cpu": 4,
-            "disk_gb": 100,
-            'project': 'project-' + uuid.uuid4().hex,
-        }
-        host_info.update(attrs)
-        return host_info
-
-
-class FakeUsage(object):
-    """Fake one or more usage."""
-
-    @staticmethod
-    def create_one_usage(attrs=None):
-        """Create a fake usage.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :return:
-            A FakeResource object, with tenant_id and other attributes
-        """
-        if attrs is None:
-            attrs = {}
-
-        # Set default attributes.
-        usage_info = {
-            'tenant_id': 'usage-tenant-id-' + uuid.uuid4().hex,
-            'total_memory_mb_usage': 512.0,
-            'total_vcpus_usage': 1.0,
-            'total_local_gb_usage': 1.0,
-            'server_usages': [
-                {
-                    'ended_at': None,
-                    'flavor': 'usage-flavor-' + uuid.uuid4().hex,
-                    'hours': 1.0,
-                    'local_gb': 1,
-                    'memory_mb': 512,
-                    'name': 'usage-name-' + uuid.uuid4().hex,
-                    'instance_id': uuid.uuid4().hex,
-                    'state': 'active',
-                    'uptime': 3600,
-                    'vcpus': 1,
+    # Overwrite default attributes.
+    flavor_access_info.update(attrs)
+
+    flavor_access = fakes.FakeResource(
+        info=copy.deepcopy(flavor_access_info), loaded=True
+    )
+
+    return flavor_access
+
+
+def create_one_keypair(attrs=None):
+    """Create a fake keypair
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, name, fingerprint, and so on
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    keypair_info = {
+        'name': 'keypair-name-' + uuid.uuid4().hex,
+        'type': 'ssh',
+        'fingerprint': 'dummy',
+        'public_key': 'dummy',
+        'user_id': 'user',
+    }
+
+    # Overwrite default attributes.
+    keypair_info.update(attrs)
+
+    keypair = fakes.FakeResource(info=copy.deepcopy(keypair_info), loaded=True)
+
+    return keypair
+
+
+def create_keypairs(attrs=None, count=2):
+    """Create multiple fake keypairs.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of keypairs to fake
+    :return:
+        A list of FakeResource objects faking the keypairs
+    """
+
+    keypairs = []
+    for i in range(0, count):
+        keypairs.append(create_one_keypair(attrs))
+
+    return keypairs
+
+
+def get_keypairs(keypairs=None, count=2):
+    """Get an iterable MagicMock object with a list of faked keypairs.
+
+    If keypairs list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
+
+    :param List keypairs:
+        A list of FakeResource objects faking keypairs
+    :param int count:
+        The number of keypairs to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        keypairs
+    """
+    if keypairs is None:
+        keypairs = create_keypairs(count)
+    return mock.Mock(side_effect=keypairs)
+
+
+def create_one_availability_zone(attrs=None):
+    """Create a fake AZ.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object with zoneName, zoneState, etc.
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    host_name = uuid.uuid4().hex
+    service_name = uuid.uuid4().hex
+    service_updated_at = uuid.uuid4().hex
+    availability_zone = {
+        'zoneName': uuid.uuid4().hex,
+        'zoneState': {'available': True},
+        'hosts': {
+            host_name: {
+                service_name: {
+                    'available': True,
+                    'active': True,
+                    'updated_at': service_updated_at,
                 }
-            ],
-        }
+            }
+        },
+    }
 
-        # Overwrite default attributes.
-        usage_info.update(attrs)
-
-        usage = fakes.FakeResource(info=copy.deepcopy(usage_info), loaded=True)
-
-        return usage
-
-    @staticmethod
-    def create_usages(attrs=None, count=2):
-        """Create multiple fake services.
-
-        :param dict attrs:
-            A dictionary with all attributes
-        :param int count:
-            The number of services to fake
-        :return:
-            A list of FakeResource objects faking the services
-        """
-        usages = []
-        for i in range(0, count):
-            usages.append(FakeUsage.create_one_usage(attrs))
-
-        return usages
-
-
-class FakeQuota(object):
-    """Fake quota"""
-
-    @staticmethod
-    def create_one_comp_quota(attrs=None):
-        """Create one quota"""
-
-        attrs = attrs or {}
-
-        quota_attrs = {
-            'id': 'project-id-' + uuid.uuid4().hex,
-            'cores': 20,
-            'fixed_ips': 30,
-            'injected_files': 100,
-            'injected_file_content_bytes': 10240,
-            'injected_file_path_bytes': 255,
-            'instances': 50,
-            'key_pairs': 20,
-            'metadata_items': 10,
-            'ram': 51200,
-            'server_groups': 10,
-            'server_group_members': 10,
-        }
+    # Overwrite default attributes.
+    availability_zone.update(attrs)
 
-        quota_attrs.update(attrs)
-        quota = fakes.FakeResource(
-            info=copy.deepcopy(quota_attrs), loaded=True
-        )
+    availability_zone = fakes.FakeResource(
+        info=copy.deepcopy(availability_zone), loaded=True
+    )
+    return availability_zone
 
-        quota.project_id = quota_attrs['id']
-
-        return quota
-
-    @staticmethod
-    def create_one_default_comp_quota(attrs=None):
-        """Create one quota"""
-
-        attrs = attrs or {}
-
-        quota_attrs = {
-            'id': 'project-id-' + uuid.uuid4().hex,
-            'cores': 10,
-            'fixed_ips': 10,
-            'injected_files': 100,
-            'injected_file_content_bytes': 10240,
-            'injected_file_path_bytes': 255,
-            'instances': 20,
-            'key_pairs': 20,
-            'metadata_items': 10,
-            'ram': 51200,
-            'server_groups': 10,
-            'server_group_members': 10,
-        }
 
-        quota_attrs.update(attrs)
-        quota = fakes.FakeResource(
-            info=copy.deepcopy(quota_attrs), loaded=True
-        )
+def create_availability_zones(attrs=None, count=2):
+    """Create multiple fake AZs.
 
-        quota.project_id = quota_attrs['id']
-
-        return quota
-
-    @staticmethod
-    def create_one_comp_detailed_quota(attrs=None):
-        """Create one quota"""
-
-        attrs = attrs or {}
-
-        quota_attrs = {
-            'id': 'project-id-' + uuid.uuid4().hex,
-            'cores': {'reserved': 0, 'in_use': 0, 'limit': 20},
-            'fixed_ips': {'reserved': 0, 'in_use': 0, 'limit': 30},
-            'injected_files': {'reserved': 0, 'in_use': 0, 'limit': 100},
-            'injected_file_content_bytes': {
-                'reserved': 0,
-                'in_use': 0,
-                'limit': 10240,
-            },
-            'injected_file_path_bytes': {
-                'reserved': 0,
-                'in_use': 0,
-                'limit': 255,
-            },
-            'instances': {'reserved': 0, 'in_use': 0, 'limit': 50},
-            'key_pairs': {'reserved': 0, 'in_use': 0, 'limit': 20},
-            'metadata_items': {'reserved': 0, 'in_use': 0, 'limit': 10},
-            'ram': {'reserved': 0, 'in_use': 0, 'limit': 51200},
-            'server_groups': {'reserved': 0, 'in_use': 0, 'limit': 10},
-            'server_group_members': {'reserved': 0, 'in_use': 0, 'limit': 10},
-        }
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of AZs to fake
+    :return:
+        A list of FakeResource objects faking the AZs
+    """
+    availability_zones = []
+    for i in range(0, count):
+        availability_zone = create_one_availability_zone(attrs)
+        availability_zones.append(availability_zone)
 
-        quota_attrs.update(attrs)
-        quota = fakes.FakeResource(
-            info=copy.deepcopy(quota_attrs), loaded=True
-        )
+    return availability_zones
+
+
+def create_one_floating_ip(attrs=None):
+    """Create a fake floating ip.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with id, ip, and so on
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    floating_ip_attrs = {
+        'id': 'floating-ip-id-' + uuid.uuid4().hex,
+        'ip': '1.0.9.0',
+        'fixed_ip': '2.0.9.0',
+        'instance_id': 'server-id-' + uuid.uuid4().hex,
+        'pool': 'public',
+    }
+
+    # Overwrite default attributes.
+    floating_ip_attrs.update(attrs)
+
+    return floating_ip_attrs
+
+
+def create_floating_ips(attrs=None, count=2):
+    """Create multiple fake floating ips.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of floating ips to fake
+    :return:
+        A list of FakeResource objects faking the floating ips
+    """
+    floating_ips = []
+    for i in range(0, count):
+        floating_ips.append(create_one_floating_ip(attrs))
+    return floating_ips
+
+
+def get_floating_ips(floating_ips=None, count=2):
+    """Get an iterable MagicMock object with a list of faked floating ips.
+
+    If floating_ips list is provided, then initialize the Mock object
+    with the list. Otherwise create one.
+
+    :param List floating_ips:
+        A list of FakeResource objects faking floating ips
+    :param int count:
+        The number of floating ips to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        floating ips
+    """
+    if floating_ips is None:
+        floating_ips = create_floating_ips(count)
+    return mock.Mock(side_effect=floating_ips)
+
+
+def create_one_floating_ip_pool(attrs=None):
+    """Create a fake floating ip pool.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with name, etc
+    """
+    if attrs is None:
+        attrs = {}
+
+    # Set default attributes.
+    floating_ip_pool_attrs = {
+        'name': 'floating-ip-pool-name-' + uuid.uuid4().hex,
+    }
+
+    # Overwrite default attributes.
+    floating_ip_pool_attrs.update(attrs)
+
+    return floating_ip_pool_attrs
+
+
+def create_floating_ip_pools(attrs=None, count=2):
+    """Create multiple fake floating ip pools.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of floating ip pools to fake
+    :return:
+        A list of FakeResource objects faking the floating ip pools
+    """
+    floating_ip_pools = []
+    for i in range(0, count):
+        floating_ip_pools.append(create_one_floating_ip_pool(attrs))
+    return floating_ip_pools
+
+
+def create_one_network(attrs=None):
+    """Create a fake network.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with id, label, cidr and so on
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    network_attrs = {
+        'bridge': 'br100',
+        'bridge_interface': None,
+        'broadcast': '10.0.0.255',
+        'cidr': '10.0.0.0/24',
+        'cidr_v6': None,
+        'created_at': '2016-02-11T11:17:37.000000',
+        'deleted': False,
+        'deleted_at': None,
+        'dhcp_server': '10.0.0.1',
+        'dhcp_start': '10.0.0.2',
+        'dns1': '8.8.4.4',
+        'dns2': None,
+        'enable_dhcp': True,
+        'gateway': '10.0.0.1',
+        'gateway_v6': None,
+        'host': None,
+        'id': 'network-id-' + uuid.uuid4().hex,
+        'injected': False,
+        'label': 'network-label-' + uuid.uuid4().hex,
+        'mtu': None,
+        'multi_host': False,
+        'netmask': '255.255.255.0',
+        'netmask_v6': None,
+        'priority': None,
+        'project_id': 'project-id-' + uuid.uuid4().hex,
+        'rxtx_base': None,
+        'share_address': False,
+        'updated_at': None,
+        'vlan': None,
+        'vpn_private_address': None,
+        'vpn_public_address': None,
+        'vpn_public_port': None,
+    }
+
+    # Overwrite default attributes.
+    network_attrs.update(attrs)
+
+    return network_attrs
+
+
+def create_networks(attrs=None, count=2):
+    """Create multiple fake networks.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of networks to fake
+    :return:
+        A list of FakeResource objects faking the networks
+    """
+    networks = []
+    for i in range(0, count):
+        networks.append(create_one_network(attrs))
+
+    return networks
+
+
+def get_networks(networks=None, count=2):
+    """Get an iterable MagicMock object with a list of faked networks.
+
+    If networks list is provided, then initialize the Mock object with the
+    list. Otherwise create one.
+
+    :param List networks:
+        A list of FakeResource objects faking networks
+    :param int count:
+        The number of networks to fake
+    :return:
+        An iterable Mock object with side_effect set to a list of faked
+        networks
+    """
+    if networks is None:
+        networks = create_networks(count=count)
+    return mock.Mock(side_effect=networks)
+
+
+def create_one_host(attrs=None):
+    """Create a fake host.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with uuid and other attributes
+    """
+    attrs = attrs or {}
+
+    # Set default attributes.
+    host_info = {
+        "service_id": 1,
+        "host": "host1",
+        "uuid": 'host-id-' + uuid.uuid4().hex,
+        "vcpus": 10,
+        "memory_mb": 100,
+        "local_gb": 100,
+        "vcpus_used": 5,
+        "memory_mb_used": 50,
+        "local_gb_used": 10,
+        "hypervisor_type": "xen",
+        "hypervisor_version": 1,
+        "hypervisor_hostname": "devstack1",
+        "free_ram_mb": 50,
+        "free_disk_gb": 50,
+        "current_workload": 10,
+        "running_vms": 1,
+        "cpu_info": "",
+        "disk_available_least": 1,
+        "host_ip": "10.10.10.10",
+        "supported_instances": "",
+        "metrics": "",
+        "pci_stats": "",
+        "extra_resources": "",
+        "stats": "",
+        "numa_topology": "",
+        "ram_allocation_ratio": 1.0,
+        "cpu_allocation_ratio": 1.0,
+        "zone": 'zone-' + uuid.uuid4().hex,
+        "host_name": 'name-' + uuid.uuid4().hex,
+        "service": 'service-' + uuid.uuid4().hex,
+        "cpu": 4,
+        "disk_gb": 100,
+        'project': 'project-' + uuid.uuid4().hex,
+    }
+    host_info.update(attrs)
+    return host_info
+
+
+def create_one_usage(attrs=None):
+    """Create a fake usage.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :return:
+        A FakeResource object, with tenant_id and other attributes
+    """
+    if attrs is None:
+        attrs = {}
+
+    # Set default attributes.
+    usage_info = {
+        'tenant_id': 'usage-tenant-id-' + uuid.uuid4().hex,
+        'total_memory_mb_usage': 512.0,
+        'total_vcpus_usage': 1.0,
+        'total_local_gb_usage': 1.0,
+        'server_usages': [
+            {
+                'ended_at': None,
+                'flavor': 'usage-flavor-' + uuid.uuid4().hex,
+                'hours': 1.0,
+                'local_gb': 1,
+                'memory_mb': 512,
+                'name': 'usage-name-' + uuid.uuid4().hex,
+                'instance_id': uuid.uuid4().hex,
+                'state': 'active',
+                'uptime': 3600,
+                'vcpus': 1,
+            }
+        ],
+    }
+
+    # Overwrite default attributes.
+    usage_info.update(attrs)
+
+    usage = fakes.FakeResource(info=copy.deepcopy(usage_info), loaded=True)
+
+    return usage
+
+
+def create_usages(attrs=None, count=2):
+    """Create multiple fake services.
+
+    :param dict attrs:
+        A dictionary with all attributes
+    :param int count:
+        The number of services to fake
+    :return:
+        A list of FakeResource objects faking the services
+    """
+    usages = []
+    for i in range(0, count):
+        usages.append(create_one_usage(attrs))
+
+    return usages
+
+
+def create_one_comp_quota(attrs=None):
+    """Create one quota"""
+
+    attrs = attrs or {}
+
+    quota_attrs = {
+        'id': 'project-id-' + uuid.uuid4().hex,
+        'cores': 20,
+        'fixed_ips': 30,
+        'injected_files': 100,
+        'injected_file_content_bytes': 10240,
+        'injected_file_path_bytes': 255,
+        'instances': 50,
+        'key_pairs': 20,
+        'metadata_items': 10,
+        'ram': 51200,
+        'server_groups': 10,
+        'server_group_members': 10,
+    }
+
+    quota_attrs.update(attrs)
+    quota = fakes.FakeResource(info=copy.deepcopy(quota_attrs), loaded=True)
+
+    quota.project_id = quota_attrs['id']
+
+    return quota
+
+
+def create_one_default_comp_quota(attrs=None):
+    """Create one quota"""
+
+    attrs = attrs or {}
+
+    quota_attrs = {
+        'id': 'project-id-' + uuid.uuid4().hex,
+        'cores': 10,
+        'fixed_ips': 10,
+        'injected_files': 100,
+        'injected_file_content_bytes': 10240,
+        'injected_file_path_bytes': 255,
+        'instances': 20,
+        'key_pairs': 20,
+        'metadata_items': 10,
+        'ram': 51200,
+        'server_groups': 10,
+        'server_group_members': 10,
+    }
+
+    quota_attrs.update(attrs)
+    quota = fakes.FakeResource(info=copy.deepcopy(quota_attrs), loaded=True)
+
+    quota.project_id = quota_attrs['id']
+
+    return quota
+
+
+def create_one_comp_detailed_quota(attrs=None):
+    """Create one quota"""
+
+    attrs = attrs or {}
+
+    quota_attrs = {
+        'id': 'project-id-' + uuid.uuid4().hex,
+        'cores': {'reserved': 0, 'in_use': 0, 'limit': 20},
+        'fixed_ips': {'reserved': 0, 'in_use': 0, 'limit': 30},
+        'injected_files': {'reserved': 0, 'in_use': 0, 'limit': 100},
+        'injected_file_content_bytes': {
+            'reserved': 0,
+            'in_use': 0,
+            'limit': 10240,
+        },
+        'injected_file_path_bytes': {
+            'reserved': 0,
+            'in_use': 0,
+            'limit': 255,
+        },
+        'instances': {'reserved': 0, 'in_use': 0, 'limit': 50},
+        'key_pairs': {'reserved': 0, 'in_use': 0, 'limit': 20},
+        'metadata_items': {'reserved': 0, 'in_use': 0, 'limit': 10},
+        'ram': {'reserved': 0, 'in_use': 0, 'limit': 51200},
+        'server_groups': {'reserved': 0, 'in_use': 0, 'limit': 10},
+        'server_group_members': {'reserved': 0, 'in_use': 0, 'limit': 10},
+    }
+
+    quota_attrs.update(attrs)
+    quota = fakes.FakeResource(info=copy.deepcopy(quota_attrs), loaded=True)
 
-        quota.project_id = quota_attrs['id']
+    quota.project_id = quota_attrs['id']
 
-        return quota
+    return quota
 
 
 class FakeLimits(object):
diff --git a/openstackclient/tests/unit/compute/v2/test_agent.py b/openstackclient/tests/unit/compute/v2/test_agent.py
index 2a28c396..76172ae0 100644
--- a/openstackclient/tests/unit/compute/v2/test_agent.py
+++ b/openstackclient/tests/unit/compute/v2/test_agent.py
@@ -26,7 +26,7 @@ from openstackclient.tests.unit import utils as tests_utils
 class TestAgent(compute_fakes.TestComputev2):
     attr = {}
     attr['agent_id'] = 1
-    fake_agent = compute_fakes.FakeAgent.create_one_agent(attr)
+    fake_agent = compute_fakes.create_one_agent(attr)
 
     columns = (
         'agent_id',
@@ -96,7 +96,7 @@ class TestAgentCreate(TestAgent):
 
 
 class TestAgentDelete(TestAgent):
-    fake_agents = compute_fakes.FakeAgent.create_agents(count=2)
+    fake_agents = compute_fakes.create_agents(count=2)
 
     def setUp(self):
         super(TestAgentDelete, self).setUp()
@@ -172,7 +172,7 @@ class TestAgentDelete(TestAgent):
 
 
 class TestAgentList(TestAgent):
-    agents = compute_fakes.FakeAgent.create_agents(count=3)
+    agents = compute_fakes.create_agents(count=3)
     list_columns = (
         "Agent ID",
         "Hypervisor",
diff --git a/openstackclient/tests/unit/compute/v2/test_aggregate.py b/openstackclient/tests/unit/compute/v2/test_aggregate.py
index 1ed63be6..4185e64c 100644
--- a/openstackclient/tests/unit/compute/v2/test_aggregate.py
+++ b/openstackclient/tests/unit/compute/v2/test_aggregate.py
@@ -27,7 +27,7 @@ from openstackclient.tests.unit.image.v2 import fakes as image_fakes
 
 
 class TestAggregate(compute_fakes.TestComputev2):
-    fake_ag = compute_fakes.FakeAggregate.create_one_aggregate()
+    fake_ag = compute_fakes.create_one_aggregate()
 
     columns = (
         'availability_zone',
@@ -158,13 +158,13 @@ class TestAggregateCreate(TestAggregate):
 
 
 class TestAggregateDelete(TestAggregate):
-    fake_ags = compute_fakes.FakeAggregate.create_aggregates(count=2)
+    fake_ags = compute_fakes.create_aggregates(count=2)
 
     def setUp(self):
         super(TestAggregateDelete, self).setUp()
 
-        self.sdk_client.find_aggregate = (
-            compute_fakes.FakeAggregate.get_aggregates(self.fake_ags)
+        self.sdk_client.find_aggregate = compute_fakes.get_aggregates(
+            self.fake_ags
         )
         self.cmd = aggregate.DeleteAggregate(self.app, None)
 
diff --git a/openstackclient/tests/unit/compute/v2/test_console.py b/openstackclient/tests/unit/compute/v2/test_console.py
index 6026c8d2..18643dd8 100644
--- a/openstackclient/tests/unit/compute/v2/test_console.py
+++ b/openstackclient/tests/unit/compute/v2/test_console.py
@@ -33,7 +33,7 @@ class TestConsole(compute_fakes.TestComputev2):
 
 
 class TestConsoleLog(TestConsole):
-    _server = compute_fakes.FakeServer.create_one_server()
+    _server = compute_fakes.create_one_server()
 
     def setUp(self):
         super(TestConsoleLog, self).setUp()
@@ -89,7 +89,7 @@ class TestConsoleLog(TestConsole):
 
 
 class TestConsoleUrlShow(TestConsole):
-    _server = compute_fakes.FakeServer.create_one_server()
+    _server = compute_fakes.create_one_server()
 
     def setUp(self):
         super(TestConsoleUrlShow, self).setUp()
diff --git a/openstackclient/tests/unit/compute/v2/test_flavor.py b/openstackclient/tests/unit/compute/v2/test_flavor.py
index 42d6e1a9..1a12b5cd 100644
--- a/openstackclient/tests/unit/compute/v2/test_flavor.py
+++ b/openstackclient/tests/unit/compute/v2/test_flavor.py
@@ -49,9 +49,7 @@ class TestFlavor(compute_fakes.TestComputev2):
 
 
 class TestFlavorCreate(TestFlavor):
-    flavor = compute_fakes.FakeFlavor.create_one_flavor(
-        attrs={'links': 'flavor-links'}
-    )
+    flavor = compute_fakes.create_one_flavor(attrs={'links': 'flavor-links'})
     project = identity_fakes.FakeProject.create_one_project()
 
     columns = (
@@ -412,7 +410,7 @@ class TestFlavorCreate(TestFlavor):
 
 
 class TestFlavorDelete(TestFlavor):
-    flavors = compute_fakes.FakeFlavor.create_flavors(count=2)
+    flavors = compute_fakes.create_flavors(count=2)
 
     def setUp(self):
         super(TestFlavorDelete, self).setUp()
@@ -489,7 +487,7 @@ class TestFlavorDelete(TestFlavor):
 
 
 class TestFlavorList(TestFlavor):
-    _flavor = compute_fakes.FakeFlavor.create_one_flavor()
+    _flavor = compute_fakes.create_one_flavor()
 
     columns = (
         'ID',
@@ -668,9 +666,7 @@ class TestFlavorList(TestFlavor):
 
     def test_flavor_list_long_no_extra_specs(self):
         # use flavor with no extra specs for this test
-        flavor = compute_fakes.FakeFlavor.create_one_flavor(
-            attrs={"extra_specs": {}}
-        )
+        flavor = compute_fakes.create_one_flavor(attrs={"extra_specs": {}})
         self.data = (
             (
                 flavor.id,
@@ -760,7 +756,7 @@ class TestFlavorList(TestFlavor):
 
 class TestFlavorSet(TestFlavor):
     # Return value of self.sdk_client.find_flavor().
-    flavor = compute_fakes.FakeFlavor.create_one_flavor(
+    flavor = compute_fakes.create_one_flavor(
         attrs={'os-flavor-access:is_public': False}
     )
     project = identity_fakes.FakeProject.create_one_project()
@@ -982,8 +978,8 @@ class TestFlavorSet(TestFlavor):
 
 class TestFlavorShow(TestFlavor):
     # Return value of self.sdk_client.find_flavor().
-    flavor_access = compute_fakes.FakeFlavorAccess.create_one_flavor_access()
-    flavor = compute_fakes.FakeFlavor.create_one_flavor()
+    flavor_access = compute_fakes.create_one_flavor_access()
+    flavor = compute_fakes.create_one_flavor()
 
     columns = (
         'OS-FLV-DISABLED:disabled',
@@ -1054,7 +1050,7 @@ class TestFlavorShow(TestFlavor):
         self.assertCountEqual(self.data, data)
 
     def test_private_flavor_show(self):
-        private_flavor = compute_fakes.FakeFlavor.create_one_flavor(
+        private_flavor = compute_fakes.create_one_flavor(
             attrs={
                 'os-flavor-access:is_public': False,
             }
@@ -1097,7 +1093,7 @@ class TestFlavorShow(TestFlavor):
 
 class TestFlavorUnset(TestFlavor):
     # Return value of self.sdk_client.find_flavor().
-    flavor = compute_fakes.FakeFlavor.create_one_flavor(
+    flavor = compute_fakes.create_one_flavor(
         attrs={'os-flavor-access:is_public': False}
     )
     project = identity_fakes.FakeProject.create_one_project()
diff --git a/openstackclient/tests/unit/compute/v2/test_host.py b/openstackclient/tests/unit/compute/v2/test_host.py
index 464dcb47..99bf9127 100644
--- a/openstackclient/tests/unit/compute/v2/test_host.py
+++ b/openstackclient/tests/unit/compute/v2/test_host.py
@@ -34,7 +34,7 @@ class TestHost(compute_fakes.TestComputev2):
 
 @mock.patch('openstackclient.api.compute_v2.APIv2.host_list')
 class TestHostList(TestHost):
-    _host = compute_fakes.FakeHost.create_one_host()
+    _host = compute_fakes.create_one_host()
 
     def setUp(self):
         super(TestHostList, self).setUp()
@@ -92,7 +92,7 @@ class TestHostSet(TestHost):
     def setUp(self):
         super(TestHostSet, self).setUp()
 
-        self.host = compute_fakes.FakeHost.create_one_host()
+        self.host = compute_fakes.create_one_host()
 
         self.cmd = host.SetHost(self.app, None)
 
@@ -139,7 +139,7 @@ class TestHostSet(TestHost):
 
 @mock.patch('openstackclient.api.compute_v2.APIv2.host_show')
 class TestHostShow(TestHost):
-    _host = compute_fakes.FakeHost.create_one_host()
+    _host = compute_fakes.create_one_host()
 
     def setUp(self):
         super(TestHostShow, self).setUp()
diff --git a/openstackclient/tests/unit/compute/v2/test_keypair.py b/openstackclient/tests/unit/compute/v2/test_keypair.py
index 72bb96cb..f3618cef 100644
--- a/openstackclient/tests/unit/compute/v2/test_keypair.py
+++ b/openstackclient/tests/unit/compute/v2/test_keypair.py
@@ -55,7 +55,7 @@ class TestKeypairCreate(TestKeypair):
     def setUp(self):
         super().setUp()
 
-        self.keypair = compute_fakes.FakeKeypair.create_one_keypair()
+        self.keypair = compute_fakes.create_one_keypair()
 
         self.columns = ('fingerprint', 'name', 'type', 'user_id')
         self.data = (
@@ -288,7 +288,7 @@ class TestKeypairCreate(TestKeypair):
 
 
 class TestKeypairDelete(TestKeypair):
-    keypairs = compute_fakes.FakeKeypair.create_keypairs(count=2)
+    keypairs = compute_fakes.create_keypairs(count=2)
 
     def setUp(self):
         super(TestKeypairDelete, self).setUp()
@@ -394,7 +394,7 @@ class TestKeypairDelete(TestKeypair):
 
 class TestKeypairList(TestKeypair):
     # Return value of self.sdk_client.keypairs().
-    keypairs = compute_fakes.FakeKeypair.create_keypairs(count=1)
+    keypairs = compute_fakes.create_keypairs(count=1)
 
     def setUp(self):
         super(TestKeypairList, self).setUp()
@@ -661,7 +661,7 @@ class TestKeypairList(TestKeypair):
 
 
 class TestKeypairShow(TestKeypair):
-    keypair = compute_fakes.FakeKeypair.create_one_keypair()
+    keypair = compute_fakes.create_one_keypair()
 
     def setUp(self):
         super(TestKeypairShow, self).setUp()
diff --git a/openstackclient/tests/unit/compute/v2/test_server.py b/openstackclient/tests/unit/compute/v2/test_server.py
index 235e24c6..92ff5b13 100644
--- a/openstackclient/tests/unit/compute/v2/test_server.py
+++ b/openstackclient/tests/unit/compute/v2/test_server.py
@@ -141,7 +141,7 @@ class TestServer(compute_fakes.TestComputev2):
         # If we are creating more than one server, make one of them
         # boot-from-volume
         include_bfv = count > 1
-        servers = compute_fakes.FakeServer.create_servers(
+        servers = compute_fakes.create_servers(
             attrs=self.attrs,
             methods=self.methods,
             count=count - 1 if include_bfv else count,
@@ -149,19 +149,17 @@ class TestServer(compute_fakes.TestComputev2):
         if include_bfv:
             attrs = copy.deepcopy(self.attrs)
             attrs['image'] = ''
-            bfv_server = compute_fakes.FakeServer.create_one_server(
+            bfv_server = compute_fakes.create_one_server(
                 attrs=attrs, methods=self.methods
             )
             servers.append(bfv_server)
 
         # This is the return value for utils.find_resource()
-        self.servers_mock.get = compute_fakes.FakeServer.get_servers(
-            servers, 0
-        )
+        self.servers_mock.get = compute_fakes.get_servers(servers, 0)
         return servers
 
     def setup_sdk_servers_mock(self, count):
-        servers = compute_fakes.FakeServer.create_sdk_servers(
+        servers = compute_fakes.create_sdk_servers(
             attrs=self.attrs,
             methods=self.methods,
             count=count,
@@ -213,7 +211,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.return_value = False
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
 
         with mock.patch.object(
             self.app.client_manager,
@@ -244,7 +242,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.return_value = False
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
 
         with mock.patch.object(
             self.app.client_manager,
@@ -277,7 +275,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.return_value = False
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
 
         with mock.patch.object(
             self.app.client_manager,
@@ -312,7 +310,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.side_effect = [False, True]
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
 
         with mock.patch.object(
             self.app.client_manager,
@@ -347,7 +345,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.side_effect = [True, False]
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
         interface = compute_fakes.create_one_server_interface()
         self.sdk_client.create_server_interface.return_value = interface
 
@@ -393,7 +391,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.side_effect = [True, True]
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
         interface = compute_fakes.create_one_server_interface()
         self.sdk_client.create_server_interface.return_value = interface
 
@@ -449,7 +447,7 @@ class TestServerAddFixedIP(TestServer):
         sm_mock.side_effect = [True, True, True]
 
         servers = self.setup_sdk_servers_mock(count=1)
-        network = compute_fakes.FakeNetwork.create_one_network()
+        network = compute_fakes.create_one_network()
         interface = compute_fakes.create_one_server_interface()
         self.sdk_client.create_server_interface.return_value = interface
 
@@ -516,7 +514,7 @@ class TestServerAddFloatingIPCompute(compute_fakes.TestComputev2):
         self.cmd = server.AddFloatingIP(self.app, None)
 
     def test_server_add_floating_ip_default(self, fip_mock):
-        _floating_ip = compute_fakes.FakeFloatingIP.create_one_floating_ip()
+        _floating_ip = compute_fakes.create_one_floating_ip()
         arglist = [
             'server1',
             _floating_ip['ip'],
@@ -536,7 +534,7 @@ class TestServerAddFloatingIPCompute(compute_fakes.TestComputev2):
         )
 
     def test_server_add_floating_ip_fixed(self, fip_mock):
-        _floating_ip = compute_fakes.FakeFloatingIP.create_one_floating_ip()
+        _floating_ip = compute_fakes.create_one_floating_ip()
         arglist = [
             '--fixed-ip-address',
             _floating_ip['fixed_ip'],
@@ -574,7 +572,7 @@ class TestServerAddFloatingIPNetwork(
         self.cmd = server.AddFloatingIP(self.app, self.namespace)
 
     def test_server_add_floating_ip(self):
-        _server = compute_fakes.FakeServer.create_one_server()
+        _server = compute_fakes.create_one_server()
         self.servers_mock.get.return_value = _server
         _port = network_fakes.create_one_port()
         _floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
@@ -606,7 +604,7 @@ class TestServerAddFloatingIPNetwork(
         self.network.update_ip.assert_called_once_with(_floating_ip, **attrs)
 
     def test_server_add_floating_ip_no_ports(self):
-        server = compute_fakes.FakeServer.create_one_server()
+        server = compute_fakes.create_one_server()
         floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
 
         self.servers_mock.get.return_value = server
@@ -639,7 +637,7 @@ class TestServerAddFloatingIPNetwork(
         )
 
     def test_server_add_floating_ip_no_external_gateway(self, success=False):
-        _server = compute_fakes.FakeServer.create_one_server()
+        _server = compute_fakes.create_one_server()
         self.servers_mock.get.return_value = _server
         _port = network_fakes.create_one_port()
         _floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
@@ -697,7 +695,7 @@ class TestServerAddFloatingIPNetwork(
         self.test_server_add_floating_ip_no_external_gateway(success=True)
 
     def test_server_add_floating_ip_with_fixed_ip(self):
-        _server = compute_fakes.FakeServer.create_one_server()
+        _server = compute_fakes.create_one_server()
         self.servers_mock.get.return_value = _server
         _port = network_fakes.create_one_port()
         _floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
@@ -737,7 +735,7 @@ class TestServerAddFloatingIPNetwork(
         self.network.update_ip.assert_called_once_with(_floating_ip, **attrs)
 
     def test_server_add_floating_ip_with_fixed_ip_no_port_found(self):
-        _server = compute_fakes.FakeServer.create_one_server()
+        _server = compute_fakes.create_one_server()
         self.servers_mock.get.return_value = _server
         _port = network_fakes.create_one_port()
         _floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
@@ -1340,16 +1338,14 @@ class TestServerAddSecurityGroup(TestServer):
     def setUp(self):
         super(TestServerAddSecurityGroup, self).setUp()
 
-        self.security_group = (
-            compute_fakes.FakeSecurityGroup.create_one_security_group()
-        )
+        self.security_group = compute_fakes.create_one_security_group()
 
         attrs = {'security_groups': [{'name': self.security_group['id']}]}
         methods = {
             'add_security_group': None,
         }
 
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=attrs, methods=methods
         )
         # This is the return value for utils.find_resource() for server
@@ -1410,9 +1406,7 @@ class TestServerCreate(TestServer):
         attrs = {
             'networks': {},
         }
-        self.new_server = compute_fakes.FakeServer.create_one_server(
-            attrs=attrs
-        )
+        self.new_server = compute_fakes.create_one_server(attrs=attrs)
 
         # This is the return value for utils.find_resource().
         # This is for testing --wait option.
@@ -1424,7 +1418,7 @@ class TestServerCreate(TestServer):
         self.find_image_mock.return_value = self.image
         self.get_image_mock.return_value = self.image
 
-        self.flavor = compute_fakes.FakeFlavor.create_one_flavor()
+        self.flavor = compute_fakes.create_one_flavor()
         self.flavors_mock.get.return_value = self.flavor
 
         self.volume = volume_fakes.create_one_volume()
@@ -4616,7 +4610,7 @@ class TestServerDelete(TestServer):
     @mock.patch.object(common_utils, 'find_resource')
     def test_server_delete_with_all_projects(self, mock_find_resource):
         servers = self.setup_servers_mock(count=1)
-        mock_find_resource.side_effect = compute_fakes.FakeServer.get_servers(
+        mock_find_resource.side_effect = compute_fakes.get_servers(
             servers,
             0,
         )
@@ -4778,7 +4772,7 @@ class _TestServerList(TestServer):
         self.find_image_mock.return_value = self.image
         self.get_image_mock.return_value = self.image
 
-        self.flavor = compute_fakes.FakeFlavor.create_one_flavor()
+        self.flavor = compute_fakes.create_one_flavor()
         self.sdk_client.find_flavor.return_value = self.flavor
         self.attrs['flavor'] = {'original_name': self.flavor.name}
 
@@ -5650,7 +5644,7 @@ class TestServerLock(TestServer):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
 
         self.app.client_manager.sdk_connection = mock.Mock()
         self.app.client_manager.sdk_connection.compute = mock.Mock()
@@ -5698,7 +5692,7 @@ class TestServerLock(TestServer):
     @mock.patch.object(sdk_utils, 'supports_microversion')
     def test_server_lock_with_reason_multi_servers(self, sm_mock):
         sm_mock.return_value = True
-        server2 = compute_fakes.FakeServer.create_one_sdk_server()
+        server2 = compute_fakes.create_one_sdk_server()
         arglist = [
             self.server.id,
             server2.id,
@@ -5721,7 +5715,7 @@ class TestServerLock(TestServer):
     @mock.patch.object(sdk_utils, 'supports_microversion')
     def test_server_lock_with_reason_pre_v273(self, sm_mock):
         sm_mock.return_value = False
-        server = compute_fakes.FakeServer.create_one_sdk_server()
+        server = compute_fakes.create_one_sdk_server()
         arglist = [
             server.id,
             '--reason',
@@ -5751,9 +5745,7 @@ class TestServerMigrate(TestServer):
             'migrate': None,
             'live_migrate': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -6246,14 +6238,14 @@ class TestServerRebuild(TestServer):
             'networks': {},
             'adminPass': 'passw0rd',
         }
-        new_server = compute_fakes.FakeServer.create_one_server(attrs=attrs)
+        new_server = compute_fakes.create_one_server(attrs=attrs)
 
         # Fake the server to be rebuilt. The IDs of them should be the same.
         attrs['id'] = new_server.id
         methods = {
             'rebuild': new_server,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=attrs, methods=methods
         )
 
@@ -6272,7 +6264,7 @@ class TestServerRebuild(TestServer):
             'networks': {},
             'adminPass': 'passw0rd',
         }
-        new_server = compute_fakes.FakeServer.create_one_server(attrs=attrs)
+        new_server = compute_fakes.create_one_server(attrs=attrs)
         self.server.rebuild.return_value = new_server
 
         arglist = [self.server.id, '--image', image_name]
@@ -6833,14 +6825,14 @@ class TestServerRebuildVolumeBacked(TestServer):
             'networks': {},
             'adminPass': 'passw0rd',
         }
-        new_server = compute_fakes.FakeServer.create_one_server(attrs=attrs)
+        new_server = compute_fakes.create_one_server(attrs=attrs)
 
         # Fake the server to be rebuilt. The IDs of them should be the same.
         attrs['id'] = new_server.id
         methods = {
             'rebuild': new_server,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=attrs, methods=methods
         )
 
@@ -6933,14 +6925,14 @@ class TestEvacuateServer(TestServer):
             'networks': {},
             'adminPass': 'passw0rd',
         }
-        new_server = compute_fakes.FakeServer.create_one_server(attrs=attrs)
+        new_server = compute_fakes.create_one_server(attrs=attrs)
 
         # Fake the server to be rebuilt. The IDs of them should be the same.
         attrs['id'] = new_server.id
         methods = {
             'evacuate': new_server,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=attrs, methods=methods
         )
 
@@ -7123,7 +7115,7 @@ class TestServerRescue(TestServer):
         self.image = image_fakes.create_one_image()
         self.get_image_mock.return_value = self.image
 
-        new_server = compute_fakes.FakeServer.create_one_server()
+        new_server = compute_fakes.create_one_server()
         attrs = {
             'id': new_server.id,
             'image': {
@@ -7135,7 +7127,7 @@ class TestServerRescue(TestServer):
         methods = {
             'rescue': new_server,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=attrs,
             methods=methods,
         )
@@ -7212,7 +7204,7 @@ class TestServerRemoveFloatingIPCompute(compute_fakes.TestComputev2):
         self.cmd = server.RemoveFloatingIP(self.app, None)
 
     def test_server_remove_floating_ip(self, fip_mock):
-        _floating_ip = compute_fakes.FakeFloatingIP.create_one_floating_ip()
+        _floating_ip = compute_fakes.create_one_floating_ip()
 
         arglist = [
             'server1',
@@ -7244,7 +7236,7 @@ class TestServerRemoveFloatingIPNetwork(network_fakes.TestNetworkV2):
         self.cmd = server.RemoveFloatingIP(self.app, self.namespace)
 
     def test_server_remove_floating_ip_default(self):
-        _server = compute_fakes.FakeServer.create_one_server()
+        _server = compute_fakes.create_one_server()
         _floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
         self.network.find_ip = mock.Mock(return_value=_floating_ip)
         arglist = [
@@ -7377,16 +7369,14 @@ class TestServerRemoveSecurityGroup(TestServer):
     def setUp(self):
         super(TestServerRemoveSecurityGroup, self).setUp()
 
-        self.security_group = (
-            compute_fakes.FakeSecurityGroup.create_one_security_group()
-        )
+        self.security_group = compute_fakes.create_one_security_group()
 
         attrs = {'security_groups': [{'name': self.security_group['id']}]}
         methods = {
             'remove_security_group': None,
         }
 
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=attrs, methods=methods
         )
         # This is the return value for utils.find_resource() for server
@@ -7418,7 +7408,7 @@ class TestServerResize(TestServer):
     def setUp(self):
         super(TestServerResize, self).setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_server()
+        self.server = compute_fakes.create_one_server()
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -7428,9 +7418,7 @@ class TestServerResize(TestServer):
         self.servers_mock.revert_resize.return_value = None
 
         # This is the return value for utils.find_resource()
-        self.flavors_get_return_value = (
-            compute_fakes.FakeFlavor.create_one_flavor()
-        )
+        self.flavors_get_return_value = compute_fakes.create_one_flavor()
         self.flavors_mock.get.return_value = self.flavors_get_return_value
 
         # Get the command object to test
@@ -7620,9 +7608,7 @@ class TestServerResizeConfirm(TestServer):
         methods = {
             'confirm_resize': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -7655,9 +7641,7 @@ class TestServerMigrateConfirm(TestServer):
         methods = {
             'confirm_resize': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -7696,9 +7680,7 @@ class TestServerConfirmMigration(TestServerResizeConfirm):
         methods = {
             'confirm_resize': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -7730,9 +7712,7 @@ class TestServerResizeRevert(TestServer):
         methods = {
             'revert_resize': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -7765,9 +7745,7 @@ class TestServerMigrateRevert(TestServer):
         methods = {
             'revert_resize': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -7806,9 +7784,7 @@ class TestServerRevertMigration(TestServer):
         methods = {
             'revert_resize': None,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
-            methods=methods
-        )
+        self.server = compute_fakes.create_one_server(methods=methods)
 
         # This is the return value for utils.find_resource()
         self.servers_mock.get.return_value = self.server
@@ -8143,7 +8119,7 @@ class TestServerShelve(TestServer):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server(
+        self.server = compute_fakes.create_one_sdk_server(
             attrs={'status': 'ACTIVE'},
         )
 
@@ -8261,7 +8237,7 @@ class TestServerShow(TestServer):
         super(TestServerShow, self).setUp()
 
         self.image = image_fakes.create_one_image()
-        self.flavor = compute_fakes.FakeFlavor.create_one_flavor()
+        self.flavor = compute_fakes.create_one_flavor()
         self.topology = {
             'nodes': [{'vcpu_set': [0, 1]}, {'vcpu_set': [2, 3]}],
             'pagesize_kb': None,
@@ -8276,7 +8252,7 @@ class TestServerShow(TestServer):
         server_method = {
             'fetch_topology': self.topology,
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=server_info, methods=server_method
         )
 
@@ -8450,7 +8426,7 @@ class TestServerSsh(TestServer):
                 ],
             },
         }
-        self.server = compute_fakes.FakeServer.create_one_server(
+        self.server = compute_fakes.create_one_server(
             attrs=self.attrs,
             methods=self.methods,
         )
@@ -8799,7 +8775,7 @@ class TestServerUnshelve(TestServer):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server(
+        self.server = compute_fakes.create_one_sdk_server(
             attrs={'status': 'SHELVED'},
         )
 
@@ -9115,7 +9091,7 @@ class TestServerGeneral(TestServer):
         # - The second time, return image info.
         # - The third time, return flavor info.
         _image = image_fakes.create_one_image()
-        _flavor = compute_fakes.FakeFlavor.create_one_flavor()
+        _flavor = compute_fakes.create_one_flavor()
         server_info = {
             'image': {u'id': _image.id},
             'flavor': {u'id': _flavor.id},
@@ -9125,7 +9101,7 @@ class TestServerGeneral(TestServer):
             'properties': '',
             'volumes_attached': [{"id": "6344fe9d-ef20-45b2-91a6"}],
         }
-        _server = compute_fakes.FakeServer.create_one_server(attrs=server_info)
+        _server = compute_fakes.create_one_server(attrs=server_info)
         find_resource.side_effect = [_server, _flavor]
         self.get_image_mock.return_value = _image
 
diff --git a/openstackclient/tests/unit/compute/v2/test_server_backup.py b/openstackclient/tests/unit/compute/v2/test_server_backup.py
index 6a5da4a6..0bbc77c8 100644
--- a/openstackclient/tests/unit/compute/v2/test_server_backup.py
+++ b/openstackclient/tests/unit/compute/v2/test_server_backup.py
@@ -42,14 +42,14 @@ class TestServerBackup(compute_fakes.TestComputev2):
         self.methods = {}
 
     def setup_servers_mock(self, count):
-        servers = compute_fakes.FakeServer.create_sdk_servers(
+        servers = compute_fakes.create_sdk_servers(
             attrs=self.attrs,
             methods=self.methods,
             count=count,
         )
 
         # This is the return value for compute_client.find_server()
-        self.sdk_client.find_server = compute_fakes.FakeServer.get_servers(
+        self.sdk_client.find_server = compute_fakes.get_servers(
             servers,
             0,
         )
diff --git a/openstackclient/tests/unit/compute/v2/test_server_event.py b/openstackclient/tests/unit/compute/v2/test_server_event.py
index d151eda5..018a6061 100644
--- a/openstackclient/tests/unit/compute/v2/test_server_event.py
+++ b/openstackclient/tests/unit/compute/v2/test_server_event.py
@@ -24,7 +24,7 @@ from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes
 
 
 class TestServerEvent(compute_fakes.TestComputev2):
-    fake_server = compute_fakes.FakeServer.create_one_server()
+    fake_server = compute_fakes.create_one_server()
 
     def setUp(self):
         super(TestServerEvent, self).setUp()
diff --git a/openstackclient/tests/unit/compute/v2/test_server_image.py b/openstackclient/tests/unit/compute/v2/test_server_image.py
index 8a27b481..f231be4c 100644
--- a/openstackclient/tests/unit/compute/v2/test_server_image.py
+++ b/openstackclient/tests/unit/compute/v2/test_server_image.py
@@ -41,14 +41,14 @@ class TestServerImage(compute_fakes.TestComputev2):
         self.methods = {}
 
     def setup_servers_mock(self, count):
-        servers = compute_fakes.FakeServer.create_sdk_servers(
+        servers = compute_fakes.create_sdk_servers(
             attrs=self.attrs,
             methods=self.methods,
             count=count,
         )
 
         # This is the return value for compute_client.find_server()
-        self.sdk_client.find_server = compute_fakes.FakeServer.get_servers(
+        self.sdk_client.find_server = compute_fakes.get_servers(
             servers,
             0,
         )
diff --git a/openstackclient/tests/unit/compute/v2/test_server_migration.py b/openstackclient/tests/unit/compute/v2/test_server_migration.py
index 58c2e7b2..47174713 100644
--- a/openstackclient/tests/unit/compute/v2/test_server_migration.py
+++ b/openstackclient/tests/unit/compute/v2/test_server_migration.py
@@ -91,7 +91,7 @@ class TestListMigration(TestServerMigration):
 
         self._set_mock_microversion('2.1')
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
         self.sdk_client.find_server.return_value = self.server
 
         self.migrations = compute_fakes.create_migrations(count=3)
@@ -724,7 +724,7 @@ class TestServerMigrationShow(TestServerMigration):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
         self.sdk_client.find_server.return_value = self.server
 
         self.server_migration = compute_fakes.create_one_server_migration()
@@ -924,7 +924,7 @@ class TestServerMigrationAbort(TestServerMigration):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
 
         # Return value for utils.find_resource for server.
         self.sdk_client.find_server.return_value = self.server
@@ -1037,7 +1037,7 @@ class TestServerMigrationForceComplete(TestServerMigration):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
 
         # Return value for utils.find_resource for server.
         self.sdk_client.find_server.return_value = self.server
diff --git a/openstackclient/tests/unit/compute/v2/test_server_volume.py b/openstackclient/tests/unit/compute/v2/test_server_volume.py
index 845029f2..13283455 100644
--- a/openstackclient/tests/unit/compute/v2/test_server_volume.py
+++ b/openstackclient/tests/unit/compute/v2/test_server_volume.py
@@ -37,7 +37,7 @@ class TestServerVolumeList(TestServerVolume):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
         self.volume_attachments = compute_fakes.create_volume_attachments()
 
         self.compute_client.find_server.return_value = self.server
@@ -240,7 +240,7 @@ class TestServerVolumeUpdate(TestServerVolume):
     def setUp(self):
         super().setUp()
 
-        self.server = compute_fakes.FakeServer.create_one_sdk_server()
+        self.server = compute_fakes.create_one_sdk_server()
         self.compute_client.find_server.return_value = self.server
 
         self.volume = volume_fakes.create_one_sdk_volume()
diff --git a/openstackclient/tests/unit/compute/v2/test_service.py b/openstackclient/tests/unit/compute/v2/test_service.py
index b61d9243..eb4f29d8 100644
--- a/openstackclient/tests/unit/compute/v2/test_service.py
+++ b/openstackclient/tests/unit/compute/v2/test_service.py
@@ -34,7 +34,7 @@ class TestService(compute_fakes.TestComputev2):
 
 
 class TestServiceDelete(TestService):
-    services = compute_fakes.FakeService.create_services(count=2)
+    services = compute_fakes.create_services(count=2)
 
     def setUp(self):
         super(TestServiceDelete, self).setUp()
@@ -107,7 +107,7 @@ class TestServiceDelete(TestService):
 
 
 class TestServiceList(TestService):
-    service = compute_fakes.FakeService.create_one_service()
+    service = compute_fakes.create_one_service()
 
     columns = (
         'ID',
@@ -241,7 +241,7 @@ class TestServiceSet(TestService):
     def setUp(self):
         super(TestServiceSet, self).setUp()
 
-        self.service = compute_fakes.FakeService.create_one_service()
+        self.service = compute_fakes.create_one_service()
 
         self.sdk_client.enable_service.return_value = self.service
         self.sdk_client.disable_service.return_value = self.service
diff --git a/openstackclient/tests/unit/compute/v2/test_usage.py b/openstackclient/tests/unit/compute/v2/test_usage.py
index 0915a9c7..113be0cd 100644
--- a/openstackclient/tests/unit/compute/v2/test_usage.py
+++ b/openstackclient/tests/unit/compute/v2/test_usage.py
@@ -33,7 +33,7 @@ class TestUsage(compute_fakes.TestComputev2):
 class TestUsageList(TestUsage):
     project = identity_fakes.FakeProject.create_one_project()
     # Return value of self.usage_mock.list().
-    usages = compute_fakes.FakeUsage.create_usages(
+    usages = compute_fakes.create_usages(
         attrs={'project_id': project.name}, count=1
     )
 
@@ -128,9 +128,7 @@ class TestUsageList(TestUsage):
 class TestUsageShow(TestUsage):
     project = identity_fakes.FakeProject.create_one_project()
     # Return value of self.usage_mock.list().
-    usage = compute_fakes.FakeUsage.create_one_usage(
-        attrs={'project_id': project.name}
-    )
+    usage = compute_fakes.create_one_usage(attrs={'project_id': project.name})
 
     columns = (
         'Project',
diff --git a/openstackclient/tests/unit/network/v2/test_floating_ip_compute.py b/openstackclient/tests/unit/network/v2/test_floating_ip_compute.py
index 489212be..238a2c6b 100644
--- a/openstackclient/tests/unit/network/v2/test_floating_ip_compute.py
+++ b/openstackclient/tests/unit/network/v2/test_floating_ip_compute.py
@@ -35,7 +35,7 @@ class TestFloatingIPCompute(compute_fakes.TestComputev2):
 @mock.patch('openstackclient.api.compute_v2.APIv2.floating_ip_create')
 class TestCreateFloatingIPCompute(TestFloatingIPCompute):
     # The floating ip to be deleted.
-    _floating_ip = compute_fakes.FakeFloatingIP.create_one_floating_ip()
+    _floating_ip = compute_fakes.create_one_floating_ip()
 
     columns = (
         'fixed_ip',
@@ -95,7 +95,7 @@ class TestCreateFloatingIPCompute(TestFloatingIPCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.floating_ip_delete')
 class TestDeleteFloatingIPCompute(TestFloatingIPCompute):
     # The floating ips to be deleted.
-    _floating_ips = compute_fakes.FakeFloatingIP.create_floating_ips(count=2)
+    _floating_ips = compute_fakes.create_floating_ips(count=2)
 
     def setUp(self):
         super(TestDeleteFloatingIPCompute, self).setUp()
@@ -171,7 +171,7 @@ class TestDeleteFloatingIPCompute(TestFloatingIPCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.floating_ip_list')
 class TestListFloatingIPCompute(TestFloatingIPCompute):
     # The floating ips to be list up
-    _floating_ips = compute_fakes.FakeFloatingIP.create_floating_ips(count=3)
+    _floating_ips = compute_fakes.create_floating_ips(count=3)
 
     columns = (
         'ID',
@@ -217,7 +217,7 @@ class TestListFloatingIPCompute(TestFloatingIPCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.floating_ip_find')
 class TestShowFloatingIPCompute(TestFloatingIPCompute):
     # The floating ip to display.
-    _floating_ip = compute_fakes.FakeFloatingIP.create_one_floating_ip()
+    _floating_ip = compute_fakes.create_one_floating_ip()
 
     columns = (
         'fixed_ip',
diff --git a/openstackclient/tests/unit/network/v2/test_floating_ip_pool_compute.py b/openstackclient/tests/unit/network/v2/test_floating_ip_pool_compute.py
index 2e0f75bd..6c3d4ee7 100644
--- a/openstackclient/tests/unit/network/v2/test_floating_ip_pool_compute.py
+++ b/openstackclient/tests/unit/network/v2/test_floating_ip_pool_compute.py
@@ -31,9 +31,7 @@ class TestFloatingIPPoolCompute(compute_fakes.TestComputev2):
 @mock.patch('openstackclient.api.compute_v2.APIv2.floating_ip_pool_list')
 class TestListFloatingIPPoolCompute(TestFloatingIPPoolCompute):
     # The floating ip pools to list up
-    _floating_ip_pools = (
-        compute_fakes.FakeFloatingIPPool.create_floating_ip_pools(count=3)
-    )
+    _floating_ip_pools = compute_fakes.create_floating_ip_pools(count=3)
 
     columns = ('Name',)
 
diff --git a/openstackclient/tests/unit/network/v2/test_network_compute.py b/openstackclient/tests/unit/network/v2/test_network_compute.py
index ffa82f5d..ada1d723 100644
--- a/openstackclient/tests/unit/network/v2/test_network_compute.py
+++ b/openstackclient/tests/unit/network/v2/test_network_compute.py
@@ -34,7 +34,7 @@ class TestNetworkCompute(compute_fakes.TestComputev2):
 @mock.patch('openstackclient.api.compute_v2.APIv2.network_create')
 class TestCreateNetworkCompute(TestNetworkCompute):
     # The network to create.
-    _network = compute_fakes.FakeNetwork.create_one_network()
+    _network = compute_fakes.create_one_network()
 
     columns = (
         'bridge',
@@ -179,10 +179,10 @@ class TestDeleteNetworkCompute(TestNetworkCompute):
         self.app.client_manager.network_endpoint_enabled = False
 
         # The networks to delete
-        self._networks = compute_fakes.FakeNetwork.create_networks(count=3)
+        self._networks = compute_fakes.create_networks(count=3)
 
         # Return value of utils.find_resource()
-        self.compute.api.network_find = compute_fakes.FakeNetwork.get_networks(
+        self.compute.api.network_find = compute_fakes.get_networks(
             networks=self._networks
         )
 
@@ -254,7 +254,7 @@ class TestDeleteNetworkCompute(TestNetworkCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.network_list')
 class TestListNetworkCompute(TestNetworkCompute):
     # The networks going to be listed up.
-    _networks = compute_fakes.FakeNetwork.create_networks(count=3)
+    _networks = compute_fakes.create_networks(count=3)
 
     columns = (
         'ID',
@@ -299,7 +299,7 @@ class TestListNetworkCompute(TestNetworkCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.network_find')
 class TestShowNetworkCompute(TestNetworkCompute):
     # The network to show.
-    _network = compute_fakes.FakeNetwork.create_one_network()
+    _network = compute_fakes.create_one_network()
 
     columns = (
         'bridge',
diff --git a/openstackclient/tests/unit/network/v2/test_port.py b/openstackclient/tests/unit/network/v2/test_port.py
index 0f6bb9c3..78ac6635 100644
--- a/openstackclient/tests/unit/network/v2/test_port.py
+++ b/openstackclient/tests/unit/network/v2/test_port.py
@@ -1113,7 +1113,7 @@ class TestListPort(TestPort):
 
     @mock.patch.object(utils, 'find_resource')
     def test_port_list_with_server_option(self, mock_find):
-        fake_server = compute_fakes.FakeServer.create_one_server()
+        fake_server = compute_fakes.create_one_server()
         mock_find.return_value = fake_server
 
         arglist = [
diff --git a/openstackclient/tests/unit/network/v2/test_security_group_compute.py b/openstackclient/tests/unit/network/v2/test_security_group_compute.py
index 22e8b71b..57defbd3 100644
--- a/openstackclient/tests/unit/network/v2/test_security_group_compute.py
+++ b/openstackclient/tests/unit/network/v2/test_security_group_compute.py
@@ -36,9 +36,7 @@ class TestCreateSecurityGroupCompute(TestSecurityGroupCompute):
     domain = identity_fakes.FakeDomain.create_one_domain()
 
     # The security group to be shown.
-    _security_group = (
-        compute_fakes.FakeSecurityGroup.create_one_security_group()
-    )
+    _security_group = compute_fakes.create_one_security_group()
 
     columns = (
         'description',
@@ -114,7 +112,7 @@ class TestCreateSecurityGroupCompute(TestSecurityGroupCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.security_group_delete')
 class TestDeleteSecurityGroupCompute(TestSecurityGroupCompute):
     # The security groups to be deleted.
-    _security_groups = compute_fakes.FakeSecurityGroup.create_security_groups()
+    _security_groups = compute_fakes.create_security_groups()
 
     def setUp(self):
         super(TestDeleteSecurityGroupCompute, self).setUp()
@@ -122,9 +120,7 @@ class TestDeleteSecurityGroupCompute(TestSecurityGroupCompute):
         self.app.client_manager.network_endpoint_enabled = False
 
         self.compute.api.security_group_find = (
-            compute_fakes.FakeSecurityGroup.get_security_groups(
-                self._security_groups
-            )
+            compute_fakes.get_security_groups(self._security_groups)
         )
 
         # Get the command object to test
@@ -198,9 +194,7 @@ class TestDeleteSecurityGroupCompute(TestSecurityGroupCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.security_group_list')
 class TestListSecurityGroupCompute(TestSecurityGroupCompute):
     # The security group to be listed.
-    _security_groups = compute_fakes.FakeSecurityGroup.create_security_groups(
-        count=3
-    )
+    _security_groups = compute_fakes.create_security_groups(count=3)
 
     columns = (
         'ID',
@@ -278,9 +272,7 @@ class TestListSecurityGroupCompute(TestSecurityGroupCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.security_group_set')
 class TestSetSecurityGroupCompute(TestSecurityGroupCompute):
     # The security group to be set.
-    _security_group = (
-        compute_fakes.FakeSecurityGroup.create_one_security_group()
-    )
+    _security_group = compute_fakes.create_one_security_group()
 
     def setUp(self):
         super(TestSetSecurityGroupCompute, self).setUp()
@@ -347,15 +339,11 @@ class TestSetSecurityGroupCompute(TestSecurityGroupCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.security_group_find')
 class TestShowSecurityGroupCompute(TestSecurityGroupCompute):
     # The security group rule to be shown with the group.
-    _security_group_rule = (
-        compute_fakes.FakeSecurityGroupRule.create_one_security_group_rule()
-    )
+    _security_group_rule = compute_fakes.create_one_security_group_rule()
 
     # The security group to be shown.
-    _security_group = (
-        compute_fakes.FakeSecurityGroup.create_one_security_group(
-            attrs={'rules': [_security_group_rule]}
-        )
+    _security_group = compute_fakes.create_one_security_group(
+        attrs={'rules': [_security_group_rule]}
     )
 
     columns = (
diff --git a/openstackclient/tests/unit/network/v2/test_security_group_rule_compute.py b/openstackclient/tests/unit/network/v2/test_security_group_rule_compute.py
index ea4adce0..2a1609ba 100644
--- a/openstackclient/tests/unit/network/v2/test_security_group_rule_compute.py
+++ b/openstackclient/tests/unit/network/v2/test_security_group_rule_compute.py
@@ -40,15 +40,11 @@ class TestCreateSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
     _security_group_rule = None
 
     # The security group that will contain the rule created.
-    _security_group = (
-        compute_fakes.FakeSecurityGroup.create_one_security_group()
-    )
+    _security_group = compute_fakes.create_one_security_group()
 
     def _setup_security_group_rule(self, attrs=None):
         self._security_group_rule = (
-            compute_fakes.FakeSecurityGroupRule.create_one_security_group_rule(
-                attrs
-            )
+            compute_fakes.create_one_security_group_rule(attrs)
         )
         (
             expected_columns,
@@ -311,11 +307,7 @@ class TestCreateSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
 @mock.patch('openstackclient.api.compute_v2.APIv2.security_group_rule_delete')
 class TestDeleteSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
     # The security group rule to be deleted.
-    _security_group_rules = (
-        compute_fakes.FakeSecurityGroupRule.create_security_group_rules(
-            count=2
-        )
-    )
+    _security_group_rules = compute_fakes.create_security_group_rules(count=2)
 
     def setUp(self):
         super(TestDeleteSecurityGroupRuleCompute, self).setUp()
@@ -383,33 +375,27 @@ class TestDeleteSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
 
 class TestListSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
     # The security group to hold the rules.
-    _security_group = (
-        compute_fakes.FakeSecurityGroup.create_one_security_group()
-    )
+    _security_group = compute_fakes.create_one_security_group()
 
     # The security group rule to be listed.
-    _security_group_rule_tcp = (
-        compute_fakes.FakeSecurityGroupRule.create_one_security_group_rule(
-            {
-                'ip_protocol': 'tcp',
-                'ethertype': 'IPv4',
-                'from_port': 80,
-                'to_port': 80,
-                'group': {'name': _security_group['name']},
-            }
-        )
+    _security_group_rule_tcp = compute_fakes.create_one_security_group_rule(
+        {
+            'ip_protocol': 'tcp',
+            'ethertype': 'IPv4',
+            'from_port': 80,
+            'to_port': 80,
+            'group': {'name': _security_group['name']},
+        }
     )
-    _security_group_rule_icmp = (
-        compute_fakes.FakeSecurityGroupRule.create_one_security_group_rule(
-            {
-                'ip_protocol': 'icmp',
-                'ethertype': 'IPv4',
-                'from_port': -1,
-                'to_port': -1,
-                'ip_range': {'cidr': '10.0.2.0/24'},
-                'group': {'name': _security_group['name']},
-            }
-        )
+    _security_group_rule_icmp = compute_fakes.create_one_security_group_rule(
+        {
+            'ip_protocol': 'icmp',
+            'ethertype': 'IPv4',
+            'from_port': -1,
+            'to_port': -1,
+            'ip_range': {'cidr': '10.0.2.0/24'},
+            'group': {'name': _security_group['name']},
+        }
     )
     _security_group['rules'] = [
         _security_group_rule_tcp,
@@ -525,9 +511,7 @@ class TestListSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
 
 class TestShowSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
     # The security group rule to be shown.
-    _security_group_rule = (
-        compute_fakes.FakeSecurityGroupRule.create_one_security_group_rule()
-    )
+    _security_group_rule = compute_fakes.create_one_security_group_rule()
 
     columns, data = security_group_rule._format_security_group_rule_show(
         _security_group_rule
diff --git a/openstackclient/tests/unit/volume/v3/test_volume_attachment.py b/openstackclient/tests/unit/volume/v3/test_volume_attachment.py
index 783f4552..73f0e1a8 100644
--- a/openstackclient/tests/unit/volume/v3/test_volume_attachment.py
+++ b/openstackclient/tests/unit/volume/v3/test_volume_attachment.py
@@ -41,7 +41,7 @@ class TestVolumeAttachment(volume_fakes.TestVolume):
 
 class TestVolumeAttachmentCreate(TestVolumeAttachment):
     volume = volume_fakes.create_one_volume()
-    server = compute_fakes.FakeServer.create_one_server()
+    server = compute_fakes.create_one_server()
     volume_attachment = volume_fakes.create_one_volume_attachment(
         attrs={'instance': server.id, 'volume_id': volume.id},
     )