Changed pattern on how objects lookup themselves by name and project.

The pattern being replaced has unwittingly added the requirement that
all creator credentials must be of type 'admin' as when looking up
the associated project ID required a call to keystone.projects.list().

As the SNAPS integration tests were always creating users with an 'admin'
role, this issue was not caught. As part of this patch, integration test
users will no longer be admin.

JIRA: SNAPS-274

Change-Id: I02957f69e31a9d4dfa63362d371f061687e59fbf
Signed-off-by: spisarski <s.pisarski@cablelabs.com>

10 files changed, 270 insertions, 197 deletions

diff --git a/snaps/openstack/utils/heat_utils.py b/snaps/openstack/utils/heat_utils.py
index 6e54dc6..0511ac8 100644
--- a/snaps/openstack/utils/heat_utils.py
+++ b/snaps/openstack/utils/heat_utils.py
@@ -257,14 +257,15 @@ def get_stack_security_groups(heat_cli, neutron, stack):
     return out
 
 
-def get_stack_servers(heat_cli, nova, neutron, stack, project_id):
+def get_stack_servers(heat_cli, nova, neutron, keystone, stack, project_name):
     """
     Returns a list of VMInst domain objects associated with a Stack
     :param heat_cli: the OpenStack heat client object
     :param nova: the OpenStack nova client object
     :param neutron: the OpenStack neutron client object
+    :param keystone: the OpenStack keystone client object
     :param stack: the SNAPS-OO Stack domain object
-    :param project_id: the associated project ID
+    :param project_name: the associated project ID
     :return: a list of VMInst domain objects
     """
 
@@ -273,7 +274,7 @@ def get_stack_servers(heat_cli, nova, neutron, stack, project_id):
     for resource in srvr_res:
         try:
             server = nova_utils.get_server_object_by_id(
-                nova, neutron, resource.id, project_id)
+                nova, neutron, keystone, resource.id, project_name)
             if server:
                 out.append(server)
         except NotFound:
@@ -287,7 +288,7 @@ def get_stack_servers(heat_cli, nova, neutron, stack, project_id):
                 heat_cli, res_res.id, 'OS::Nova::Server')
             for res_srvr in res_res_srvrs:
                 server = nova_utils.get_server_object_by_id(
-                    nova, neutron, res_srvr.id, project_id)
+                    nova, neutron, keystone, res_srvr.id, project_name)
                 if server:
                     out.append(server)
 
diff --git a/snaps/openstack/utils/keystone_utils.py b/snaps/openstack/utils/keystone_utils.py
index 6262d06..263f823 100644
--- a/snaps/openstack/utils/keystone_utils.py
+++ b/snaps/openstack/utils/keystone_utils.py
@@ -18,6 +18,7 @@ from keystoneclient.client import Client
 from keystoneauth1.identity import v3, v2
 from keystoneauth1 import session
 import requests
+from keystoneclient.exceptions import NotFound
 
 from snaps.domain.project import Project, Domain
 from snaps.domain.role import Role
@@ -105,26 +106,16 @@ def get_endpoint(os_creds, service_type, interface='public'):
         interface=interface)
 
 
-def get_project(keystone=None, os_creds=None, project_settings=None,
-                project_name=None):
+def get_project(keystone=None, project_settings=None, project_name=None):
     """
     Returns the first project where the project_settings is used for the query
     if not None, else the project_name parameter is used for the query. If both
     parameters are None, None is returned
     :param keystone: the Keystone client
-    :param os_creds: the OpenStack credentials used to obtain the Keystone
-                     client if the keystone parameter is None
     :param project_settings: a ProjectConfig object
     :param project_name: the name to query
     :return: the SNAPS-OO Project domain object or None
     """
-    if not keystone:
-        if os_creds:
-            keystone = keystone_client(os_creds)
-        else:
-            raise KeystoneException(
-                'Cannot lookup project without the proper credentials')
-
     proj_filter = dict()
 
     if project_name:
@@ -152,6 +143,26 @@ def get_project(keystone=None, os_creds=None, project_settings=None,
                            domain_id=domain_id)
 
 
+def get_project_by_id(keystone, proj_id):
+    """
+    Returns the first project where the project_settings is used for the query
+    if not None, else the project_name parameter is used for the query. If both
+    parameters are None, None is returned
+    :param keystone: the Keystone client
+    :param proj_id: the project ID
+    """
+    if proj_id and len(proj_id) > 0:
+        try:
+            os_proj = keystone.projects.get(proj_id)
+            if os_proj:
+                return Project(name=os_proj.name, project_id=os_proj.id,
+                               domain_id=os_proj)
+        except NotFound:
+            pass
+        except KeyError:
+            pass
+
+
 def create_project(keystone, project_settings):
     """
     Creates a project
@@ -237,8 +248,8 @@ def create_user(keystone, user_settings):
     """
     project = None
     if user_settings.project_name:
-        project = get_project(keystone=keystone,
-                              project_name=user_settings.project_name)
+        project = get_project(
+            keystone=keystone, project_name=user_settings.project_name)
 
     if keystone.version == V2_VERSION_STR:
         project_id = None
diff --git a/snaps/openstack/utils/neutron_utils.py b/snaps/openstack/utils/neutron_utils.py
index a2957a6..f2ee648 100644
--- a/snaps/openstack/utils/neutron_utils.py
+++ b/snaps/openstack/utils/neutron_utils.py
@@ -101,18 +101,18 @@ def delete_network(neutron, network):
         neutron.delete_network(network.id)
 
 
-def get_network(neutron, network_settings=None, network_name=None,
-                project_id=None, os_creds=None):
+def get_network(neutron, keystone, network_settings=None, network_name=None,
+                project_name=None):
     """
     Returns Network SNAPS-OO domain object the first network found with
     either the given attributes from the network_settings object if not None,
     else the query will use just the name from the network_name parameter.
-    When the project_id is included, that will be added to the query filter.
-    :param neutron: the client
+    When the project_name is included, that will be added to the query filter.
+    :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param network_settings: the NetworkConfig object used to create filter
     :param network_name: the name of the network to retrieve
-    :param project_id: the id of the network's project
-    :param os_creds: the OpenStack credentials for retrieving the project
+    :param project_name: the name of the network's project
     :return: a SNAPS-OO Network domain object
     """
     net_filter = dict()
@@ -121,16 +121,16 @@ def get_network(neutron, network_settings=None, network_name=None,
     elif network_name:
         net_filter['name'] = network_name
 
-    if network_settings and network_settings.project_name and os_creds:
-        net_filter['project_id'] = keystone_utils.get_project(
-            os_creds=os_creds, project_name=network_settings.project_name).id
-    elif project_id:
-        net_filter['project_id'] = project_id
-
     networks = neutron.list_networks(**net_filter)
     for network, netInsts in networks.items():
         for inst in netInsts:
-            return __map_network(neutron, inst)
+            if project_name:
+                project = keystone_utils.get_project_by_id(
+                    keystone, inst['project_id'])
+                if project and project.name == project_name:
+                    return __map_network(neutron, inst)
+            else:
+                return __map_network(neutron, inst)
 
 
 def __get_os_network_by_id(neutron, network_id):
@@ -282,7 +282,7 @@ def get_subnets_by_network_id(neutron, network_id):
     return out
 
 
-def create_router(neutron, os_creds, router_settings, project_id):
+def create_router(neutron, os_creds, router_settings):
     """
     Creates a router for OpenStack
     :param neutron: the client
@@ -290,16 +290,10 @@ def create_router(neutron, os_creds, router_settings, project_id):
     :param router_settings: A dictionary containing the router configuration
                             and is responsible for creating the subnet request
                             JSON body
-    :param project_id: the associated project ID
     :return: a SNAPS-OO Router domain object
     """
     if neutron:
-        if router_settings and router_settings.project_name:
-            keystone = keystone_utils.keystone_client(os_creds)
-            project_id = keystone_utils.get_project(
-                keystone=keystone, project_name=router_settings.project_name)
-        json_body = router_settings.dict_for_neutron(
-            neutron, os_creds, project_id)
+        json_body = router_settings.dict_for_neutron(neutron, os_creds)
         logger.info('Creating router with name - ' + router_settings.name)
         os_router = neutron.create_router(json_body)
         return __map_router(neutron, os_router['router'])
@@ -483,14 +477,16 @@ def delete_port(neutron, port):
     neutron.delete_port(port.id)
 
 
-def get_port(neutron, port_settings=None, port_name=None, project_id=None):
+def get_port(neutron, keystone, port_settings=None, port_name=None,
+             project_name=None):
     """
     Returns the first port object (dictionary) found for the given query
-    :param neutron: the client
+    :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param port_settings: the PortConfig object used for generating the query
     :param port_name: if port_settings is None, this name is the value to place
                       into the query
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :return: a SNAPS-OO Port domain object
     """
     port_filter = dict()
@@ -504,21 +500,26 @@ def get_port(neutron, port_settings=None, port_name=None, project_id=None):
             port_filter['device_id'] = port_settings.device_id
         if port_settings.mac_address:
             port_filter['mac_address'] = port_settings.mac_address
+        if port_settings.project_name:
+            project_name = port_settings.project_name
         if port_settings.network_name:
             network = get_network(
-                neutron, network_name=port_settings.network_name,
-                project_id=project_id)
+                neutron, keystone, network_name=port_settings.network_name,
+                project_name=project_name)
             if network:
                 port_filter['network_id'] = network.id
     elif port_name:
         port_filter['name'] = port_name
 
-    if project_id:
-        port_filter['project_id'] = project_id
-
     ports = neutron.list_ports(**port_filter)
     for port in ports['ports']:
-        return Port(**port)
+        if project_name:
+            project = keystone_utils.get_project_by_id(
+                keystone, port['project_id'])
+            if project and project.name == project_name:
+                return Port(**port)
+        else:
+            return Port(**port)
     return None
 
 
@@ -559,19 +560,18 @@ def get_ports(neutron, network, ips=None):
     return out
 
 
-def create_security_group(neutron, keystone, sec_grp_settings, project_id):
+def create_security_group(neutron, keystone, sec_grp_settings):
     """
     Creates a security group object in OpenStack
     :param neutron: the Neutron client
     :param keystone: the Keystone client
     :param sec_grp_settings: the security group settings
-    :param project_id: the default project to associated the security group
     :return: a SNAPS-OO SecurityGroup domain object
     """
     logger.info('Creating security group with name - %s',
                 sec_grp_settings.name)
     os_group = neutron.create_security_group(
-        sec_grp_settings.dict_for_neutron(keystone, project_id))
+        sec_grp_settings.dict_for_neutron(keystone))
     return __map_os_security_group(neutron, os_group['security_group'])
 
 
@@ -585,37 +585,47 @@ def delete_security_group(neutron, sec_grp):
     neutron.delete_security_group(sec_grp.id)
 
 
-def get_security_group(neutron, sec_grp_settings=None, sec_grp_name=None,
-                       project_id=None):
+def get_security_group(neutron, keystone, sec_grp_settings=None,
+                       sec_grp_name=None, project_name=None):
     """
     Returns the first security group for a given query. The query gets built
     from the sec_grp_settings parameter if not None, else only the name of
     the security group will be used, else if the query parameters are None then
     None will be returned
-    :param neutron: the client
+    :param neutron: the neutron client
+    :param keystone: the keystone client
     :param sec_grp_settings: an instance of SecurityGroupConfig object
     :param sec_grp_name: the name of security group object to retrieve
-    :param project_id: the ID of the project/tentant object that owns the
+    :param project_name: the name of the project/tentant object that owns the
                        secuity group to retrieve
     :return: a SNAPS-OO SecurityGroup domain object or None if not found
     """
 
     sec_grp_filter = dict()
-    if project_id:
-        sec_grp_filter['tenant_id'] = project_id
 
     if sec_grp_settings:
         sec_grp_filter['name'] = sec_grp_settings.name
 
         if sec_grp_settings.description:
             sec_grp_filter['description'] = sec_grp_settings.description
+        if sec_grp_settings.project_name:
+            project_name = sec_grp_settings.project_name
     elif sec_grp_name:
         sec_grp_filter['name'] = sec_grp_name
     else:
         return None
 
     groups = neutron.list_security_groups(**sec_grp_filter)
+    group = None
     for group in groups['security_groups']:
+        if project_name:
+            project = keystone_utils.get_project_by_id(
+                keystone, group['tenant_id'])
+            if project and project_name == project.name:
+                break
+        else:
+            break
+    if group:
         return __map_os_security_group(neutron, group)
 
 
@@ -648,18 +658,20 @@ def get_security_group_by_id(neutron, sec_grp_id):
     return None
 
 
-def create_security_group_rule(neutron, sec_grp_rule_settings, proj_id):
+def create_security_group_rule(neutron, keystone, sec_grp_rule_settings,
+                               proj_name):
     """
     Creates a security group rule in OpenStack
-    :param neutron: the client
+    :param neutron: the neutron client
+    :param keystone: the keystone client
     :param sec_grp_rule_settings: the security group rule settings
-    :param proj_id: the default project to apply to the rule settings
+    :param proj_name: the default project name
     :return: a SNAPS-OO SecurityGroupRule domain object
     """
     logger.info('Creating security group to security group - %s',
                 sec_grp_rule_settings.sec_grp_name)
     os_rule = neutron.create_security_group_rule(
-        sec_grp_rule_settings.dict_for_neutron(neutron, proj_id))
+        sec_grp_rule_settings.dict_for_neutron(neutron, keystone, proj_name))
     return SecurityGroupRule(**os_rule['security_group_rule'])
 
 
@@ -763,10 +775,11 @@ def get_floating_ips(neutron):
     return out
 
 
-def create_floating_ip(neutron, ext_net_name, port_id=None):
+def create_floating_ip(neutron, keystone, ext_net_name, port_id=None):
     """
     Returns the floating IP object that was created with this call
     :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param ext_net_name: the name of the external network on which to apply the
                          floating IP address
     :param port_id: the ID of the port to which the floating IP will be
@@ -774,7 +787,7 @@ def create_floating_ip(neutron, ext_net_name, port_id=None):
     :return: the SNAPS FloatingIp object
     """
     logger.info('Creating floating ip to external network - ' + ext_net_name)
-    ext_net = get_network(neutron, network_name=ext_net_name)
+    ext_net = get_network(neutron, keystone, network_name=ext_net_name)
     if ext_net:
         body = {'floatingip': {'floating_network_id': ext_net.id}}
         if port_id:
diff --git a/snaps/openstack/utils/nova_utils.py b/snaps/openstack/utils/nova_utils.py
index b37e0a4..5e6a037 100644
--- a/snaps/openstack/utils/nova_utils.py
+++ b/snaps/openstack/utils/nova_utils.py
@@ -55,16 +55,17 @@ def nova_client(os_creds):
                   region_name=os_creds.region_name)
 
 
-def create_server(nova, neutron, glance, instance_config, image_config,
-                  project_id, keypair_config=None):
+def create_server(nova, keystone, neutron, glance, instance_config,
+                  image_config, project_name, keypair_config=None):
     """
     Creates a VM instance
     :param nova: the nova client (required)
+    :param keystone: the keystone client for retrieving projects (required)
     :param neutron: the neutron client for retrieving ports (required)
     :param glance: the glance client (required)
     :param instance_config: the VMInstConfig object (required)
     :param image_config: the VM's ImageConfig object (required)
-    :param project_id: the associated project ID (required)
+    :param project_name: the associated project name (required)
     :param keypair_config: the VM's KeypairConfig object (optional)
     :return: a snaps.domain.VmInst object
     """
@@ -73,7 +74,8 @@ def create_server(nova, neutron, glance, instance_config, image_config,
 
     for port_setting in instance_config.port_settings:
         port = neutron_utils.get_port(
-            neutron, port_settings=port_setting, project_id=project_id)
+            neutron, keystone, port_settings=port_setting,
+            project_name=project_name)
         if port:
             ports.append(port)
         else:
@@ -122,19 +124,21 @@ def create_server(nova, neutron, glance, instance_config, image_config,
 
         server = nova.servers.create(**args)
 
-        return __map_os_server_obj_to_vm_inst(neutron, server, project_id)
+        return __map_os_server_obj_to_vm_inst(
+            neutron, keystone, server, project_name)
     else:
         raise NovaException(
             'Cannot create instance, image cannot be located with name %s',
             image_config.name)
 
 
-def get_server(nova, neutron, vm_inst_settings=None, server_name=None,
-               project_id=None):
+def get_server(nova, neutron, keystone, vm_inst_settings=None,
+               server_name=None, project_id=None):
     """
     Returns a VmInst object for the first server instance found.
     :param nova: the Nova client
     :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param vm_inst_settings: the VmInstanceConfig object from which to build
                              the query if not None
     :param server_name: the server with this name to return if vm_inst_settings
@@ -150,7 +154,8 @@ def get_server(nova, neutron, vm_inst_settings=None, server_name=None,
 
     servers = nova.servers.list(search_opts=search_opts)
     for server in servers:
-        return __map_os_server_obj_to_vm_inst(neutron, server, project_id)
+        return __map_os_server_obj_to_vm_inst(
+            neutron, keystone, server, project_id)
 
 
 def get_server_connection(nova, vm_inst_settings=None, server_name=None):
@@ -174,11 +179,14 @@ def get_server_connection(nova, vm_inst_settings=None, server_name=None):
         return server.links[0]
 
 
-def __map_os_server_obj_to_vm_inst(neutron, os_server, project_id):
+def __map_os_server_obj_to_vm_inst(neutron, keystone, os_server,
+                                   project_name=None):
     """
     Returns a VmInst object for an OpenStack Server object
-    :param neutron: the Neutron client (when None, ports will be empty)
+    :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param os_server: the OpenStack server object
+    :param project_name: the associated project name
     :return: an equivalent SNAPS-OO VmInst domain object
     """
     sec_grp_names = list()
@@ -192,7 +200,8 @@ def __map_os_server_obj_to_vm_inst(neutron, os_server, project_id):
     if len(os_server.networks) > 0:
         for net_name, ips in os_server.networks.items():
             network = neutron_utils.get_network(
-                neutron, network_name=net_name, project_id=project_id)
+                neutron, keystone, network_name=net_name,
+                project_name=project_name)
             ports = neutron_utils.get_ports(neutron, network, ips)
             for port in ports:
                 out_ports.append(port)
@@ -254,30 +263,35 @@ def get_server_console_output(nova, server):
     return None
 
 
-def get_latest_server_object(nova, neutron, server, project_id):
+def get_latest_server_object(nova, neutron, keystone, server, project_name):
     """
     Returns a server with a given id
     :param nova: the Nova client
     :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param server: the old server object
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :return: the list of servers or None if not found
     """
     server = __get_latest_server_os_object(nova, server)
-    return __map_os_server_obj_to_vm_inst(neutron, server, project_id)
+    return __map_os_server_obj_to_vm_inst(
+        neutron, keystone, server, project_name)
 
 
-def get_server_object_by_id(nova, neutron, server_id, project_id):
+def get_server_object_by_id(nova, neutron, keystone, server_id,
+                            project_name=None):
     """
     Returns a server with a given id
     :param nova: the Nova client
     :param neutron: the Neutron client
+    :param keystone: the Keystone client
     :param server_id: the server's id
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :return: an SNAPS-OO VmInst object or None if not found
     """
     server = __get_latest_server_os_object_by_id(nova, server_id)
-    return __map_os_server_obj_to_vm_inst(neutron, server, project_id)
+    return __map_os_server_obj_to_vm_inst(
+        neutron, keystone, server, project_name)
 
 
 def get_server_security_group_names(nova, server):
@@ -720,16 +734,18 @@ def update_quotas(nova, project_id, compute_quotas):
     return nova.quotas.update(project_id, **update_values)
 
 
-def attach_volume(nova, neutron, server, volume, project_id, timeout=120):
+def attach_volume(nova, neutron, keystone, server, volume, project_name,
+                  timeout=120):
     """
     Attaches a volume to a server. When the timeout parameter is used, a VmInst
     object with the proper volume updates is returned unless it has not been
     updated in the allotted amount of time then an Exception will be raised.
     :param nova: the nova client
     :param neutron: the neutron client
+    :param keystone: the neutron client
     :param server: the VMInst domain object
     :param volume: the Volume domain object
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :param timeout: denotes the amount of time to block to determine if the
                     has been properly attached.
     :return: updated VmInst object
@@ -738,7 +754,8 @@ def attach_volume(nova, neutron, server, volume, project_id, timeout=120):
 
     start_time = time.time()
     while time.time() < start_time + timeout:
-        vm = get_server_object_by_id(nova, neutron, server.id, project_id)
+        vm = get_server_object_by_id(
+            nova, neutron, keystone, server.id, project_name)
         for vol_dict in vm.volume_ids:
             if volume.id == vol_dict['id']:
                 return vm
@@ -749,16 +766,18 @@ def attach_volume(nova, neutron, server, volume, project_id, timeout=120):
             volume.id, server.id))
 
 
-def detach_volume(nova, neutron, server, volume, project_id, timeout=120):
+def detach_volume(nova, neutron, keystone, server, volume, project_name,
+                  timeout=120):
     """
     Detaches a volume to a server. When the timeout parameter is used, a VmInst
     object with the proper volume updates is returned unless it has not been
     updated in the allotted amount of time then an Exception will be raised.
     :param nova: the nova client
     :param neutron: the neutron client
+    :param keystone: the keystone client
     :param server: the VMInst domain object
     :param volume: the Volume domain object
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :param timeout: denotes the amount of time to block to determine if the
                     has been properly detached.
     :return: updated VmInst object
@@ -767,7 +786,8 @@ def detach_volume(nova, neutron, server, volume, project_id, timeout=120):
 
     start_time = time.time()
     while time.time() < start_time + timeout:
-        vm = get_server_object_by_id(nova, neutron, server.id, project_id)
+        vm = get_server_object_by_id(
+            nova, neutron, keystone, server.id, project_name)
         if len(vm.volume_ids) == 0:
             return vm
         else:
diff --git a/snaps/openstack/utils/settings_utils.py b/snaps/openstack/utils/settings_utils.py
index c14437d..e43f8f5 100644
--- a/snaps/openstack/utils/settings_utils.py
+++ b/snaps/openstack/utils/settings_utils.py
@@ -224,15 +224,16 @@ def create_keypair_config(heat_cli, stack, keypair, pk_output_key):
     return KeypairConfig(name=keypair.name)
 
 
-def create_vm_inst_config(nova, neutron, server, project_id):
+def create_vm_inst_config(nova, keystone, neutron, server, project_name):
     """
     Returns a VmInstanceConfig object
     note: if the server instance is not active, the PortSettings objects will
     not be generated resulting in an invalid configuration
     :param nova: the nova client
+    :param keystone: the keystone client
     :param neutron: the neutron client
     :param server: a SNAPS-OO VmInst domain object
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :return:
     """
 
@@ -245,7 +246,7 @@ def create_vm_inst_config(nova, neutron, server, project_id):
     kwargs['port_settings'] = __create_port_configs(neutron, server.ports)
     kwargs['security_group_names'] = server.sec_grp_names
     kwargs['floating_ip_settings'] = __create_floatingip_config(
-        neutron, kwargs['port_settings'], project_id)
+        neutron, keystone, kwargs['port_settings'], project_name)
 
     return VmInstanceConfig(**kwargs)
 
@@ -282,11 +283,12 @@ def __create_port_configs(neutron, ports):
     return out
 
 
-def __create_floatingip_config(neutron, port_settings, project_id):
+def __create_floatingip_config(neutron, keystone, port_settings, project_name):
     """
     Returns a list of FloatingIpConfig objects as they pertain to an
     existing deployed server instance
     :param neutron: the neutron client
+    :param keystone: the keystone client
     :param port_settings: list of SNAPS-OO PortConfig objects
     :return: a list of FloatingIpConfig objects or an empty list if no
              floating IPs have been created
@@ -298,10 +300,10 @@ def __create_floatingip_config(neutron, port_settings, project_id):
     fip_ports = list()
     for port_setting in port_settings:
         setting_port = neutron_utils.get_port(
-            neutron, port_setting, project_id=project_id)
+            neutron, keystone, port_setting, project_name=project_name)
         if setting_port:
             network = neutron_utils.get_network(
-                neutron, network_name=port_setting.network_name)
+                neutron, keystone, network_name=port_setting.network_name)
             network_ports = neutron_utils.get_ports(neutron, network)
             if network_ports:
                 for setting_port in network_ports:
diff --git a/snaps/openstack/utils/tests/heat_utils_tests.py b/snaps/openstack/utils/tests/heat_utils_tests.py
index ee95a63..cad3fc2 100644
--- a/snaps/openstack/utils/tests/heat_utils_tests.py
+++ b/snaps/openstack/utils/tests/heat_utils_tests.py
@@ -31,7 +31,7 @@ from snaps.openstack.tests import openstack_tests
 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
 from snaps.openstack.utils import (
     heat_utils, neutron_utils, nova_utils, settings_utils, glance_utils,
-    cinder_utils)
+    cinder_utils, keystone_utils)
 
 __author__ = 'spisarski'
 
@@ -186,8 +186,10 @@ class HeatUtilsCreateSimpleStackTests(OSComponentTestCase):
         self.assertEqual(self.subnet_name, subnets[0].name)
 
         nova = nova_utils.nova_client(self.os_creds)
+        keystone = keystone_utils.keystone_client(self.os_creds)
         servers = heat_utils.get_stack_servers(
-            self.heat_client, nova, neutron, self.stack1, self.project_id)
+            self.heat_client, nova, neutron, keystone, self.stack1,
+            self.os_creds.project_name)
         self.assertIsNotNone(servers)
         self.assertEqual(1, len(servers))
         self.assertEqual(self.vm_inst_name, servers[0].name)
@@ -308,14 +310,16 @@ class HeatUtilsCreateComplexStackTests(OSComponentTestCase):
 
                 if not is_deleted:
                     nova = nova_utils.nova_client(self.os_creds)
+                    keystone = keystone_utils.keystone_client(self.os_creds)
                     neutron = neutron_utils.neutron_client(self.os_creds)
                     glance = glance_utils.glance_client(self.os_creds)
                     servers = heat_utils.get_stack_servers(
-                        self.heat_client, nova, neutron, self.stack,
-                        self.project_id)
+                        self.heat_client, nova, neutron, keystone, self.stack,
+                        self.os_creds.project_name)
                     for server in servers:
                         vm_settings = settings_utils.create_vm_inst_config(
-                            nova, neutron, server, self.project_id)
+                            nova, keystone, neutron, server,
+                            self.os_creds.project_name)
                         img_settings = settings_utils.determine_image_config(
                             glance, server,
                             [self.image_creator1.image_settings,
@@ -382,9 +386,10 @@ class HeatUtilsCreateComplexStackTests(OSComponentTestCase):
 
         nova = nova_utils.nova_client(self.os_creds)
         glance = glance_utils.glance_client(self.os_creds)
-
+        keystone = keystone_utils.keystone_client(self.os_creds)
         servers = heat_utils.get_stack_servers(
-            self.heat_client, nova, neutron, self.stack, self.project_id)
+            self.heat_client, nova, neutron, keystone, self.stack,
+            self.os_creds.project_name)
         self.assertIsNotNone(servers)
         self.assertEqual(2, len(servers))
 
@@ -499,8 +504,9 @@ class HeatUtilsRouterTests(OSComponentTestCase):
         router = routers[0]
         self.assertEqual(self.router_name, router.name)
 
+        keystone = keystone_utils.keystone_client(self.os_creds)
         ext_net = neutron_utils.get_network(
-            self.neutron, network_name=self.ext_net_name)
+            self.neutron, keystone, network_name=self.ext_net_name)
         self.assertEqual(ext_net.id, router.external_network_id)
 
 
diff --git a/snaps/openstack/utils/tests/keystone_utils_tests.py b/snaps/openstack/utils/tests/keystone_utils_tests.py
index 2916003..7ce7a61 100644
--- a/snaps/openstack/utils/tests/keystone_utils_tests.py
+++ b/snaps/openstack/utils/tests/keystone_utils_tests.py
@@ -75,8 +75,8 @@ class KeystoneUtilsTests(OSComponentTestCase):
         if self.project:
             neutron = neutron_utils.neutron_client(self.os_creds)
             default_sec_grp = neutron_utils.get_security_group(
-                neutron, sec_grp_name='default',
-                project_id=self.project.id)
+                neutron, self.keystone, sec_grp_name='default',
+                project_name=self.os_creds.project_name)
             if default_sec_grp:
                 try:
                     neutron_utils.delete_security_group(
diff --git a/snaps/openstack/utils/tests/neutron_utils_tests.py b/snaps/openstack/utils/tests/neutron_utils_tests.py
index 22c6a33..925bd06 100644
--- a/snaps/openstack/utils/tests/neutron_utils_tests.py
+++ b/snaps/openstack/utils/tests/neutron_utils_tests.py
@@ -89,6 +89,7 @@ class NeutronUtilsNetworkTests(OSComponentTestCase):
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.port_name = str(guid) + '-port'
         self.neutron = neutron_utils.neutron_client(self.os_creds)
+        self.keystone = keystone_utils.keystone_client(self.os_creds)
         self.network = None
         self.net_config = openstack_tests.get_pub_net_config(
             net_name=guid + '-pub-net')
@@ -109,8 +110,9 @@ class NeutronUtilsNetworkTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
         self.assertEqual(len(self.net_config.network_settings.subnet_settings),
                          len(self.network.subnets))
 
@@ -144,6 +146,7 @@ class NeutronUtilsSubnetTests(OSComponentTestCase):
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.port_name = str(guid) + '-port'
         self.neutron = neutron_utils.neutron_client(self.os_creds)
+        self.keystone = keystone_utils.keystone_client(self.os_creds)
         self.network = None
         self.net_config = openstack_tests.get_pub_net_config(
             net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
@@ -168,8 +171,9 @@ class NeutronUtilsSubnetTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -195,8 +199,9 @@ class NeutronUtilsSubnetTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         with self.assertRaises(Exception):
             SubnetConfig(cidr=self.net_config.subnet_cidr)
@@ -211,8 +216,9 @@ class NeutronUtilsSubnetTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -492,6 +498,7 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
         self.port_name = str(guid) + '-port'
         self.neutron = neutron_utils.neutron_client(self.os_creds)
+        self.keystone = keystone_utils.keystone_client(self.os_creds)
         self.network = None
         self.port = None
         self.router = None
@@ -529,8 +536,7 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         Tests the neutron_utils.create_router()
         """
         self.router = neutron_utils.create_router(
-            self.neutron, self.os_creds, self.net_config.router_settings,
-            self.project_id)
+            self.neutron, self.os_creds, self.net_config.router_settings)
         validate_router(self.neutron, self.net_config.router_settings.name,
                         True)
 
@@ -540,19 +546,16 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         """
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.net_config = openstack_tests.OSNetworkConfig(
-            self.net_config.network_settings.name,
-            subnet_setting.name,
-            subnet_setting.cidr,
-            self.net_config.router_settings.name,
+            self.net_config.network_settings.name, subnet_setting.name,
+            subnet_setting.cidr, self.net_config.router_settings.name,
             self.ext_net_name)
         self.router = neutron_utils.create_router(
-            self.neutron, self.os_creds, self.net_config.router_settings,
-            self.project_id)
-        validate_router(self.neutron, self.net_config.router_settings.name,
-                        True)
+            self.neutron, self.os_creds, self.net_config.router_settings)
+        validate_router(
+            self.neutron, self.net_config.router_settings.name, True)
 
         ext_net = neutron_utils.get_network(
-            self.neutron, network_name=self.ext_net_name)
+            self.neutron, self.keystone, network_name=self.ext_net_name)
         self.assertEqual(self.router.external_network_id, ext_net.id)
 
     def test_add_interface_router(self):
@@ -564,16 +567,16 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
             self.neutron, subnet_setting.name, subnet_setting.cidr, True))
 
         self.router = neutron_utils.create_router(
-            self.neutron, self.os_creds, self.net_config.router_settings,
-            self.project_id)
+            self.neutron, self.os_creds, self.net_config.router_settings)
         validate_router(self.neutron, self.net_config.router_settings.name,
                         True)
 
@@ -592,8 +595,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -613,12 +617,12 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         self.router = neutron_utils.create_router(
-            self.neutron, self.os_creds, self.net_config.router_settings,
-            self.project_id)
+            self.neutron, self.os_creds, self.net_config.router_settings)
         validate_router(self.neutron, self.net_config.router_settings.name,
                         True)
 
@@ -636,12 +640,12 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         self.router = neutron_utils.create_router(
-            self.neutron, self.os_creds, self.net_config.router_settings,
-            self.project_id)
+            self.neutron, self.os_creds, self.net_config.router_settings)
         validate_router(self.neutron, self.net_config.router_settings.name,
                         True)
 
@@ -661,8 +665,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -686,8 +691,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(self.neutron, subnet_setting.name,
@@ -711,8 +717,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -756,8 +763,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -783,8 +791,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -810,8 +819,9 @@ class NeutronUtilsRouterTests(OSComponentTestCase):
         self.assertEqual(self.net_config.network_settings.name,
                          self.network.name)
         self.assertTrue(validate_network(
-            self.neutron, self.net_config.network_settings.name, True,
-            self.project_id))
+            self.neutron, self.keystone,
+            self.net_config.network_settings.name, True,
+            self.os_creds.project_name))
 
         subnet_setting = self.net_config.network_settings.subnet_settings[0]
         self.assertTrue(validate_subnet(
@@ -862,19 +872,19 @@ class NeutronUtilsSecurityGroupTests(OSComponentTestCase):
         """
         sec_grp_settings = SecurityGroupConfig(name=self.sec_grp_name)
         security_group = neutron_utils.create_security_group(
-            self.neutron, self.keystone, sec_grp_settings, self.project_id)
+            self.neutron, self.keystone, sec_grp_settings)
 
         self.assertTrue(sec_grp_settings.name, security_group.name)
 
         sec_grp_get = neutron_utils.get_security_group(
-            self.neutron, sec_grp_settings=sec_grp_settings)
+            self.neutron, self.keystone, sec_grp_settings=sec_grp_settings)
         self.assertIsNotNone(sec_grp_get)
         self.assertTrue(validation_utils.objects_equivalent(
             security_group, sec_grp_get))
 
         neutron_utils.delete_security_group(self.neutron, security_group)
         sec_grp_get = neutron_utils.get_security_group(
-            self.neutron, sec_grp_settings=sec_grp_settings)
+            self.neutron, self.keystone, sec_grp_settings=sec_grp_settings)
         self.assertIsNone(sec_grp_get)
 
     def test_create_sec_grp_no_name(self):
@@ -888,8 +898,7 @@ class NeutronUtilsSecurityGroupTests(OSComponentTestCase):
             sec_grp_settings = SecurityGroupConfig()
             self.security_groups.append(
                 neutron_utils.create_security_group(
-                    self.neutron, self.keystone, sec_grp_settings,
-                    self.project_id))
+                    self.neutron, self.keystone, sec_grp_settings))
 
     def test_create_sec_grp_no_rules(self):
         """
@@ -899,14 +908,13 @@ class NeutronUtilsSecurityGroupTests(OSComponentTestCase):
             name=self.sec_grp_name, description='hello group')
         self.security_groups.append(
             neutron_utils.create_security_group(
-                self.neutron, self.keystone, sec_grp_settings,
-                self.project_id))
+                self.neutron, self.keystone, sec_grp_settings))
 
         self.assertTrue(sec_grp_settings.name, self.security_groups[0].name)
         self.assertEqual(sec_grp_settings.name, self.security_groups[0].name)
 
         sec_grp_get = neutron_utils.get_security_group(
-            self.neutron, sec_grp_settings=sec_grp_settings)
+            self.neutron, self.keystone, sec_grp_settings=sec_grp_settings)
         self.assertIsNotNone(sec_grp_get)
         self.assertEqual(self.security_groups[0], sec_grp_get)
 
@@ -923,26 +931,24 @@ class NeutronUtilsSecurityGroupTests(OSComponentTestCase):
 
         self.security_groups.append(
             neutron_utils.create_security_group(
-                self.neutron, self.keystone, sec_grp_settings,
-                self.project_id))
+                self.neutron, self.keystone, sec_grp_settings))
         free_rules = neutron_utils.get_rules_by_security_group(
             self.neutron, self.security_groups[0])
         for free_rule in free_rules:
             self.security_group_rules.append(free_rule)
 
         keystone = keystone_utils.keystone_client(self.os_creds)
-        project_id = keystone_utils.get_project(
-            keystone, self.os_creds.project_name)
         self.security_group_rules.append(
             neutron_utils.create_security_group_rule(
-                self.neutron, sec_grp_settings.rule_settings[0], project_id))
+                self.neutron, keystone, sec_grp_settings.rule_settings[0],
+                self.os_creds.project_name))
 
         # Refresh object so it is populated with the newly added rule
         security_group = neutron_utils.get_security_group(
-            self.neutron, sec_grp_settings=sec_grp_settings)
+            self.neutron, self.keystone, sec_grp_settings=sec_grp_settings)
 
-        rules = neutron_utils.get_rules_by_security_group(self.neutron,
-                                                          security_group)
+        rules = neutron_utils.get_rules_by_security_group(
+            self.neutron, security_group)
 
         self.assertTrue(
             validation_utils.objects_equivalent(
@@ -951,7 +957,7 @@ class NeutronUtilsSecurityGroupTests(OSComponentTestCase):
         self.assertTrue(sec_grp_settings.name, security_group.name)
 
         sec_grp_get = neutron_utils.get_security_group(
-            self.neutron, sec_grp_settings=sec_grp_settings)
+            self.neutron, self.keystone, sec_grp_settings=sec_grp_settings)
         self.assertIsNotNone(sec_grp_get)
         self.assertEqual(security_group, sec_grp_get)
 
@@ -963,13 +969,11 @@ class NeutronUtilsSecurityGroupTests(OSComponentTestCase):
         self.security_groups.append(neutron_utils.create_security_group(
             self.neutron, self.keystone,
             SecurityGroupConfig(
-                name=self.sec_grp_name + '-1', description='hello group'),
-            self.project_id))
+                name=self.sec_grp_name + '-1', description='hello group')))
         self.security_groups.append(neutron_utils.create_security_group(
             self.neutron, self.keystone,
             SecurityGroupConfig(
-                name=self.sec_grp_name + '-2', description='hello group'),
-            self.project_id))
+                name=self.sec_grp_name + '-2', description='hello group')))
 
         sec_grp_1b = neutron_utils.get_security_group_by_id(
             self.neutron, self.security_groups[0].id)
@@ -991,6 +995,7 @@ class NeutronUtilsFloatingIpTests(OSComponentTestCase):
         and creating an OS image file within OpenStack
         """
         self.neutron = neutron_utils.neutron_client(self.os_creds)
+        self.keystone = keystone_utils.keystone_client(self.os_creds)
         self.floating_ip = None
 
     def tearDown(self):
@@ -1011,8 +1016,8 @@ class NeutronUtilsFloatingIpTests(OSComponentTestCase):
         """
         initial_fips = neutron_utils.get_floating_ips(self.neutron)
 
-        self.floating_ip = neutron_utils.create_floating_ip(self.neutron,
-                                                            self.ext_net_name)
+        self.floating_ip = neutron_utils.create_floating_ip(
+            self.neutron, self.keystone, self.ext_net_name)
         all_fips = neutron_utils.get_floating_ips(self.neutron)
         self.assertEqual(len(initial_fips) + 1, len(all_fips))
         returned = neutron_utils.get_floating_ip(self.neutron,
@@ -1026,19 +1031,20 @@ Validation routines
 """
 
 
-def validate_network(neutron, name, exists, project_id):
+def validate_network(neutron, keystone, name, exists, project_name):
     """
     Returns true if a network for a given name DOES NOT exist if the exists
     parameter is false conversely true. Returns false if a network for a given
     name DOES exist if the exists parameter is true conversely false.
     :param neutron: The neutron client
+    :param keystone: The keystone client
     :param name: The expected network name
     :param exists: Whether or not the network name should exist or not
-    :param project_id: the associated project ID
+    :param project_name: the associated project name
     :return: True/False
     """
-    network = neutron_utils.get_network(neutron, network_name=name,
-                                        project_id=project_id)
+    network = neutron_utils.get_network(
+        neutron, keystone, network_name=name, project_name=project_name)
     if exists and network:
         return True
     if not exists and not network:
diff --git a/snaps/openstack/utils/tests/nova_utils_tests.py b/snaps/openstack/utils/tests/nova_utils_tests.py
index ee9c5d1..910684c 100644
--- a/snaps/openstack/utils/tests/nova_utils_tests.py
+++ b/snaps/openstack/utils/tests/nova_utils_tests.py
@@ -32,7 +32,7 @@ from snaps.openstack.create_volume import OpenStackVolume
 from snaps.openstack.tests import openstack_tests
 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
 from snaps.openstack.utils import (
-    nova_utils, neutron_utils, glance_utils, cinder_utils)
+    nova_utils, neutron_utils, glance_utils, cinder_utils, keystone_utils)
 from snaps.openstack.utils.nova_utils import NovaException
 
 __author__ = 'spisarski'
@@ -243,6 +243,7 @@ class NovaUtilsInstanceTests(OSComponentTestCase):
         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 
         self.nova = nova_utils.nova_client(self.os_creds)
+        self.keystone = keystone_utils.keystone_client(self.os_creds)
         self.neutron = neutron_utils.neutron_client(self.os_creds)
         self.glance = glance_utils.glance_client(self.os_creds)
 
@@ -322,8 +323,9 @@ class NovaUtilsInstanceTests(OSComponentTestCase):
         """
 
         self.vm_inst = nova_utils.create_server(
-            self.nova, self.neutron, self.glance, self.instance_settings,
-            self.image_creator.image_settings, self.project_id)
+            self.nova, self.keystone, self.neutron, self.glance,
+            self.instance_settings, self.image_creator.image_settings,
+            self.os_creds.project_name)
 
         self.assertIsNotNone(self.vm_inst)
 
@@ -341,7 +343,8 @@ class NovaUtilsInstanceTests(OSComponentTestCase):
 
         self.assertTrue(active)
         vm_inst = nova_utils.get_latest_server_object(
-            self.nova, self.neutron, self.vm_inst, self.project_id)
+            self.nova, self.neutron, self.keystone, self.vm_inst,
+            self.os_creds.project_name)
 
         self.assertEqual(self.vm_inst.name, vm_inst.name)
         self.assertEqual(self.vm_inst.id, vm_inst.id)
@@ -451,9 +454,10 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
 
         # Attach volume to VM
         neutron = neutron_utils.neutron_client(self.os_creds)
+        keystone = keystone_utils.keystone_client(self.os_creds)
         self.assertIsNotNone(nova_utils.attach_volume(
-            self.nova, neutron, self.instance_creator.get_vm_inst(),
-            self.volume_creator.get_volume(), self.project_id))
+            self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
+            self.volume_creator.get_volume(), self.os_creds.project_name))
 
         vol_attach = None
         vol_detach = None
@@ -472,9 +476,10 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
         self.assertTrue(attached)
         self.assertIsNotNone(vol_attach)
 
+        keystone = keystone_utils.keystone_client(self.os_creds)
         vm_attach = nova_utils.get_server_object_by_id(
-            self.nova, neutron, self.instance_creator.get_vm_inst().id,
-            self.project_id)
+            self.nova, neutron, keystone,
+            self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
 
         # Validate Attachment
         self.assertIsNotNone(vol_attach)
@@ -485,8 +490,8 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
 
         # Detach volume to VM
         self.assertIsNotNone(nova_utils.detach_volume(
-            self.nova, neutron, self.instance_creator.get_vm_inst(),
-            self.volume_creator.get_volume(), self.project_id))
+            self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
+            self.volume_creator.get_volume(), self.os_creds.project_name))
 
         start_time = time.time()
         while time.time() < start_time + 120:
@@ -502,8 +507,8 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
         self.assertIsNotNone(vol_detach)
 
         vm_detach = nova_utils.get_server_object_by_id(
-            self.nova, neutron, self.instance_creator.get_vm_inst().id,
-            self.project_id)
+            self.nova, neutron, keystone,
+            self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
 
         # Validate Detachment
         self.assertIsNotNone(vol_detach)
@@ -524,10 +529,13 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
 
         # Attach volume to VM
         neutron = neutron_utils.neutron_client(self.os_creds)
+        keystone = keystone_utils.keystone_client(self.os_creds)
         with self.assertRaises(NovaException):
             nova_utils.attach_volume(
-                self.nova, neutron, self.instance_creator.get_vm_inst(),
-                self.volume_creator.get_volume(), self.project_id, 0)
+                self.nova, neutron, keystone,
+                self.instance_creator.get_vm_inst(),
+                self.volume_creator.get_volume(), self.os_creds.project_name,
+                0)
 
     def test_detach_volume_nowait(self):
         """
@@ -541,14 +549,16 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
 
         # Attach volume to VM
         neutron = neutron_utils.neutron_client(self.os_creds)
+        keystone = keystone_utils.keystone_client(self.os_creds)
         nova_utils.attach_volume(
-            self.nova, neutron, self.instance_creator.get_vm_inst(),
-            self.volume_creator.get_volume(), self.project_id)
+            self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
+            self.volume_creator.get_volume(), self.os_creds.project_name)
 
         # Check VmInst for attachment
+        keystone = keystone_utils.keystone_client(self.os_creds)
         latest_vm = nova_utils.get_server_object_by_id(
-            self.nova, neutron, self.instance_creator.get_vm_inst().id,
-            self.project_id)
+            self.nova, neutron, keystone,
+            self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
         self.assertEqual(1, len(latest_vm.volume_ids))
 
         # Check Volume for attachment
@@ -571,5 +581,7 @@ class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
         # Detach volume
         with self.assertRaises(NovaException):
             nova_utils.detach_volume(
-                self.nova, neutron, self.instance_creator.get_vm_inst(),
-                self.volume_creator.get_volume(), self.project_id, 0)
+                self.nova, neutron, keystone,
+                self.instance_creator.get_vm_inst(),
+                self.volume_creator.get_volume(), self.os_creds.project_name,
+                0)
diff --git a/snaps/openstack/utils/tests/settings_utils_tests.py b/snaps/openstack/utils/tests/settings_utils_tests.py
index 5dabe38..7287f44 100644
--- a/snaps/openstack/utils/tests/settings_utils_tests.py
+++ b/snaps/openstack/utils/tests/settings_utils_tests.py
@@ -37,7 +37,7 @@ from snaps.openstack.create_security_group import OpenStackSecurityGroup
 from snaps.openstack.tests import openstack_tests
 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
 from snaps.openstack.utils import (
-    neutron_utils, settings_utils, nova_utils, glance_utils)
+    neutron_utils, settings_utils, nova_utils, glance_utils, keystone_utils)
 
 __author__ = 'spisarski'
 
@@ -155,6 +155,7 @@ class SettingsUtilsVmInstTests(OSComponentTestCase):
         and creating an OS image file within OpenStack
         """
         self.nova = nova_utils.nova_client(self.os_creds)
+        self.keystone = keystone_utils.keystone_client(self.os_creds)
         self.glance = glance_utils.glance_client(self.os_creds)
         self.neutron = neutron_utils.neutron_client(self.os_creds)
 
@@ -324,10 +325,11 @@ class SettingsUtilsVmInstTests(OSComponentTestCase):
         self.inst_creator.create(block=True)
 
         server = nova_utils.get_server(
-            self.nova, self.neutron,
+            self.nova, self.neutron, self.keystone,
             vm_inst_settings=self.inst_creator.instance_settings)
         derived_vm_settings = settings_utils.create_vm_inst_config(
-            self.nova, self.neutron, server, self.project_id)
+            self.nova, self.keystone, self.neutron, server,
+            self.os_creds.project_name)
         self.assertIsNotNone(derived_vm_settings)
         self.assertIsNotNone(derived_vm_settings.port_settings)
         self.assertIsNotNone(derived_vm_settings.floating_ip_settings)
@@ -340,7 +342,7 @@ class SettingsUtilsVmInstTests(OSComponentTestCase):
         self.inst_creator.create(block=True)
 
         server = nova_utils.get_server(
-            self.nova, self.neutron,
+            self.nova, self.neutron, self.keystone,
             vm_inst_settings=self.inst_creator.instance_settings)
         derived_image_settings = settings_utils.determine_image_config(
             self.glance, server, [self.image_creator.image_settings])