diff --git a/xos/synchronizer/model_policies/model_policy_vsgtenant.py b/xos/synchronizer/model_policies/model_policy_vsgserviceinstance.py
similarity index 62%
rename from xos/synchronizer/model_policies/model_policy_vsgtenant.py
rename to xos/synchronizer/model_policies/model_policy_vsgserviceinstance.py
index 33b8877..e5a0562 100644
--- a/xos/synchronizer/model_policies/model_policy_vsgtenant.py
+++ b/xos/synchronizer/model_policies/model_policy_vsgserviceinstance.py
@@ -18,56 +18,56 @@
 from synchronizers.new_base.model_policies.model_policy_tenantwithcontainer import TenantWithContainerPolicy, LeastLoadedNodeScheduler
 from synchronizers.new_base.exceptions import *
 
-class VSGTenantPolicy(TenantWithContainerPolicy):
-    model_name = "VSGTenant"
+class VSGServiceInstancePolicy(TenantWithContainerPolicy):
+    model_name = "VSGServiceInstance"
 
-    def handle_create(self, tenant):
-        return self.handle_update(tenant)
+    def handle_create(self, service_instance):
+        return self.handle_update(service_instance)
 
-    def handle_update(self, tenant):
-        if (tenant.link_deleted_count>0) and (not tenant.provided_links.exists()):
+    def handle_update(self, service_instance):
+        if (service_instance.link_deleted_count>0) and (not service_instance.provided_links.exists()):
             # if the last provided_link has just gone away, then self-destruct
-            self.logger.info("The last provided link has been deleted -- self-destructing.");
+            self.logger.info("The last provided link has been deleted -- self-destructing.")
             # TODO: We shouldn't have to call handle_delete ourselves. The model policy framework should handle this
-            #       for us, but it isn't. I think that's happening is that tenant.delete() isn't setting a new
+            #       for us, but it isn't. I think that's happening is that serviceinstance.delete() isn't setting a new
             #       updated timestamp, since there's no way to pass `always_update_timestamp`, and therefore the
             #       policy framework doesn't know that the object has changed and needs new policies. For now, the
             #       workaround is to just call handle_delete ourselves.
-            self.handle_delete(tenant)
-            # Note that if we deleted the Instance in handle_delete, then django may have cascade-deleted the tenant
-            # by now. Thus we have to guard our delete, to check that the tenant still exists.
-            if VSGTenant.objects.filter(id=tenant.id).exists():
-                tenant.delete()
+            self.handle_delete(service_instance)
+            # Note that if we deleted the Instance in handle_delete, then django may have cascade-deleted the service
+            # instance by now. Thus we have to guard our delete, to check that the service instance still exists.
+            if VSGServiceInstance.objects.filter(id=service_instance.id).exists():
+                service_instance.delete()
             else:
-                self.logger.info("Tenant %s is already deleted" % tenant)
+                self.logger.info("Tenant %s is already deleted" % service_instance)
             return
 
-        self.manage_container(tenant)
-        self.manage_address_service_instance(tenant)
-        self.cleanup_orphans(tenant)
+        self.manage_container(service_instance)
+        self.manage_address_service_instance(service_instance)
+        self.cleanup_orphans(service_instance)
 
-    def handle_delete(self, tenant):
-        if tenant.instance and (not tenant.instance.deleted):
-            all_tenants_this_instance = VSGTenant.objects.filter(instance_id=tenant.instance.id)
-            other_tenants_this_instance = [x for x in all_tenants_this_instance if x.id != tenant.id]
-            if (not other_tenants_this_instance):
-                self.logger.info("VSG Instance %s is now unused -- deleting" % tenant.instance)
-                self.delete_instance(tenant, tenant.instance)
+    def handle_delete(self, service_instance):
+        if service_instance.instance and (not service_instance.instance.deleted):
+            all_service_instances_this_instance = VSGServiceInstance.objects.filter(instance_id=service_instance.instance.id)
+            other_service_instances_this_instance = [x for x in all_service_instances_this_instance if x.id != service_instance.id]
+            if (not other_service_instances_this_instance):
+                self.logger.info("VSG Instance %s is now unused -- deleting" % service_instance.instance)
+                self.delete_instance(service_instance, service_instance.instance)
             else:
-                self.logger.info("VSG Instance %s has %d other service instances attached" % (tenant.instance, len(other_tenants_this_instance)))
+                self.logger.info("VSG Instance %s has %d other service instances attached" % (service_instance.instance, len(other_service_instances_this_instance)))
 
-    def manage_address_service_instance(self, tenant):
-        if tenant.deleted:
+    def manage_address_service_instance(self, service_instance):
+        if service_instance.deleted:
             return
 
-        if tenant.address_service_instance is None:
-            address_service_instance = self.allocate_public_service_instance(address_pool_name="addresses_vsg", subscriber_tenant=tenant)
+        if service_instance.address_service_instance is None:
+            address_service_instance = self.allocate_public_service_instance(address_pool_name="addresses_vsg", subscriber_tenant=service_instance)
             address_service_instance.save()
 
-    def cleanup_orphans(self, tenant):
+    def cleanup_orphans(self, service_instance):
         # ensure vSG only has one AddressManagerServiceInstance
-        cur_asi = tenant.address_service_instance
-        for link in tenant.subscribed_links.all():
+        cur_asi = service_instance.address_service_instance
+        for link in service_instance.subscribed_links.all():
             # TODO: hardcoded dependency
             # cast from ServiceInstance to AddressManagerServiceInstance
             asis = AddressManagerServiceInstance.objects.filter(id = link.provider_service_instance.id)
@@ -75,8 +75,8 @@
                 if (not cur_asi) or (asi.id != cur_asi.id):
                     asi.delete()
 
-    def get_vsg_service(self, tenant):
-        return VSGService.objects.get(id=tenant.owner.id)
+    def get_vsg_service(self, service_instance):
+        return VSGService.objects.get(id=service_instance.owner.id)
 
     def find_instance_for_s_tag(self, s_tag):
         tags = Tag.objects.filter(name="s_tag", value=s_tag)
@@ -85,59 +85,59 @@
 
         return None
 
-    def find_or_make_instance_for_s_tag(self, tenant, s_tag):
-        instance = self.find_instance_for_s_tag(tenant.volt.s_tag)
+    def find_or_make_instance_for_s_tag(self, service_instance):
+        instance = self.find_instance_for_s_tag(service_instance.volt.s_tag)
         if instance:
             if instance.no_sync:
                 # if no_sync is still set, then perhaps we failed while saving it and need to retry.
-                self.save_instance(tenant, instance)
+                self.save_instance(service_instance, instance)
             return instance
 
-        desired_image = self.get_image(tenant)
+        desired_image = self.get_image(service_instance)
 
         flavors = Flavor.objects.filter(name="m1.small")
         if not flavors:
             raise SynchronizerConfigurationError("No m1.small flavor")
 
-        slice = tenant.owner.slices.first()
+        slice = service_instance.owner.slices.first()
 
-        (node, parent) = LeastLoadedNodeScheduler(slice, label=self.get_vsg_service(tenant).node_label).pick()
+        (node, parent) = LeastLoadedNodeScheduler(slice, label=self.get_vsg_service(service_instance).node_label).pick()
 
         assert (slice is not None)
         assert (node is not None)
         assert (desired_image is not None)
-        assert (tenant.creator is not None)
+        assert (service_instance.creator is not None)
         assert (node.site_deployment.deployment is not None)
         assert (desired_image is not None)
 
         instance = Instance(slice=slice,
                             node=node,
                             image=desired_image,
-                            creator=tenant.creator,
+                            creator=service_instance.creator,
                             deployment=node.site_deployment.deployment,
                             flavor=flavors[0],
                             isolation=slice.default_isolation,
                             parent=parent)
 
-        self.save_instance(tenant, instance)
+        self.save_instance(service_instance, instance)
 
         return instance
 
-    def manage_container(self, tenant):
-        if tenant.deleted:
+    def manage_container(self, service_instance):
+        if service_instance.deleted:
             return
 
-        if not tenant.volt:
+        if not service_instance.volt:
             raise SynchronizerConfigurationError("This VSG container has no volt")
 
-        if tenant.instance:
+        if service_instance.instance:
             # We're good.
             return
 
-        instance = self.find_or_make_instance_for_s_tag(tenant, tenant.volt.s_tag)
-        tenant.instance = instance
+        instance = self.find_or_make_instance_for_s_tag(service_instance)
+        service_instance.instance = instance
         # TODO: possible for partial failure here?
-        tenant.save()
+        service_instance.save()
 
     def find_or_make_port(self, instance, network, **kwargs):
         port = Port.objects.filter(instance_id=instance.id, network_id=network.id)
@@ -148,8 +148,8 @@
             port.save()
         return port
 
-    def get_lan_network(self, tenant, instance):
-        slice = tenant.owner.slices.all()[0]
+    def get_lan_network(self, service_instance, instance):
+        slice = service_instance.owner.slices.all()[0]
         # there should only be one network private network, and its template should not be the management template
         lan_networks = [x for x in slice.networks.all() if
                         x.template.visibility == "private" and (not "management" in x.template.name)]
@@ -171,9 +171,9 @@
             p = NetworkParameter(parameter=pt, content_type=port.self_content_type_id, object_id=port.id, value=str(value))
             p.save()
 
-    def delete_instance(self, tenant, instance):
+    def delete_instance(self, service_instance, instance):
         # delete the `s_tag` tags
-        tags = Tag.objects.filter(service_id=tenant.owner.id, content_type=instance.self_content_type_id,
+        tags = Tag.objects.filter(service_id=service_instance.owner.id, content_type=instance.self_content_type_id,
                                   object_id=instance.id, name="s_tag")
         for tag in tags:
             tag.delete()
@@ -192,28 +192,28 @@
 
         instance.delete()
 
-    def save_instance(self, tenant, instance):
+    def save_instance(self, service_instance, instance):
         instance.volumes = "/etc/dnsmasq.d,/etc/ufw"
         instance.no_sync = True   # prevent instance from being synced until we're done with it
-        super(VSGTenantPolicy, self).save_instance(instance)
+        super(VSGServiceInstancePolicy, self).save_instance(instance)
         try:
             if instance.isolation in ["container", "container_vm"]:
                 raise Exception("Not supported")
 
             if instance.isolation in ["vm"]:
-                lan_network = self.get_lan_network(tenant, instance)
+                lan_network = self.get_lan_network(service_instance, instance)
                 port = self.find_or_make_port(instance, lan_network)
-                self.port_set_parameter(port, "c_tag", tenant.volt.c_tag)
-                self.port_set_parameter(port, "s_tag", tenant.volt.s_tag)
-                self.port_set_parameter(port, "neutron_port_name", "stag-%s" % tenant.volt.s_tag)
+                self.port_set_parameter(port, "c_tag", service_instance.volt.c_tag)
+                self.port_set_parameter(port, "s_tag", service_instance.volt.s_tag)
+                self.port_set_parameter(port, "neutron_port_name", "stag-%s" % service_instance.volt.s_tag)
                 port.save()
 
             # tag the instance with the s-tag, so we can easily find the
             # instance later
-            if tenant.volt and tenant.volt.s_tag:
-                tags = Tag.objects.filter(name="s_tag", value=tenant.volt.s_tag)
+            if service_instance.volt and service_instance.volt.s_tag:
+                tags = Tag.objects.filter(name="s_tag", value=service_instance.volt.s_tag)
                 if not tags:
-                    tag = Tag(service=tenant.owner, content_type=instance.self_content_type_id, object_id=instance.id, name="s_tag", value=str(tenant.volt.s_tag))
+                    tag = Tag(service=service_instance.owner, content_type=instance.self_content_type_id, object_id=instance.id, name="s_tag", value=str(service_instance.volt.s_tag))
                     tag.save()
 
             # VTN-CORD needs a WAN address for the VM, so that the VM can
@@ -221,15 +221,15 @@
             tags = Tag.objects.filter(content_type=instance.self_content_type_id, object_id=instance.id, name="vm_vrouter_tenant")
             if not tags:
                 address_service_instance = self.allocate_public_service_instance(address_pool_name="addresses_vsg",
-                                                                                 subscriber_service=tenant.owner)
+                                                                                 subscriber_service=service_instance.owner)
                 address_service_instance.set_attribute("tenant_for_instance_id", instance.id)
                 address_service_instance.save()
                 # TODO: potential partial failure
-                tag = Tag(service=tenant.owner, content_type=instance.self_content_type_id, object_id=instance.id, name="vm_vrouter_tenant", value="%d" % address_service_instance.id)
+                tag = Tag(service=service_instance.owner, content_type=instance.self_content_type_id, object_id=instance.id, name="vm_vrouter_tenant", value="%d" % address_service_instance.id)
                 tag.save()
 
             instance.no_sync = False   # allow the synchronizer to run now
-            super(VSGTenantPolicy, self).save_instance(instance)
+            super(VSGServiceInstancePolicy, self).save_instance(instance)
         except:
             # need to clean up any failures here
             raise
diff --git a/xos/synchronizer/model_policies/test_model_policy_vsgtenant.py b/xos/synchronizer/model_policies/test_model_policy_vsgserviceinstance.py
similarity index 87%
rename from xos/synchronizer/model_policies/test_model_policy_vsgtenant.py
rename to xos/synchronizer/model_policies/test_model_policy_vsgserviceinstance.py
index 4fb4542..365604a 100644
--- a/xos/synchronizer/model_policies/test_model_policy_vsgtenant.py
+++ b/xos/synchronizer/model_policies/test_model_policy_vsgserviceinstance.py
@@ -27,8 +27,8 @@
 import synchronizers.new_base.modelaccessor
 
 import synchronizers.new_base.model_policies.model_policy_tenantwithcontainer
-import model_policy_vsgtenant
-from model_policy_vsgtenant import VSGTenantPolicy
+import model_policy_vsgserviceinstance
+from model_policy_vsgserviceinstance import VSGServiceInstancePolicy
 from synchronizers.new_base.model_policies.model_policy_tenantwithcontainer import LeastLoadedNodeScheduler
 
 # ---------------------------------------------------------------------------------------------------------------------
@@ -227,9 +227,9 @@
     def __init__(self, **kwargs):
         super(MockVSGService, self).__init__(**kwargs)
 
-class MockVSGTenantObjects(MockObjectStore): pass
-class MockVSGTenant(MockObject):
-    objects = get_MockObjectStore("VSGTenant")
+class MockVSGServiceInstanceObjects(MockObjectStore): pass
+class MockVSGServiceInstance(MockObject):
+    objects = get_MockObjectStore("VSGServiceInstance")
     owner = None
     deleted = False
     instance = None
@@ -247,15 +247,15 @@
 
 class TestModelPolicyVsgTenant(unittest.TestCase):
     def setUp(self):
-        # Some of the functions we call have side-effects. For example, creating a VSGTenant may lead to creation of
+        # Some of the functions we call have side-effects. For example, creating a VSGServiceInstance may lead to creation of
         # tags. Ideally, this wouldn't happen, but it does. So make sure we reset the world.
         for store in AllMockObjectStores:
             store.items = []
 
-        self.policy = VSGTenantPolicy()
-        self.tenant = MockVSGTenant()
+        self.policy = VSGServiceInstancePolicy()
+        self.tenant = MockVSGServiceInstance()
         self.user = MockUser(email="testadmin@test.org")
-        self.tenant = MockVSGTenant(creator=self.user, id=1)
+        self.tenant = MockVSGServiceInstance(creator=self.user, id=1)
         self.flavor = MockFlavor(name="m1.small")
         self.npt_ctag = MockNetworkParameterType(name="c_tag", id=1)
         self.npt_stag = MockNetworkParameterType(name="s_tag", id=2)
@@ -270,32 +270,32 @@
         synchronizers.new_base.model_policies.model_policy_tenantwithcontainer.Flavor = MockFlavor
         synchronizers.new_base.model_policies.model_policy_tenantwithcontainer.Tag = MockTag
         synchronizers.new_base.model_policies.model_policy_tenantwithcontainer.Node = MockNode
-        model_policy_vsgtenant.Instance = MockInstance
-        model_policy_vsgtenant.Flavor = MockFlavor
-        model_policy_vsgtenant.Tag = MockTag
-        model_policy_vsgtenant.VSGService = MockVSGService
-        model_policy_vsgtenant.VSGTenant = MockVSGTenant
-        model_policy_vsgtenant.Node = MockNode
-        model_policy_vsgtenant.Port = MockPort
-        model_policy_vsgtenant.NetworkParameterType = MockNetworkParameterType
-        model_policy_vsgtenant.NetworkParameter = MockNetworkParameter
-        model_policy_vsgtenant.ServiceInstance = MockServiceInstance
-        model_policy_vsgtenant.AddressManagerServiceInstance = MockAddressManagerServiceInstance
+        model_policy_vsgserviceinstance.Instance = MockInstance
+        model_policy_vsgserviceinstance.Flavor = MockFlavor
+        model_policy_vsgserviceinstance.Tag = MockTag
+        model_policy_vsgserviceinstance.VSGService = MockVSGService
+        model_policy_vsgserviceinstance.VSGServiceInstance = MockVSGServiceInstance
+        model_policy_vsgserviceinstance.Node = MockNode
+        model_policy_vsgserviceinstance.Port = MockPort
+        model_policy_vsgserviceinstance.NetworkParameterType = MockNetworkParameterType
+        model_policy_vsgserviceinstance.NetworkParameter = MockNetworkParameter
+        model_policy_vsgserviceinstance.ServiceInstance = MockServiceInstance
+        model_policy_vsgserviceinstance.AddressManagerServiceInstance = MockAddressManagerServiceInstance
 
         MockTag.objects.item_list = []
 
-    @patch.object(VSGTenantPolicy, "manage_container")
-    @patch.object(VSGTenantPolicy, "manage_address_service_instance")
-    @patch.object(VSGTenantPolicy, "cleanup_orphans")
+    @patch.object(VSGServiceInstancePolicy, "manage_container")
+    @patch.object(VSGServiceInstancePolicy, "manage_address_service_instance")
+    @patch.object(VSGServiceInstancePolicy, "cleanup_orphans")
     def test_handle_create(self, cleanup_orphans, manage_address_service_instance, manage_container):
         self.policy.handle_create(self.tenant)
         manage_container.assert_called_with(self.tenant)
         manage_address_service_instance.assert_called_with(self.tenant)
         cleanup_orphans.assert_called_with(self.tenant)
 
-    @patch.object(VSGTenantPolicy, "manage_container")
-    @patch.object(VSGTenantPolicy, "manage_address_service_instance")
-    @patch.object(VSGTenantPolicy, "cleanup_orphans")
+    @patch.object(VSGServiceInstancePolicy, "manage_container")
+    @patch.object(VSGServiceInstancePolicy, "manage_address_service_instance")
+    @patch.object(VSGServiceInstancePolicy, "cleanup_orphans")
     def test_handle_update(self, cleanup_orphans, manage_address_service_instance, manage_container):
         self.policy.handle_create(self.tenant)
         manage_container.assert_called_with(self.tenant)
@@ -317,10 +317,10 @@
         self.policy.handle_delete(self.tenant)
         amsi_delete.assert_not_called()
 
-    @patch.object(MockVSGTenantObjects, "get_items")
+    @patch.object(MockVSGServiceInstanceObjects, "get_items")
     @patch.object(MockInstanceObjects, "get_items")
     @patch.object(MockInstance, "delete")
-    def test_handle_delete_cleanup_instance(self, instance_delete, instance_objects, vsgtenant_objects):
+    def test_handle_delete_cleanup_instance(self, instance_delete, instance_objects, vsgserviceinstance_objects):
         vsg_service = MockVSGService()
         instance = MockInstance(id=1)
         instance_objects.return_value = [instance]
@@ -328,14 +328,14 @@
         self.tenant.instance = instance
         self.tenant.instance_id = instance.id
         self.tenant.owner = vsg_service
-        vsgtenant_objects.return_value = [self.tenant]
+        vsgserviceinstance_objects.return_value = [self.tenant]
         self.policy.handle_delete(self.tenant)
         instance_delete.assert_called()
 
-    @patch.object(MockVSGTenantObjects, "get_items")
+    @patch.object(MockVSGServiceInstanceObjects, "get_items")
     @patch.object(MockInstanceObjects, "get_items")
     @patch.object(MockInstance, "delete")
-    def test_handle_delete_cleanup_instance_live(self, instance_delete, instance_objects, vsgtenant_objects):
+    def test_handle_delete_cleanup_instance_live(self, instance_delete, instance_objects, vsgserviceinstance_objects):
         # Make sure if an Instance still has active VSG Tenants, that we don't clean it up
         vsg_service = MockVSGService()
         instance = MockInstance(id=1)
@@ -345,13 +345,13 @@
         self.tenant.instance_id = instance.id
         self.tenant.owner = vsg_service
 
-        other_tenant = MockVSGTenant()
+        other_tenant = MockVSGServiceInstance()
         other_tenant.address_service_instance = None
         other_tenant.instance = instance
         other_tenant.instance_id = instance.id
         other_tenant.owner = vsg_service
 
-        vsgtenant_objects.return_value = [self.tenant, other_tenant]
+        vsgserviceinstance_objects.return_value = [self.tenant, other_tenant]
 
         self.policy.handle_delete(self.tenant)
         instance_delete.assert_not_called()
@@ -359,13 +359,13 @@
     @patch.object(MockServiceInstanceObjects, "get_items")
     @patch.object(MockAddressManagerServiceInstanceObjects, "get_items")
     @patch.object(MockTagObjects, "get_items")
-    @patch.object(MockVSGTenantObjects, "get_items")
+    @patch.object(MockVSGServiceInstanceObjects, "get_items")
     @patch.object(MockInstanceObjects, "get_items")
     @patch.object(MockAddressManagerServiceInstance, "delete")
     @patch.object(MockTag, "delete")
     @patch.object(MockInstance, "delete")
     def test_handle_delete_cleanup_instance_and_tags_and_stuff(self, instance_delete, tag_delete, amsi_delete,
-                                                            instance_objects, vsgtenant_objects, tag_objects,
+                                                            instance_objects, vsgserviceinstance_objects, tag_objects,
                                                             amsi_objects, si_objects):
         vsg_service = MockVSGService()
         am_instance = MockAddressManagerServiceInstance()
@@ -377,7 +377,7 @@
         self.tenant.instance = instance
         self.tenant.instance_id = instance.id
         self.tenant.owner = vsg_service
-        vsgtenant_objects.return_value = [self.tenant]
+        vsgserviceinstance_objects.return_value = [self.tenant]
         stag_tag = MockTag(service_id=self.tenant.owner.id, content_type=instance.self_content_type_id,
                        object_id=instance.id, name="s_tag")
         vrouter_tag = MockTag(service_id=self.tenant.owner.id, content_type=instance.self_content_type_id,
@@ -420,9 +420,9 @@
             self.policy.manage_container(self.tenant)
         self.assertEqual(e.exception.message, "This VSG container has no volt")
 
-    @patch.object(VSGTenantPolicy, "find_or_make_instance_for_s_tag")
-    @patch.object(MockVSGTenant, "save")
-    @patch.object(MockVSGTenant, "volt")
+    @patch.object(VSGServiceInstancePolicy, "find_or_make_instance_for_s_tag")
+    @patch.object(MockVSGServiceInstance, "save")
+    @patch.object(MockVSGServiceInstance, "volt")
     def test_manage_container_noinstance(self, volt, tenant_save, find_or_make_instance_for_s_tag):
         instance = MockInstance()
         volt.s_tag=222
@@ -432,9 +432,9 @@
         self.assertEqual(self.tenant.instance, instance)
         tenant_save.assert_called()
 
-    @patch.object(VSGTenantPolicy, "find_or_make_instance_for_s_tag")
-    @patch.object(MockVSGTenant, "save")
-    @patch.object(MockVSGTenant, "volt")
+    @patch.object(VSGServiceInstancePolicy, "find_or_make_instance_for_s_tag")
+    @patch.object(MockVSGServiceInstance, "save")
+    @patch.object(MockVSGServiceInstance, "volt")
     def test_manage_container_hasinstance(self, volt, tenant_save, find_or_make_instance_for_s_tag):
         instance = MockInstance()
         volt.s_tag=222
@@ -445,9 +445,9 @@
         self.assertEqual(self.tenant.instance, instance)
         tenant_save.assert_not_called()
 
-    @patch.object(VSGTenantPolicy, "find_or_make_instance_for_s_tag")
-    @patch.object(MockVSGTenant, "save")
-    @patch.object(MockVSGTenant, "volt")
+    @patch.object(VSGServiceInstancePolicy, "find_or_make_instance_for_s_tag")
+    @patch.object(MockVSGServiceInstance, "save")
+    @patch.object(MockVSGServiceInstance, "volt")
     def test_manage_container_deleted(self, volt, tenant_save, find_or_make_instance_for_s_tag):
         self.tenant.deleted = True
         self.policy.manage_container(self.tenant)
@@ -535,15 +535,15 @@
     @patch.object(MockNodeObjects, "get_items")
     @patch.object(MockFlavorObjects, "get_items")
     @patch.object(MockVSGServiceObjects, "get_items")
-    @patch.object(MockVSGTenant, "volt")
-    @patch.object(MockVSGTenant, "save")
-    @patch.object(VSGTenantPolicy, "get_image")
-    @patch.object(VSGTenantPolicy, "allocate_public_service_instance")
+    @patch.object(MockVSGServiceInstance, "volt")
+    @patch.object(MockVSGServiceInstance, "save")
+    @patch.object(VSGServiceInstancePolicy, "get_image")
+    @patch.object(VSGServiceInstancePolicy, "allocate_public_service_instance")
     @patch.object(LeastLoadedNodeScheduler, "pick")
     @patch.object(MockNode, "site_deployment")
     @patch.object(MockInstance, "save")
     @patch.object(MockInstance, "delete")
-    @patch.object(VSGTenantPolicy, "port_set_parameter")
+    @patch.object(VSGServiceInstancePolicy, "port_set_parameter")
     def test_find_or_make_instance_for_s_tag(self, port_set_parameter, instance_delete, instance_save, site_deployment,
                               pick, get_psi, get_image, tenant_save, volt,
                               vsgservice_objects, flavor_objects, node_objects, npt_objects):
@@ -565,7 +565,7 @@
         # done setup mocks
 
         # call the function under test
-        instance = self.policy.find_or_make_instance_for_s_tag(self.tenant, self.tenant.volt.s_tag)
+        instance = self.policy.find_or_make_instance_for_s_tag(self.tenant)
 
         # make sure Instance was created
         self.assertNotEqual(instance, None)
@@ -600,7 +600,7 @@
         # Allocate_public_service_instance should have been called
         get_psi.assert_called()
 
-    @patch.object(VSGTenantPolicy, "allocate_public_service_instance")
+    @patch.object(VSGServiceInstancePolicy, "allocate_public_service_instance")
     def test_manage_address_service_instance(self, get_psi):
         vrtenant = MockAddressManagerServiceInstance(public_ip="1.2.3.4", public_mac="01:02:03:04:05:06")
         get_psi.return_value = vrtenant