diff --git a/shade/tests/fakes.py b/shade/tests/fakes.py
index d6ab32d50..8c1ff1543 100644
--- a/shade/tests/fakes.py
+++ b/shade/tests/fakes.py
@@ -18,6 +18,7 @@ Fakes used for testing
 """
 
 import datetime
+import json
 import uuid
 
 from shade._heat import template_format
@@ -83,33 +84,45 @@ outputs:
 FAKE_TEMPLATE_CONTENT = template_format.parse(FAKE_TEMPLATE)
 
 
-def make_fake_server(server_id, name, status='ACTIVE'):
-    return {
+def make_fake_server(
+        server_id, name, status='ACTIVE', admin_pass=None,
+        addresses=None, image=None, flavor=None):
+    if addresses is None:
+        if status == 'ACTIVE':
+            addresses = {
+                "private": [
+                    {
+                        "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
+                        "version": 6,
+                        "addr": "fddb:b018:307:0:f816:3eff:fedf:b08d",
+                        "OS-EXT-IPS:type": "fixed"},
+                    {
+                        "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
+                        "version": 4,
+                        "addr": "10.1.0.9",
+                        "OS-EXT-IPS:type": "fixed"},
+                    {
+                        "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
+                        "version": 4,
+                        "addr": "172.24.5.5",
+                        "OS-EXT-IPS:type": "floating"}]}
+        else:
+            addresses = {}
+    if image is None:
+        image = {"id": "217f3ab1-03e0-4450-bf27-63d52b421e9e",
+                 "links": []}
+    if flavor is None:
+        flavor = {"id": "64",
+                  "links": []}
+
+    server = {
         "OS-EXT-STS:task_state": None,
-        "addresses": {
-            "private": [
-                {
-                    "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
-                    "version": 6,
-                    "addr": "fddb:b018:307:0:f816:3eff:fedf:b08d",
-                    "OS-EXT-IPS:type": "fixed"},
-                {
-                    "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
-                    "version": 4,
-                    "addr": "10.1.0.9",
-                    "OS-EXT-IPS:type": "fixed"},
-                {
-                    "OS-EXT-IPS-MAC:mac_addr": "fa:16:3e:df:b0:8d",
-                    "version": 4,
-                    "addr": "172.24.5.5",
-                    "OS-EXT-IPS:type": "floating"}]},
+        "addresses": addresses,
         "links": [],
-        "image": {"id": "217f3ab1-03e0-4450-bf27-63d52b421e9e",
-                  "links": []},
+        "image": image,
         "OS-EXT-STS:vm_state": "active",
         "OS-SRV-USG:launched_at": "2017-03-23T23:57:38.000000",
-        "flavor": {"id": "64",
-                   "links": []},
+        "flavor": flavor,
         "id": server_id,
         "security_groups": [{"name": "default"}],
         "user_id": "9c119f4beaaa438792ce89387362b3ad",
@@ -127,9 +140,12 @@ def make_fake_server(server_id, name, status='ACTIVE'):
         "key_name": None,
         "name": name,
         "created": "2017-03-23T23:57:12Z",
-        "tenant_id": "fdbf563e9d474696b35667254e65b45b",
+        "tenant_id": PROJECT_ID,
         "os-extended-volumes:volumes_attached": [],
         "config_drive": "True"}
+    if admin_pass:
+        server['adminPass'] = admin_pass
+    return json.loads(json.dumps(server))
 
 
 def make_fake_keypair(name):
@@ -242,38 +258,6 @@ class FakeFloatingIP(object):
         self.instance_id = instance_id
 
 
-class FakeServer(object):
-    def __init__(
-            self, id, name, status, addresses=None,
-            accessIPv4='', accessIPv6='', private_v4='',
-            private_v6='', public_v4='', public_v6='',
-            interface_ip='',
-            flavor=None, image=None, adminPass=None,
-            metadata=None):
-        self.id = id
-        self.name = name
-        self.status = status
-        if not addresses:
-            self.addresses = {}
-        else:
-            self.addresses = addresses
-        if not flavor:
-            flavor = {}
-        self.flavor = flavor
-        if not image:
-            image = {}
-        self.image = image
-        self.accessIPv4 = accessIPv4
-        self.accessIPv6 = accessIPv6
-        self.private_v4 = private_v4
-        self.public_v4 = public_v4
-        self.private_v6 = private_v6
-        self.public_v6 = public_v6
-        self.adminPass = adminPass
-        self.metadata = metadata
-        self.interface_ip = interface_ip
-
-
 class FakeServerGroup(object):
     def __init__(self, id, name, policies):
         self.id = id
@@ -354,13 +338,6 @@ class FakeNovaSecgroupRule(object):
         self.parent_group_id = parent_group_id
 
 
-class FakeKeypair(object):
-    def __init__(self, id, name, public_key):
-        self.id = id
-        self.name = name
-        self.public_key = public_key
-
-
 class FakeHypervisor(object):
     def __init__(self, id, hostname):
         self.id = id
diff --git a/shade/tests/unit/test_create_server.py b/shade/tests/unit/test_create_server.py
index 9dd813dde..4ab000aa3 100644
--- a/shade/tests/unit/test_create_server.py
+++ b/shade/tests/unit/test_create_server.py
@@ -34,7 +34,7 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that an exception when attempting to get the server instance via
         the novaclient raises an exception in create_server.
         """
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -43,7 +43,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -66,8 +66,8 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that a server error before we return or begin waiting for the
         server instance spawn raises an exception in create_server.
         """
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        error_server = fakes.FakeServer('1234', '', 'ERROR')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
+        error_server = fakes.make_fake_server('1234', '', 'ERROR')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -76,7 +76,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -87,7 +87,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(error_server).toDict()}),
+                 json={'server': error_server}),
         ])
         self.assertRaises(
             exc.OpenStackCloudException, self.cloud.create_server,
@@ -99,8 +99,8 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that a server error while waiting for the server to spawn
         raises an exception in create_server.
         """
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        error_server = fakes.FakeServer('1234', '', 'ERROR')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
+        error_server = fakes.make_fake_server('1234', '', 'ERROR')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -109,7 +109,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -120,11 +120,11 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(build_server).toDict()]}),
+                 json={'servers': [build_server]}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(error_server).toDict()]}),
+                 json={'servers': [error_server]}),
         ])
         self.assertRaises(
             exc.OpenStackCloudException,
@@ -139,7 +139,7 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that a timeout while waiting for the server to spawn raises an
         exception in create_server.
         """
-        fake_server = fakes.FakeServer('1234', '', 'BUILD')
+        fake_server = fakes.make_fake_server('1234', '', 'BUILD')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -148,7 +148,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(fake_server).toDict()},
+                 json={'server': fake_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -159,7 +159,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(fake_server).toDict()]}),
+                 json={'servers': [fake_server]}),
         ])
         self.assertRaises(
             exc.OpenStackCloudTimeout,
@@ -175,7 +175,7 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that create_server with no wait and no exception in the
         novaclient create call returns the server instance.
         """
-        fake_server = fakes.FakeServer('1234', '', 'BUILD')
+        fake_server = fakes.make_fake_server('1234', '', 'BUILD')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -184,7 +184,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(fake_server).toDict()},
+                 json={'server': fake_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -195,11 +195,12 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(fake_server).toDict()}),
+                 json={'server': fake_server}),
         ])
+        normalized = self.cloud._expand_server(
+            self.cloud._normalize_server(fake_server), False, False)
         self.assertEqual(
-            self.cloud._normalize_server(
-                meta.obj_to_munch(fake_server)),
+            normalized,
             self.cloud.create_server(
                 name='server-name',
                 image=dict(id='image-id'),
@@ -211,9 +212,10 @@ class TestCreateServer(base.RequestsMockTestCase):
         """
         Test that a server with an admin_pass passed returns the password
         """
-        fake_server = fakes.FakeServer('1234', '', 'BUILD')
-        fake_create_server = fakes.FakeServer('1234', '', 'BUILD',
-                                              adminPass='ooBootheiX0edoh')
+        admin_pass = self.getUniqueString('password')
+        fake_server = fakes.make_fake_server('1234', '', 'BUILD')
+        fake_create_server = fakes.make_fake_server(
+            '1234', '', 'BUILD', admin_pass=admin_pass)
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -222,11 +224,10 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(
-                     fake_create_server).toDict()},
+                 json={'server': fake_create_server},
                  validate=dict(
                      json={'server': {
-                         u'adminPass': 'ooBootheiX0edoh',
+                         u'adminPass': admin_pass,
                          u'flavorRef': u'flavor-id',
                          u'imageRef': u'image-id',
                          u'max_count': 1,
@@ -235,14 +236,14 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(fake_server).toDict()}),
+                 json={'server': fake_server}),
         ])
         self.assertEqual(
-            self.cloud._normalize_server(
-                meta.obj_to_munch(fake_create_server)),
+            self.cloud._normalize_server(fake_create_server)['adminPass'],
             self.cloud.create_server(
                 name='server-name', image=dict(id='image-id'),
-                flavor=dict(id='flavor-id'), admin_pass='ooBootheiX0edoh'))
+                flavor=dict(id='flavor-id'),
+                admin_pass=admin_pass)['adminPass'])
 
         self.assert_calls()
 
@@ -251,9 +252,10 @@ class TestCreateServer(base.RequestsMockTestCase):
         """
         Test that a server with an admin_pass passed returns the password
         """
-        fake_server = fakes.FakeServer('1234', '', 'BUILD')
-        fake_server_with_pass = fakes.FakeServer('1234', '', 'BUILD',
-                                                 adminPass='ooBootheiX0edoh')
+        admin_pass = self.getUniqueString('password')
+        fake_server = fakes.make_fake_server('1234', '', 'BUILD')
+        fake_server_with_pass = fakes.make_fake_server(
+            '1234', '', 'BUILD', admin_pass=admin_pass)
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -262,26 +264,24 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(
-                     fake_server_with_pass).toDict()},
+                 json={'server': fake_server_with_pass},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
                          u'imageRef': u'image-id',
                          u'max_count': 1,
                          u'min_count': 1,
-                         u'adminPass': 'ooBootheiX0edoh',
+                         u'adminPass': admin_pass,
                          u'name': u'server-name'}})),
         ])
 
         # The wait returns non-password server
-        mock_wait.return_value = self.cloud._normalize_server(
-            meta.obj_to_munch(fake_server))
+        mock_wait.return_value = self.cloud._normalize_server(fake_server)
 
         server = self.cloud.create_server(
             name='server-name', image=dict(id='image-id'),
             flavor=dict(id='flavor-id'),
-            admin_pass='ooBootheiX0edoh', wait=True)
+            admin_pass=admin_pass, wait=True)
 
         # Assert that we did wait
         self.assertTrue(mock_wait.called)
@@ -289,8 +289,7 @@ class TestCreateServer(base.RequestsMockTestCase):
         # Even with the wait, we should still get back a passworded server
         self.assertEqual(
             server['adminPass'],
-            self.cloud._normalize_server(
-                meta.obj_to_munch(fake_server_with_pass))['adminPass']
+            self.cloud._normalize_server(fake_server_with_pass)['adminPass']
         )
         self.assert_calls()
 
@@ -335,7 +334,7 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that create_server with a wait actually does the wait.
         """
         # TODO(mordred) Make this a full proper response
-        fake_server = fakes.FakeServer('1234', '', 'BUILD')
+        fake_server = fakes.make_fake_server('1234', '', 'BUILD')
 
         self.register_uris([
             dict(method='GET',
@@ -345,7 +344,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(fake_server).toDict()},
+                 json={'server': fake_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -359,7 +358,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(id='image-id'), dict(id='flavor-id'), wait=True),
 
         mock_wait.assert_called_once_with(
-            meta.obj_to_munch(fake_server),
+            fake_server,
             auto_ip=True, ips=None,
             ip_pool=None, reuse=True, timeout=180,
             nat_destination=None,
@@ -374,8 +373,9 @@ class TestCreateServer(base.RequestsMockTestCase):
         Test that create_server with a wait throws an exception if the
         server doesn't have addresses.
         """
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        fake_server = fakes.FakeServer('1234', '', 'ACTIVE')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
+        fake_server = fakes.make_fake_server(
+            '1234', '', 'ACTIVE', addresses={})
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -384,7 +384,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -395,11 +395,11 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(build_server).toDict()]}),
+                 json={'servers': [build_server]}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(fake_server).toDict()]}),
+                 json={'servers': [fake_server]}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'network', 'public', append=['v2.0', 'ports.json'],
@@ -428,8 +428,7 @@ class TestCreateServer(base.RequestsMockTestCase):
         Verify that if 'network' is supplied, and 'nics' is not, that we
         attempt to get the network for the server.
         """
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        active_server = fakes.FakeServer('1234', '', 'ACTIVE')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
         network = {
             'id': 'network-id',
             'name': 'network-name'
@@ -442,7 +441,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -454,12 +453,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(active_server).toDict()}),
-            dict(method='GET',
-                 uri=self.get_mock_url(
-                     'network', 'public', append=['v2.0', 'ports.json'],
-                     qs_elements=['device_id=1234']),
-                 json={'ports': []}),
+                 json={'server': build_server}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'network', 'public', append=['v2.0', 'networks.json']),
@@ -483,7 +477,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             'id': 'network-id',
             'name': 'network-name'
         }
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
@@ -492,7 +486,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': u'flavor-id',
@@ -504,7 +498,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()}),
+                 json={'server': build_server}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'network', 'public', append=['v2.0', 'networks.json']),
@@ -525,8 +519,8 @@ class TestCreateServer(base.RequestsMockTestCase):
         fake_image_dict = fakes.make_fake_image(image_id=image_id)
         fake_image_search_return = {'images': [fake_image_dict]}
 
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        active_server = fakes.FakeServer('1234', '', 'BUILD')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
+        active_server = fakes.make_fake_server('1234', '', 'BUILD')
 
         self.register_uris([
             dict(method='GET',
@@ -540,7 +534,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': fakes.FLAVOR_ID,
@@ -552,7 +546,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(active_server).toDict()}),
+                 json={'server': active_server}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'network', 'public', append=['v2.0', 'networks.json']),
@@ -566,8 +560,8 @@ class TestCreateServer(base.RequestsMockTestCase):
         self.assert_calls()
 
     def test_create_boot_attach_volume(self):
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        active_server = fakes.FakeServer('1234', '', 'BUILD')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
+        active_server = fakes.make_fake_server('1234', '', 'BUILD')
 
         vol = {'id': 'volume001', 'status': 'available',
                'name': '', 'attachments': []}
@@ -581,7 +575,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['os-volumes_boot']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': 'flavor-id',
@@ -608,7 +602,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(active_server).toDict()}),
+                 json={'server': active_server}),
         ])
 
         self.cloud.create_server(
@@ -622,8 +616,8 @@ class TestCreateServer(base.RequestsMockTestCase):
         self.assert_calls()
 
     def test_create_boot_from_volume_image_terminate(self):
-        build_server = fakes.FakeServer('1234', '', 'BUILD')
-        active_server = fakes.FakeServer('1234', '', 'BUILD')
+        build_server = fakes.make_fake_server('1234', '', 'BUILD')
+        active_server = fakes.make_fake_server('1234', '', 'BUILD')
 
         self.register_uris([
             dict(method='GET',
@@ -633,7 +627,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['os-volumes_boot']),
-                 json={'server': meta.obj_to_munch(build_server).toDict()},
+                 json={'server': build_server},
                  validate=dict(
                      json={'server': {
                          u'flavorRef': 'flavor-id',
@@ -651,7 +645,7 @@ class TestCreateServer(base.RequestsMockTestCase):
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234']),
-                 json={'server': meta.obj_to_munch(active_server).toDict()}),
+                 json={'server': active_server}),
         ])
 
         self.cloud.create_server(
diff --git a/shade/tests/unit/test_delete_server.py b/shade/tests/unit/test_delete_server.py
index a74432eff..bcbe0497b 100644
--- a/shade/tests/unit/test_delete_server.py
+++ b/shade/tests/unit/test_delete_server.py
@@ -18,7 +18,6 @@ Tests for the `delete_server` command.
 """
 
 from shade import exc as shade_exc
-from shade import meta
 from shade.tests import fakes
 from shade.tests.unit import base
 
@@ -29,12 +28,12 @@ class TestDeleteServer(base.RequestsMockTestCase):
         """
         Test that server delete is called when wait=False
         """
-        server = fakes.FakeServer('1234', 'daffy', 'ACTIVE')
+        server = fakes.make_fake_server('1234', 'daffy', 'ACTIVE')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(server).toDict()]}),
+                 json={'servers': [server]}),
             dict(method='DELETE',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234'])),
@@ -71,19 +70,19 @@ class TestDeleteServer(base.RequestsMockTestCase):
         """
         Test that delete_server waits for the server to be gone
         """
-        server = fakes.FakeServer('9999', 'wily', 'ACTIVE')
+        server = fakes.make_fake_server('9999', 'wily', 'ACTIVE')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(server).toDict()]}),
+                 json={'servers': [server]}),
             dict(method='DELETE',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '9999'])),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(server).toDict()]}),
+                 json={'servers': [server]}),
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
@@ -97,12 +96,12 @@ class TestDeleteServer(base.RequestsMockTestCase):
         """
         Test that delete_server raises non-404 exceptions
         """
-        server = fakes.FakeServer('1212', 'speedy', 'ACTIVE')
+        server = fakes.make_fake_server('1212', 'speedy', 'ACTIVE')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(server).toDict()]}),
+                 json={'servers': [server]}),
             dict(method='DELETE',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1212']),
@@ -128,12 +127,12 @@ class TestDeleteServer(base.RequestsMockTestCase):
             return orig_has_service(service_type)
         self.cloud.has_service = fake_has_service
 
-        server = fakes.FakeServer('1234', 'porky', 'ACTIVE')
+        server = fakes.make_fake_server('1234', 'porky', 'ACTIVE')
         self.register_uris([
             dict(method='GET',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', 'detail']),
-                 json={'servers': [meta.obj_to_munch(server).toDict()]}),
+                 json={'servers': [server]}),
             dict(method='DELETE',
                  uri=self.get_mock_url(
                      'compute', 'public', append=['servers', '1234'])),
diff --git a/shade/tests/unit/test_floating_ip_common.py b/shade/tests/unit/test_floating_ip_common.py
index d9860cf0d..638294aef 100644
--- a/shade/tests/unit/test_floating_ip_common.py
+++ b/shade/tests/unit/test_floating_ip_common.py
@@ -23,7 +23,7 @@ from mock import patch
 
 from shade import meta
 from shade import OpenStackCloud
-from shade.tests.fakes import FakeServer
+from shade.tests import fakes
 from shade.tests.unit import base
 
 
@@ -35,10 +35,10 @@ class TestFloatingIP(base.TestCase):
     def test_add_auto_ip(
             self, mock_available_floating_ip, mock_attach_ip_to_server,
             mock_get_floating_ip):
-        server = FakeServer(
-            id='server-id', name='test-server', status="ACTIVE", addresses={}
+        server_dict = fakes.make_fake_server(
+            server_id='server-id', name='test-server', status="ACTIVE",
+            addresses={}
         )
-        server_dict = meta.obj_to_munch(server)
         floating_ip_dict = {
             "id": "this-is-a-floating-ip-id",
             "fixed_ip_address": None,
@@ -59,10 +59,9 @@ class TestFloatingIP(base.TestCase):
 
     @patch.object(OpenStackCloud, '_add_ip_from_pool')
     def test_add_ips_to_server_pool(self, mock_add_ip_from_pool):
-        server = FakeServer(
-            id='romeo', name='test-server', status="ACTIVE", addresses={}
-        )
-        server_dict = meta.obj_to_munch(server)
+        server_dict = fakes.make_fake_server(
+            server_id='romeo', name='test-server', status="ACTIVE",
+            addresses={})
         pool = 'nova'
 
         self.cloud.add_ips_to_server(server_dict, ip_pool=pool)
@@ -82,8 +81,8 @@ class TestFloatingIP(base.TestCase):
         self.cloud.force_ipv4 = False
         self.cloud._local_ipv6 = True
         mock_has_service.return_value = False
-        server = FakeServer(
-            id='server-id', name='test-server', status="ACTIVE",
+        server = fakes.make_fake_server(
+            server_id='server-id', name='test-server', status="ACTIVE",
             addresses={
                 'private': [{
                     'addr': "10.223.160.141",
@@ -97,8 +96,7 @@ class TestFloatingIP(base.TestCase):
                 }]
             }
         )
-        server_dict = meta.add_server_interfaces(
-            self.cloud, meta.obj_to_munch(server))
+        server_dict = meta.add_server_interfaces(self.cloud, server)
 
         new_server = self.cloud.add_ips_to_server(server=server_dict)
         mock_get_floating_ip.assert_not_called()
@@ -122,8 +120,8 @@ class TestFloatingIP(base.TestCase):
         self.cloud.force_ipv4 = False
         self.cloud._local_ipv6 = True
         mock_has_service.return_value = False
-        server = FakeServer(
-            id='server-id', name='test-server', status="ACTIVE",
+        server = fakes.make_fake_server(
+            server_id='server-id', name='test-server', status="ACTIVE",
             addresses={
                 'private': [{
                     'addr': "10.223.160.141",
@@ -138,8 +136,7 @@ class TestFloatingIP(base.TestCase):
                 }]
             }
         )
-        server_dict = meta.add_server_interfaces(
-            self.cloud, meta.obj_to_munch(server))
+        server_dict = meta.add_server_interfaces(self.cloud, server)
 
         new_server = self.cloud.add_ips_to_server(server=server_dict)
         mock_get_floating_ip.assert_not_called()
@@ -159,8 +156,8 @@ class TestFloatingIP(base.TestCase):
         self.cloud.force_ipv4 = False
         self.cloud._local_ipv6 = False
         mock_has_service.return_value = False
-        server = FakeServer(
-            id='server-id', name='test-server', status="ACTIVE",
+        server = fakes.make_fake_server(
+            server_id='server-id', name='test-server', status="ACTIVE",
             addresses={
                 'private': [{
                     'addr': "10.223.160.141",
@@ -175,8 +172,7 @@ class TestFloatingIP(base.TestCase):
                 }]
             }
         )
-        server_dict = meta.add_server_interfaces(
-            self.cloud, meta.obj_to_munch(server))
+        server_dict = meta.add_server_interfaces(self.cloud, server)
 
         new_server = self.cloud.add_ips_to_server(server=server_dict)
         mock_get_floating_ip.assert_not_called()
@@ -185,10 +181,9 @@ class TestFloatingIP(base.TestCase):
 
     @patch.object(OpenStackCloud, 'add_ip_list')
     def test_add_ips_to_server_ip_list(self, mock_add_ip_list):
-        server = FakeServer(
-            id='server-id', name='test-server', status="ACTIVE", addresses={}
-        )
-        server_dict = meta.obj_to_munch(server)
+        server_dict = fakes.make_fake_server(
+            server_id='server-id', name='test-server', status="ACTIVE",
+            addresses={})
         ips = ['203.0.113.29', '172.24.4.229']
 
         self.cloud.add_ips_to_server(server_dict, ips=ips)
@@ -200,10 +195,9 @@ class TestFloatingIP(base.TestCase):
     @patch.object(OpenStackCloud, '_add_auto_ip')
     def test_add_ips_to_server_auto_ip(
             self, mock_add_auto_ip, mock_needs_floating_ip):
-        server = FakeServer(
-            id='server-id', name='test-server', status="ACTIVE", addresses={}
-        )
-        server_dict = meta.obj_to_munch(server)
+        server_dict = fakes.make_fake_server(
+            server_id='server-id', name='test-server', status="ACTIVE",
+            addresses={})
 
         # TODO(mordred) REMOVE THIS MOCK WHEN THE NEXT PATCH LANDS
         # SERIOUSLY THIS TIME. NEXT PATCH - WHICH SHOULD ADD MOCKS FOR
diff --git a/shade/tests/unit/test_floating_ip_neutron.py b/shade/tests/unit/test_floating_ip_neutron.py
index 5588bfcb3..555f47289 100644
--- a/shade/tests/unit/test_floating_ip_neutron.py
+++ b/shade/tests/unit/test_floating_ip_neutron.py
@@ -24,7 +24,6 @@ import datetime
 import munch
 
 from shade import exc
-from shade import meta
 from shade.tests import fakes
 from shade.tests.unit import base
 
@@ -136,15 +135,14 @@ class TestFloatingIP(base.RequestsMockTestCase):
     def setUp(self):
         super(TestFloatingIP, self).setUp()
 
-        self.fake_server = meta.obj_to_munch(
-            fakes.FakeServer(
-                'server-id', '', 'ACTIVE',
-                addresses={u'test_pnztt_net': [{
-                    u'OS-EXT-IPS:type': u'fixed',
-                    u'addr': '192.0.2.129',
-                    u'version': 4,
-                    u'OS-EXT-IPS-MAC:mac_addr':
-                    u'fa:16:3e:ae:7d:42'}]}))
+        self.fake_server = fakes.make_fake_server(
+            'server-id', '', 'ACTIVE',
+            addresses={u'test_pnztt_net': [{
+                u'OS-EXT-IPS:type': u'fixed',
+                u'addr': '192.0.2.129',
+                u'version': 4,
+                u'OS-EXT-IPS-MAC:mac_addr':
+                u'fa:16:3e:ae:7d:42'}]})
         self.floating_ip = self.cloud._normalize_floating_ips(
             self.mock_floating_ip_list_rep['floatingips'])[0]
 
diff --git a/shade/tests/unit/test_floating_ip_nova.py b/shade/tests/unit/test_floating_ip_nova.py
index 6e39f1c79..c86321b40 100644
--- a/shade/tests/unit/test_floating_ip_nova.py
+++ b/shade/tests/unit/test_floating_ip_nova.py
@@ -19,7 +19,6 @@ test_floating_ip_nova
 Tests Floating IP resource methods for nova-network
 """
 
-from shade import meta
 from shade.tests import fakes
 from shade.tests.unit import base
 
@@ -68,15 +67,14 @@ class TestFloatingIP(base.RequestsMockTestCase):
     def setUp(self):
         super(TestFloatingIP, self).setUp()
 
-        self.fake_server = meta.obj_to_munch(
-            fakes.FakeServer(
-                'server-id', '', 'ACTIVE',
-                addresses={u'test_pnztt_net': [{
-                    u'OS-EXT-IPS:type': u'fixed',
-                    u'addr': '192.0.2.129',
-                    u'version': 4,
-                    u'OS-EXT-IPS-MAC:mac_addr':
-                    u'fa:16:3e:ae:7d:42'}]}))
+        self.fake_server = fakes.make_fake_server(
+            'server-id', '', 'ACTIVE',
+            addresses={u'test_pnztt_net': [{
+                u'OS-EXT-IPS:type': u'fixed',
+                u'addr': '192.0.2.129',
+                u'version': 4,
+                u'OS-EXT-IPS-MAC:mac_addr':
+                u'fa:16:3e:ae:7d:42'}]})
 
         self.cloud.has_service = get_fake_has_service(self.cloud.has_service)
 
@@ -239,7 +237,7 @@ class TestFloatingIP(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute',
-                     append=['servers', self.fake_server.id, 'action']),
+                     append=['servers', self.fake_server['id'], 'action']),
                  validate=dict(
                      json={
                          "addFloatingIp": {
@@ -264,7 +262,7 @@ class TestFloatingIP(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute',
-                     append=['servers', self.fake_server.id, 'action']),
+                     append=['servers', self.fake_server['id'], 'action']),
                  validate=dict(
                      json={
                          "removeFloatingIp": {
@@ -287,7 +285,7 @@ class TestFloatingIP(base.RequestsMockTestCase):
             dict(method='POST',
                  uri=self.get_mock_url(
                      'compute',
-                     append=['servers', self.fake_server.id, 'action']),
+                     append=['servers', self.fake_server['id'], 'action']),
                  validate=dict(
                      json={
                          "addFloatingIp": {
diff --git a/shade/tests/unit/test_inventory.py b/shade/tests/unit/test_inventory.py
index 9a5632953..84846b231 100644
--- a/shade/tests/unit/test_inventory.py
+++ b/shade/tests/unit/test_inventory.py
@@ -18,7 +18,6 @@ from os_client_config import exceptions as occ_exc
 
 from shade import exc
 from shade import inventory
-from shade import meta
 from shade.tests import fakes
 from shade.tests.unit import base
 
@@ -101,8 +100,8 @@ class TestInventory(base.TestCase):
         inv = inventory.OpenStackInventory()
 
         server = self.cloud._normalize_server(
-            meta.obj_to_munch(fakes.FakeServer(
-                '1234', 'test', 'ACTIVE', addresses={})))
+            fakes.make_fake_server(
+                '1234', 'test', 'ACTIVE', addresses={}))
         self.assertIsInstance(inv.clouds, list)
         self.assertEqual(1, len(inv.clouds))
         inv.clouds[0].list_servers.return_value = [server]
diff --git a/shade/tests/unit/test_meta.py b/shade/tests/unit/test_meta.py
index 1b50dd37d..65c1eca57 100644
--- a/shade/tests/unit/test_meta.py
+++ b/shade/tests/unit/test_meta.py
@@ -75,11 +75,10 @@ class FakeCloud(object):
     def get_default_network(self):
         return None
 
-standard_fake_server = fakes.FakeServer(
-    id='test-id-0',
+standard_fake_server = fakes.make_fake_server(
+    server_id='test-id-0',
     name='test-id-0',
     status='ACTIVE',
-    metadata={'group': 'test-group'},
     addresses={'private': [{'OS-EXT-IPS:type': 'fixed',
                             'addr': PRIVATE_V4,
                             'version': 4}],
@@ -88,9 +87,8 @@ standard_fake_server = fakes.FakeServer(
                            'version': 4}]},
     flavor={'id': '101'},
     image={'id': '471c2475-da2f-47ac-aba5-cb4aa3d546f5'},
-    accessIPv4='',
-    accessIPv6='',
 )
+standard_fake_server['metadata'] = {'group': 'test-group'}
 
 SUBNETS_WITH_NAT = [
     {
@@ -286,15 +284,15 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'subnets': SUBNETS_WITH_NAT})
         ])
 
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'private': [{'OS-EXT-IPS:type': 'fixed',
                                     'addr': PRIVATE_V4,
                                     'version': 4}],
                        'public': [{'OS-EXT-IPS:type': 'floating',
                                    'addr': PUBLIC_V4,
                                    'version': 4}]}
-        ))
+        )
 
         self.assertEqual(
             PRIVATE_V4, meta.get_server_private_ip(srv, self.cloud))
@@ -315,8 +313,8 @@ class TestMeta(base.RequestsMockTestCase):
 
         shared_mac = '11:22:33:44:55:66'
         distinct_mac = '66:55:44:33:22:11'
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'test-net': [{'OS-EXT-IPS:type': 'fixed',
                                      'OS-EXT-IPS-MAC:mac_addr': distinct_mac,
                                      'addr': '10.0.0.100',
@@ -329,7 +327,7 @@ class TestMeta(base.RequestsMockTestCase):
                                    'OS-EXT-IPS-MAC:mac_addr': shared_mac,
                                    'addr': PUBLIC_V4,
                                    'version': 4}]}
-        ))
+        )
 
         self.assertEqual(
             '10.0.0.101', meta.get_server_private_ip(srv, self.cloud))
@@ -383,8 +381,8 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'security_groups': []})
         ])
 
-        srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             flavor={u'id': u'1'},
             image={
                 'name': u'cirros-0.3.4-x86_64-uec',
@@ -395,7 +393,7 @@ class TestMeta(base.RequestsMockTestCase):
                 u'version': 4,
                 u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'
             }]}
-        )))
+        ))
 
         self.assertEqual(PRIVATE_V4, srv['private_v4'])
         self.assert_calls()
@@ -433,8 +431,8 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'security_groups': []})
         ])
 
-        srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             flavor={u'id': u'1'},
             image={
                 'name': u'cirros-0.3.4-x86_64-uec',
@@ -445,7 +443,7 @@ class TestMeta(base.RequestsMockTestCase):
                 u'version': 4,
                 u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'
             }]}
-        )))
+        ))
 
         self.assertEqual(PRIVATE_V4, srv['private_v4'])
         self.assert_calls()
@@ -483,8 +481,8 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'security_groups': []})
         ])
 
-        srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             flavor={u'id': u'1'},
             image={
                 'name': u'cirros-0.3.4-x86_64-uec',
@@ -493,7 +491,7 @@ class TestMeta(base.RequestsMockTestCase):
                 u'addr': PRIVATE_V4,
                 u'version': 4,
             }]}
-        )))
+        ))
 
         self.assertEqual(PRIVATE_V4, srv['private_v4'])
         self.assert_calls()
@@ -551,8 +549,8 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'security_groups': []})
         ])
 
-        srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             flavor={u'id': u'1'},
             image={
                 'name': u'cirros-0.3.4-x86_64-uec',
@@ -562,7 +560,7 @@ class TestMeta(base.RequestsMockTestCase):
                 u'version': 4,
                 'OS-EXT-IPS-MAC:mac_addr': 'fa:16:3e:ae:7d:42',
             }]}
-        )))
+        ))
 
         self.assertEqual(PUBLIC_V4, srv['public_v4'])
         self.assert_calls()
@@ -588,8 +586,8 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'security_groups': []})
         ])
 
-        srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             flavor={u'id': u'1'},
             image={
                 'name': u'cirros-0.3.4-x86_64-uec',
@@ -607,7 +605,7 @@ class TestMeta(base.RequestsMockTestCase):
                     'version': 6
                 }]
             }
-        )))
+        ))
 
         self.assertEqual("10.223.160.141", srv['private_v4'])
         self.assertEqual("104.130.246.91", srv['public_v4'])
@@ -647,8 +645,8 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'security_groups': []})
         ])
 
-        srv = self.cloud.get_openstack_vars(meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = self.cloud.get_openstack_vars(fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             flavor={u'id': u'1'},
             image={
                 'name': u'cirros-0.3.4-x86_64-uec',
@@ -666,7 +664,7 @@ class TestMeta(base.RequestsMockTestCase):
                     'version': 6
                 }]
             }
-        )))
+        ))
 
         self.assertEqual("10.223.160.141", srv['private_v4'])
         self.assertEqual("104.130.246.91", srv['public_v4'])
@@ -690,12 +688,12 @@ class TestMeta(base.RequestsMockTestCase):
                  uri='https://network.example.com/v2.0/subnets.json',
                  json={'subnets': SUBNETS_WITH_NAT})
         ])
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'test-net': [{
                 'addr': PUBLIC_V4,
                 'version': 4}]},
-        ))
+        )
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertEqual(PUBLIC_V4, ip)
@@ -717,12 +715,12 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'subnets': SUBNETS_WITH_NAT})
         ])
 
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'test-net': [{
                 'addr': PUBLIC_V4,
                 'version': 4}]},
-        ))
+        )
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertEqual(PUBLIC_V4, ip)
@@ -744,12 +742,12 @@ class TestMeta(base.RequestsMockTestCase):
                  uri='https://network.example.com/v2.0/subnets.json',
                  json={'subnets': SUBNETS_WITH_NAT})
         ])
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'test-net': [{
                 'addr': PRIVATE_V4,
                 'version': 4}]},
-        ))
+        )
         self.assertIsNone(
             meta.get_server_external_ipv4(cloud=self.cloud, server=srv))
         int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv)
@@ -772,29 +770,29 @@ class TestMeta(base.RequestsMockTestCase):
                  json={'subnets': SUBNETS_WITH_NAT})
         ])
 
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'test-net': [{
                 'addr': PUBLIC_V4,
                 'version': 4}]},
-        ))
+        )
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertEqual(None, ip)
         self.assert_calls()
 
     def test_get_server_external_ipv4_neutron_accessIPv4(self):
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
-            accessIPv4=PUBLIC_V4))
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE')
+        srv['accessIPv4'] = PUBLIC_V4
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertEqual(PUBLIC_V4, ip)
 
     def test_get_server_external_ipv4_neutron_accessIPv6(self):
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
-            accessIPv6=PUBLIC_V6))
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE')
+        srv['accessIPv6'] = PUBLIC_V6
         ip = meta.get_server_external_ipv6(server=srv)
 
         self.assertEqual(PUBLIC_V6, ip)
@@ -806,10 +804,10 @@ class TestMeta(base.RequestsMockTestCase):
                  uri='https://network.example.com/v2.0/networks.json',
                  status_code=404)])
 
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]}
-        ))
+        )
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertEqual(PUBLIC_V4, ip)
@@ -819,9 +817,9 @@ class TestMeta(base.RequestsMockTestCase):
         # Testing Clouds w/o Neutron and a network named public
         self.cloud.cloud_config.config['has_network'] = False
 
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
-            addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]}))
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
+            addresses={'public': [{'addr': PUBLIC_V4, 'version': 4}]})
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertEqual(PUBLIC_V4, ip)
@@ -830,23 +828,23 @@ class TestMeta(base.RequestsMockTestCase):
         # Testing Clouds w/o Neutron or a globally routable IP
         self.cloud.cloud_config.config['has_network'] = False
 
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
-            addresses={'test-net': [{'addr': PRIVATE_V4}]}))
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
+            addresses={'test-net': [{'addr': PRIVATE_V4}]})
         ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
 
         self.assertIsNone(ip)
 
     def test_get_server_external_ipv6(self):
-        srv = meta.obj_to_munch(fakes.FakeServer(
-            id='test-id', name='test-name', status='ACTIVE',
+        srv = fakes.make_fake_server(
+            server_id='test-id', name='test-name', status='ACTIVE',
             addresses={
                 'test-net': [
                     {'addr': PUBLIC_V4, 'version': 4},
                     {'addr': PUBLIC_V6, 'version': 6}
                 ]
             }
-        ))
+        )
         ip = meta.get_server_external_ipv6(srv)
         self.assertEqual(PUBLIC_V6, ip)
 
@@ -925,10 +923,10 @@ class TestMeta(base.RequestsMockTestCase):
         self.assertEqual('admin', hostvars['location']['project']['name'])
         self.assertEqual("test-image-name", hostvars['image']['name'])
         self.assertEqual(
-            standard_fake_server.image['id'], hostvars['image']['id'])
+            standard_fake_server['image']['id'], hostvars['image']['id'])
         self.assertNotIn('links', hostvars['image'])
         self.assertEqual(
-            standard_fake_server.flavor['id'], hostvars['flavor']['id'])
+            standard_fake_server['flavor']['id'], hostvars['flavor']['id'])
         self.assertEqual("test-flavor-name", hostvars['flavor']['name'])
         self.assertNotIn('links', hostvars['flavor'])
         # test having volumes
@@ -964,14 +962,14 @@ class TestMeta(base.RequestsMockTestCase):
         mock_get_server_external_ipv4.return_value = PUBLIC_V4
 
         server = standard_fake_server
-        server.image = 'fake-image-id'
+        server['image'] = 'fake-image-id'
         hostvars = meta.get_hostvars_from_server(
             FakeCloud(), meta.obj_to_munch(server))
         self.assertEqual('fake-image-id', hostvars['image']['id'])
 
     def test_az(self):
         server = standard_fake_server
-        server.__dict__['OS-EXT-AZ:availability_zone'] = 'az1'
+        server['OS-EXT-AZ:availability_zone'] = 'az1'
 
         hostvars = self.cloud._normalize_server(meta.obj_to_munch(server))
         self.assertEqual('az1', hostvars['az'])
@@ -1036,12 +1034,12 @@ class TestMeta(base.RequestsMockTestCase):
 
     def test_obj_to_munch(self):
         cloud = FakeCloud()
-        cloud.server = standard_fake_server
+        cloud.subcloud = FakeCloud()
         cloud_dict = meta.obj_to_munch(cloud)
         self.assertEqual(FakeCloud.name, cloud_dict['name'])
         self.assertNotIn('_unused', cloud_dict)
         self.assertNotIn('get_flavor_name', cloud_dict)
-        self.assertNotIn('server', cloud_dict)
+        self.assertNotIn('subcloud', cloud_dict)
         self.assertTrue(hasattr(cloud_dict, 'name'))
         self.assertEqual(cloud_dict.name, cloud_dict['name'])
 
diff --git a/shade/tests/unit/test_security_groups.py b/shade/tests/unit/test_security_groups.py
index cad328edf..d41628f8d 100644
--- a/shade/tests/unit/test_security_groups.py
+++ b/shade/tests/unit/test_security_groups.py
@@ -617,7 +617,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
 
     def test_add_security_group_to_server_neutron(self):
         # fake to get server by name, server-name must match
-        fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE')
+        fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
 
         # use neutron for secgroup list and return an existing fake
         self.cloud.secgroup_source = 'neutron'
@@ -669,7 +669,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
 
     def test_remove_security_group_from_server_neutron(self):
         # fake to get server by name, server-name must match
-        fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE')
+        fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
 
         # use neutron for secgroup list and return an existing fake
         self.cloud.secgroup_source = 'neutron'
@@ -697,8 +697,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
 
     def test_add_bad_security_group_to_server_nova(self):
         # fake to get server by name, server-name must match
-        fake_server = meta.obj_to_munch(
-            fakes.FakeServer('1234', 'server-name', 'ACTIVE'))
+        fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
 
         # use nova for secgroup list and return an existing fake
         self.has_neutron = False
@@ -724,7 +723,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
 
     def test_add_bad_security_group_to_server_neutron(self):
         # fake to get server by name, server-name must match
-        fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE')
+        fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
 
         # use neutron for secgroup list and return an existing fake
         self.cloud.secgroup_source = 'neutron'
@@ -747,8 +746,7 @@ class TestSecurityGroups(base.RequestsMockTestCase):
 
     def test_add_security_group_to_bad_server(self):
         # fake to get server by name, server-name must match
-        fake_server = meta.obj_to_munch(
-            fakes.FakeServer('1234', 'server-name', 'ACTIVE'))
+        fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
 
         self.register_uris([
             dict(