Merge pull request #54 from yogirackspace/master

Name changes - BaseURLRefs to EndPoints and BaseURLs to EndpointTemplates. 

13 files changed, 394 insertions, 395 deletions

diff --git a/bin/keystone-manage b/bin/keystone-manage
index 6641e082..01b3a418 100755
--- a/bin/keystone-manage
+++ b/bin/keystone-manage
@@ -78,7 +78,7 @@ def Main():
         parser.error('No object type specified for first argument')
 
     object_type = args[0]
-    if object_type in ['user', 'tenant', 'role', 'baseURLs' , 'token', 'tenant_baseURL']:
+    if object_type in ['user', 'tenant', 'role', 'endpointTemplates' , 'token', 'endpoint']:
         pass
     else:
         parser.error('%s is not a supported object type' % object_type)
@@ -260,10 +260,10 @@ def Main():
             except Exception as exc:
                 print "ERROR: Failed to grant role %s to %s on %s: %s" % (object_id, user, tenant, exc)
             return
-    elif object_type == "baseURLs":
+    elif object_type == "endpointTemplates":
         if command == "add":
             if len(args) < 8:
-                parser.error("Missing arguments: baseURLs add " \
+                parser.error("Missing arguments: endpointTemplates add " \
                             "'region' 'service'" \
                             "'publicURL' 'adminURL' 'internalURL' 'enabled'")
             region = args[2]
@@ -273,29 +273,29 @@ def Main():
             internal_url = args[6]
             enabled = args[7]
             try:
-                object = db_models.BaseUrls()
+                object = db_models.EndpointTemplates()
                 object.region = region
                 object.service = service
                 object.public_url = public_url
                 object.admin_url = admin_url
                 object.internal_url = internal_url
                 object.enabled = enabled
-                object = db_api.baseurl.create(object)
-                print "SUCCESS: Created BaseURL for %s pointing to %s." % \
+                object = db_api.endpoint_template.create(object)
+                print "SUCCESS: Created EndpointTemplates for %s pointing to %s." % \
                     (object.service, object.public_url)
                 return
             except Exception as exc:
-                print "ERROR: Failed to create BaseURL for %s: %s" % (service,
+                print "ERROR: Failed to create EndpointTemplates for %s: %s" % (service,
                                                                       exc)
                 return
         elif command == "list":
             if len(args) == 3:
                 tenant = args[2]
                 try:
-                    objects = db_api.baseurl.ref_get_by_tenant(tenant)
+                    objects = db_api.endpoint_template.endpoint_get_by_tenant(tenant)
                     if objects == None:
                         raise IndexError("URLs not found")
-                    print 'Endpoints (BaseURLs) for tenant %s' % tenant
+                    print 'Endpoints for tenant %s' % tenant
                     print 'service', 'region', 'Public URL'
                     print '-' * 30
                     for row in objects:
@@ -307,35 +307,35 @@ def Main():
             else:
                 tenant = None
                 try:
-                    objects = db_api.baseurl.get_all()
+                    objects = db_api.endpoint_template.get_all()
                     if objects == None:
                         raise IndexError("URLs not found")
-                    print 'All Endpoints (BaseURLs)'
+                    print 'All EndpointTemplates'
                     print 'service', 'region', 'Public URL'
                     print '-' * 20
                     for row in objects:
                         print row.service, row.region, row.public_url
                 except Exception, e:
-                    print 'Error getting all BaseURLs:', str(e)
+                    print 'Error getting all EndpointTemplates:', str(e)
                 return
-    elif object_type == "tenant_baseURL":
+    elif object_type == "endpoint":
         if command == "add":
             if len(args) < 4:
-                parser.error("Missing arguments: baseURLs add 'tenant'\
-                             'baseURL'")
+                parser.error("Missing arguments: endPoint add 'tenant'\
+                             'endPointTemplate'")
                             
             tenant_id = args[2]
-            baseURLs_id = args[3]
+            endpoint_template_id = args[3]
             try:
-                object = db_models.TenantBaseURLAssociation()
+                object = db_models.Endpoints()
                 object.tenant_id = tenant_id
-                object.baseURLs_id = baseURLs_id
-                object = db_api.baseurl.ref_add(object)
-                print "SUCCESS: BaseURL %s added to tenant %s." % \
-                            (baseURLs_id, tenant_id)
+                object.endpoint_template_id = endpoint_template_id
+                object = db_api.endpoint_template.endpoint_add(object)
+                print "SUCCESS: EndpointTemplate %s added to tenant %s." % \
+                            (endpoint_template_id, tenant_id)
                 return
             except Exception as exc:
-                print "ERROR: Failed to create BaseURL Ref: %s" % exc
+                print "ERROR: Failed to create Endpoint: %s" % exc
                 return
     elif object_type == "token":
         if command == "add":
diff --git a/bin/sampledata.sh b/bin/sampledata.sh
index 40a316fb..95a523ab 100755
--- a/bin/sampledata.sh
+++ b/bin/sampledata.sh
@@ -42,12 +42,12 @@
 ./keystone-manage $* role grant Member joeuser 0000
 
 #BaseURLs
-./keystone-manage $* baseURLs add RegionOne swift http://swift.publicinternets.com/v1/AUTH_%tenant_id% http://swift.admin-nets.local:8080/ http://127.0.0.1:8080/v1/AUTH_%tenant_id% 1
-./keystone-manage $* baseURLs add RegionOne nova_compat http://nova.publicinternets.com/v1.0/ http://127.0.0.1:8774/v1.0  http://localhost:8774/v1.0 1
-./keystone-manage $* baseURLs add RegionOne nova http://nova.publicinternets.com/v1.1/ http://127.0.0.1:8774/v1.1  http://localhost:8774/v1.1 1
-./keystone-manage $* baseURLs add RegionOne glance http://glance.publicinternets.com/v1.1/%tenant_id% http://nova.admin-nets.local/v1.1/%tenant_id% http://127.0.0.1:9292/v1.1/%tenant_id% 1
-./keystone-manage $* baseURLs add RegionOne cdn http://cdn.publicinternets.com/v1.1/%tenant_id% http://cdn.admin-nets.local/v1.1/%tenant_id% http://127.0.0.1:7777/v1.1/%tenant_id% 1
-./keystone-manage $* baseURLs add RegionOne keystone http://keystone.publicinternets.com/v2.0 http://127.0.0.1:8081/v2.0 http://127.0.0.1:8080/v2.0 1
+./keystone-manage $* endpointTemplates add RegionOne swift http://swift.publicinternets.com/v1/AUTH_%tenant_id% http://swift.admin-nets.local:8080/ http://127.0.0.1:8080/v1/AUTH_%tenant_id% 1
+./keystone-manage $* endpointTemplates add RegionOne nova_compat http://nova.publicinternets.com/v1.0/ http://127.0.0.1:8774/v1.0  http://localhost:8774/v1.0 1
+./keystone-manage $* endpointTemplates add RegionOne nova http://nova.publicinternets.com/v1.1/ http://127.0.0.1:8774/v1.1  http://localhost:8774/v1.1 1
+./keystone-manage $* endpointTemplates add RegionOne glance http://glance.publicinternets.com/v1.1/%tenant_id% http://nova.admin-nets.local/v1.1/%tenant_id% http://127.0.0.1:9292/v1.1/%tenant_id% 1
+./keystone-manage $* endpointTemplates add RegionOne cdn http://cdn.publicinternets.com/v1.1/%tenant_id% http://cdn.admin-nets.local/v1.1/%tenant_id% http://127.0.0.1:7777/v1.1/%tenant_id% 1
+./keystone-manage $* endpointTemplates add RegionOne keystone http://keystone.publicinternets.com/v2.0 http://127.0.0.1:8081/v2.0 http://127.0.0.1:8080/v2.0 1
 
 # Groups
 #./keystone-manage $* group add Admin 1234
@@ -66,9 +66,9 @@
 ./keystone-manage $* token add 999888777 disabled 1234 2015-02-05T00:00
 
 #Tenant base urls
-./keystone-manage $* tenant_baseURL add 1234 1
-./keystone-manage $* tenant_baseURL add 1234 2
-./keystone-manage $* tenant_baseURL add 1234 3
-./keystone-manage $* tenant_baseURL add 1234 4
-./keystone-manage $* tenant_baseURL add 1234 5
-./keystone-manage $* tenant_baseURL add 1234 6
+./keystone-manage $* endpoint add 1234 1
+./keystone-manage $* endpoint add 1234 2
+./keystone-manage $* endpoint add 1234 3
+./keystone-manage $* endpoint add 1234 4
+./keystone-manage $* endpoint add 1234 5
+./keystone-manage $* endpoint add 1234 6
diff --git a/keystone/db/sqlalchemy/api/__init__.py b/keystone/db/sqlalchemy/api/__init__.py
index 7741861c..657621a6 100644
--- a/keystone/db/sqlalchemy/api/__init__.py
+++ b/keystone/db/sqlalchemy/api/__init__.py
@@ -1 +1 @@
-import baseurl, group, role, tenant_group, tenant, token, user
+import endpoint_template, group, role, tenant_group, tenant, token, user
diff --git a/keystone/db/sqlalchemy/api/baseurl.py b/keystone/db/sqlalchemy/api/endpoint_template.py
index 3a046c22..f09479e5 100644..100755
--- a/keystone/db/sqlalchemy/api/baseurl.py
+++ b/keystone/db/sqlalchemy/api/endpoint_template.py
@@ -18,23 +18,23 @@
 from keystone.db.sqlalchemy import get_session, models, aliased
 
 def create(values):
-    baseurls_ref = models.BaseUrls()
-    baseurls_ref.update(values)
-    baseurls_ref.save()
-    return baseurls_ref
+    endpoint_template = models.EndpointTemplates()
+    endpoint_template.update(values)
+    endpoint_template.save()
+    return endpoint_template
 
 
 def get(id, session=None):
     if not session:
         session = get_session()
-    result = session.query(models.BaseUrls).filter_by(id=id).first()
+    result = session.query(models.EndpointTemplates).filter_by(id=id).first()
     return result
 
 
 def get_all(session=None):
     if not session:
         session = get_session()
-    return session.query(models.BaseUrls).all()
+    return session.query(models.EndpointTemplates).all()
 
 
 def get_page(marker, limit, session=None):
@@ -42,31 +42,31 @@ def get_page(marker, limit, session=None):
         session = get_session()
 
     if marker:
-        return session.query(models.BaseUrls).filter("id>:marker").params(\
+        return session.query(models.EndpointTemplates).filter("id>:marker").params(\
                 marker='%s' % marker).order_by(\
-                models.BaseUrls.id.desc()).limit(limit).all()
+                models.EndpointTemplates.id.desc()).limit(limit).all()
     else:
-        return session.query(models.BaseUrls).order_by(\
-                            models.BaseUrls.id.desc()).limit(limit).all()
+        return session.query(models.EndpointTemplates).order_by(\
+                            models.EndpointTemplates.id.desc()).limit(limit).all()
 
 
 def get_page_markers(marker, limit, session=None):
     if not session:
         session = get_session()
-    first = session.query(models.BaseUrls).order_by(\
-                        models.BaseUrls.id).first()
-    last = session.query(models.BaseUrls).order_by(\
-                        models.BaseUrls.id.desc()).first()
+    first = session.query(models.EndpointTemplates).order_by(\
+                        models.EndpointTemplates.id).first()
+    last = session.query(models.EndpointTemplates).order_by(\
+                        models.EndpointTemplates.id.desc()).first()
     if first is None:
         return (None, None)
     if marker is None:
         marker = first.id
-    next = session.query(models.BaseUrls).filter("id > :marker").params(\
+    next = session.query(models.EndpointTemplates).filter("id > :marker").params(\
                     marker='%s' % marker).order_by(\
-                    models.BaseUrls.id).limit(limit).all()
-    prev = session.query(models.BaseUrls).filter("id < :marker").params(\
+                    models.EndpointTemplates.id).limit(limit).all()
+    prev = session.query(models.EndpointTemplates).filter("id < :marker").params(\
                     marker='%s' % marker).order_by(\
-                    models.BaseUrls.id.desc()).limit(int(limit)).all()
+                    models.EndpointTemplates.id.desc()).limit(int(limit)).all()
     if len(next) == 0:
         next = last
     else:
@@ -88,27 +88,27 @@ def get_page_markers(marker, limit, session=None):
     return (prev, next)
 
 
-def ref_get_by_tenant_get_page(tenant_id, marker, limit,
+def endpoint_get_by_tenant_get_page(tenant_id, marker, limit,
                                         session=None):
     if not session:
         session = get_session()
     if marker:
-        return session.query(models.TenantBaseURLAssociation).\
-            filter(models.TenantBaseURLAssociation.tenant_id == tenant_id).\
+        return session.query(models.Endpoints).\
+            filter(models.Endpoints.tenant_id == tenant_id).\
             filter("id >= :marker").params(
             marker='%s' % marker).order_by(
-            models.TenantBaseURLAssociation.id).limit(limit).all()
+            models.Endpoints.id).limit(limit).all()
     else:
-        return session.query(models.TenantBaseURLAssociation).\
-            filter(models.TenantBaseURLAssociation.tenant_id == tenant_id).\
-            order_by(models.TenantBaseURLAssociation.id).limit(limit).all()
+        return session.query(models.Endpoints).\
+            filter(models.Endpoints.tenant_id == tenant_id).\
+            order_by(models.Endpoints.id).limit(limit).all()
 
 
-def ref_get_by_tenant_get_page_markers(tenant_id, marker, limit,
+def endpoint_get_by_tenant_get_page_markers(tenant_id, marker, limit,
                                                 session=None):
     if not session:
         session = get_session()
-    tba = aliased(models.TenantBaseURLAssociation)
+    tba = aliased(models.Endpoints)
     first = session.query(tba).\
                     filter(tba.tenant_id == tenant_id).\
                     order_by(tba.id).first()
@@ -154,32 +154,32 @@ def ref_get_by_tenant_get_page_markers(tenant_id, marker, limit,
     return (prev, next)
 
 
-def ref_add(values):
-    baseurls_ref = models.TenantBaseURLAssociation()
-    baseurls_ref.update(values)
-    baseurls_ref.save()
-    return baseurls_ref
+def endpoint_add(values):
+    endpoints = models.Endpoints()
+    endpoints.update(values)
+    endpoints.save()
+    return endpoints
 
 
-def ref_get(id, session=None):
+def endpoint_get(id, session=None):
     if not session:
         session = get_session()
-    result = session.query(models.TenantBaseURLAssociation).\
+    result = session.query(models.Endpoints).\
                     filter_by(id=id).first()
     return result
 
 
-def ref_get_by_tenant(tenant_id, session=None):
+def endpoint_get_by_tenant(tenant_id, session=None):
     if not session:
         session = get_session()
-    result = session.query(models.TenantBaseURLAssociation).\
+    result = session.query(models.Endpoints).\
                     filter_by(tenant_id=tenant_id).first()
     return result
 
 
-def ref_delete(id, session=None):
+def endpoint_delete(id, session=None):
     if not session:
         session = get_session()
     with session.begin():
-        baseurls_ref = ref_get(id, session)
-        session.delete(baseurls_ref)
+        endpoints = endpoint_get(id, session)
+        session.delete(endpoints)
diff --git a/keystone/db/sqlalchemy/api/tenant.py b/keystone/db/sqlalchemy/api/tenant.py
index 2af370a0..a4c1fd49 100755
--- a/keystone/db/sqlalchemy/api/tenant.py
+++ b/keystone/db/sqlalchemy/api/tenant.py
@@ -181,14 +181,14 @@ def delete(id, session=None):
         session.delete(tenant_ref)
 
 
-def get_all_baseurls(tenant_id, session=None):
+def get_all_endpoints(tenant_id, session=None):
     if not session:
         session = get_session()
-    tba = aliased(models.TenantBaseURLAssociation)
-    baseUrls = aliased(models.BaseUrls)
-    return session.query(baseUrls).join((tba,
-        tba.baseURLs_id == baseUrls.id)).\
-            filter(tba.tenant_id == tenant_id).all()
+    ep = aliased(models.Endpoints)
+    endpointTemplates = aliased(models.EndpointTemplates)
+    return session.query(endpointTemplates).join((ep,
+        ep.endpoint_template_id == endpointTemplates.id)).\
+            filter(ep.tenant_id == tenant_id).all()
 
 def get_role_assignments(tenant_id, session=None):
     if not session:
diff --git a/keystone/db/sqlalchemy/models.py b/keystone/db/sqlalchemy/models.py
index 59d885f1..bbf02aa7 100644..100755
--- a/keystone/db/sqlalchemy/models.py
+++ b/keystone/db/sqlalchemy/models.py
@@ -93,12 +93,12 @@ class UserRoleAssociation(Base, KeystoneBase):
     __table_args__ = (UniqueConstraint("user_id", "role_id", "tenant_id"), {})
 
 
-class TenantBaseURLAssociation(Base, KeystoneBase):
-    __tablename__ = 'tenant_baseURLs'
+class Endpoints(Base, KeystoneBase):
+    __tablename__ = 'endpoints'
     id = Column(Integer, primary_key=True)
     tenant_id = Column(String(255), ForeignKey('tenants.id'))
-    baseURLs_id = Column(Integer, ForeignKey('urlbase.id'))
-    __table_args__ = (UniqueConstraint("baseURLs_id", "tenant_id"), {})
+    endpoint_template_id = Column(Integer, ForeignKey('endpoint_templates.id'))
+    __table_args__ = (UniqueConstraint("endpoint_template_id", "tenant_id"), {})
 
 
 # Define objects
@@ -116,7 +116,7 @@ class Tenant(Base, KeystoneBase):
     desc = Column(String(255))
     enabled = Column(Integer)
     groups = relationship('Group', backref='tenants')
-    endpoints = relationship('TenantBaseURLAssociation', backref='tenant',
+    endpoints = relationship('Endpoints', backref='tenant',
                              cascade="all")
 
 
@@ -159,8 +159,8 @@ class Token(Base, KeystoneBase):
     expires = Column(DateTime)
 
 
-class BaseUrls(Base, KeystoneBase):
-    __tablename__ = 'urlbase'
+class EndpointTemplates(Base, KeystoneBase):
+    __tablename__ = 'endpoint_templates'
 
     id = Column(Integer, primary_key=True)
     region = Column(String(255))
diff --git a/keystone/logic/service.py b/keystone/logic/service.py
index 0506d98f..9a873726 100755
--- a/keystone/logic/service.py
+++ b/keystone/logic/service.py
@@ -25,7 +25,7 @@ import keystone.logic.types.fault as fault
 import keystone.logic.types.tenant as tenants
 import keystone.logic.types.role as roles
 import keystone.logic.types.user as get_users
-import keystone.logic.types.baseURL as baseURLs
+import keystone.logic.types.endpoint as endpoints
 import keystone.utils as utils
 
 class IdentityService(object):
@@ -850,11 +850,11 @@ class IdentityService(object):
 
     def __get_auth_data(self, dtoken, tenant_id):
         """return AuthData object for a token"""
-        base_urls = None
+        endpoints = None
         if tenant_id != None:
-            base_urls = db_api.tenant.get_all_baseurls(tenant_id)
+            endpoints = db_api.tenant.get_all_endpoints(tenant_id)
         token = auth.Token(dtoken.expires, dtoken.id, tenant_id)
-        return auth.AuthData(token, base_urls)
+        return auth.AuthData(token, endpoints)
 
     def __get_validate_data(self, dtoken, duser):
         """return ValidateData object for a token/user pair"""
@@ -998,18 +998,18 @@ class IdentityService(object):
                                                 % (url, next, limit)))
         return roles.RoleRefs(ts, links)
 
-    def get_baseurls(self, admin_token, marker, limit, url):
+    def get_endpoint_templates(self, admin_token, marker, limit, url):
         self.__validate_token(admin_token)
 
         ts = []
-        dbaseurls = db_api.baseurl.get_page(marker, limit)
-        for dbaseurl in dbaseurls:
-            ts.append(baseURLs.BaseURL(dbaseurl.id, dbaseurl.region,
-                                       dbaseurl.service, dbaseurl.public_url,
-                                       dbaseurl.admin_url,
-                                       dbaseurl.internal_url,
-                                       dbaseurl.enabled))
-        prev, next = db_api.baseurl.get_page_markers(marker, limit)
+        dendpointTemplates = db_api.endpoint_template.get_page(marker, limit)
+        for dendpointTemplate in dendpointTemplates:
+            ts.append(endpoints.EndpointTemplate(dendpointTemplate.id, dendpointTemplate.region,
+                                       dendpointTemplate.service, dendpointTemplate.public_url,
+                                       dendpointTemplate.admin_url,
+                                       dendpointTemplate.internal_url,
+                                       dendpointTemplate.enabled))
+        prev, next = db_api.endpoint_template.get_page_markers(marker, limit)
         links = []
         if prev:
             links.append(atom.Link('prev', "%s?'marker=%s&limit=%s'" \
@@ -1017,19 +1017,19 @@ class IdentityService(object):
         if next:
             links.append(atom.Link('next', "%s?'marker=%s&limit=%s'" \
                                                 % (url, next, limit)))
-        return baseURLs.BaseURLs(ts, links)
+        return endpoints.EndpointTemplates(ts, links)
 
-    def get_baseurl(self, admin_token, baseurl_id):
+    def get_endpoint_template(self, admin_token, endpoint_template_id):
         self.__validate_token(admin_token)
 
-        dbaseurl = db_api.baseurl.get(baseurl_id)
-        if not dbaseurl:
-            raise fault.ItemNotFoundFault("The base URL could not be found")
-        return baseURLs.BaseURL(dbaseurl.id, dbaseurl.region, dbaseurl.service,
-                                dbaseurl.public_url, dbaseurl.admin_url,
-                                dbaseurl.internal_url, dbaseurl.enabled)
+        dendpointTemplate = db_api.endpoint_template.get(endpoint_template_id)
+        if not dendpointTemplate:
+            raise fault.ItemNotFoundFault("The endpoint template could not be found")
+        return endpoints.EndpointTemplate(dendpointTemplate.id, dendpointTemplate.region, dendpointTemplate.service,
+                                dendpointTemplate.public_url, dendpointTemplate.admin_url,
+                                dendpointTemplate.internal_url, dendpointTemplate.enabled)
 
-    def get_tenant_baseURLs(self, admin_token, marker, limit, url, tenant_id):
+    def get_tenant_endpoints(self, admin_token, marker, limit, url, tenant_id):
         self.__validate_token(admin_token)
         if tenant_id == None:
             raise fault.BadRequestFault("Expecting a Tenant Id")
@@ -1039,17 +1039,17 @@ class IdentityService(object):
 
         ts = []
 
-        dtenantBaseURLAssociations = \
-            db_api.baseurl.ref_get_by_tenant_get_page(tenant_id, marker,
+        dtenantEndpoints = \
+            db_api.endpoint_template.endpoint_get_by_tenant_get_page(tenant_id, marker,
                                                           limit)
-        for dtenantBaseURLAssociation in dtenantBaseURLAssociations:
-            ts.append(baseURLs.BaseURLRef(dtenantBaseURLAssociation.id,
-                    url + '/baseURLs/' + \
-                    str(dtenantBaseURLAssociation.baseURLs_id)))
+        for dtenantEndpoint in dtenantEndpoints:
+            ts.append(endpoints.Endpoint(dtenantEndpoint.id,
+                    url + '/endpointTemplates/' + \
+                    str(dtenantEndpoint.endpoint_template_id)))
         links = []
         if ts.__len__():
             prev, next = \
-                db_api.baseurl.ref_get_by_tenant_get_page_markers(tenant_id,
+                db_api.endpoint_template.endpoint_get_by_tenant_get_page_markers(tenant_id,
                                                         marker, limit)
             if prev:
                 links.append(atom.Link('prev', "%s?'marker=%s&limit=%s'" % 
@@ -1057,10 +1057,10 @@ class IdentityService(object):
             if next:
                 links.append(atom.Link('next', "%s?'marker=%s&limit=%s'" % 
                                       (url, next, limit)))
-        return baseURLs.BaseURLRefs(ts, links)
+        return endpoints.Endpoints(ts, links)
 
-    def create_baseurl_ref_to_tenant(self, admin_token,
-                                     tenant_id, baseurl, url):
+    def create_endpoint_for_tenant(self, admin_token,
+                                     tenant_id, endpoint_template, url):
         self.__validate_token(admin_token)
         if tenant_id == None:
             raise fault.BadRequestFault("Expecting a Tenant Id")
@@ -1068,19 +1068,19 @@ class IdentityService(object):
         if db_api.tenant.get(tenant_id) == None:
             raise fault.ItemNotFoundFault("The tenant not found")
 
-        dbaseurl = db_api.baseurl.get(baseurl.id)
-        if not dbaseurl:
-            raise fault.ItemNotFoundFault("The base URL could not be found")
-        dbaseurl_ref = db_models.TenantBaseURLAssociation()
-        dbaseurl_ref.tenant_id = tenant_id
-        dbaseurl_ref.baseURLs_id = baseurl.id
-        dbaseurl_ref = db_api.baseurl.ref_add(dbaseurl_ref)
-        baseurlRef = baseURLs.BaseURLRef(dbaseurl_ref.id, url + \
-                                         '/baseURLs/' + \
-                                         dbaseurl_ref.baseURLs_id)
-        return baseurlRef
-
-    def delete_baseurls_ref(self, admin_token, baseurls_id):
+        dendpoint_template = db_api.endpoint_template.get(endpoint_template.id)
+        if not dendpoint_template:
+            raise fault.ItemNotFoundFault("The endpoint template could not be found")
+        dendpoint = db_models.Endpoints()
+        dendpoint.tenant_id = tenant_id
+        dendpoint.endpoints_template_id = endpoint_template.id
+        dendpoint = db_api.endpoint_template.endpoint_add(dendpoint)
+        dendpoint = endpoints.Endpoint(dendpoint.id, url + \
+                                         '/endpointTemplates/' + \
+                                         dendpoint.endpoints_template_id)
+        return dendpoint
+
+    def delete_endpoint(self, admin_token, endpoint_id):
         self.__validate_token(admin_token)
-        db_api.baseurl.ref_delete(baseurls_id)
+        db_api.endpoint_template.endpoint_delete(endpoint_id)
         return None
diff --git a/keystone/logic/types/baseURL.py b/keystone/logic/types/endpoint.py
index c73536bf..a2d9ee58 100644
--- a/keystone/logic/types/baseURL.py
+++ b/keystone/logic/types/endpoint.py
@@ -20,16 +20,16 @@ import string
 import keystone.logic.types.fault as fault
 
 
-class BaseURL(object):
+class EndpointTemplate(object):
     @staticmethod
     def from_xml(xml_str):
         try:
             dom = etree.Element("root")
             dom.append(etree.fromstring(xml_str))
             root = dom.find("{http://docs.openstack.org/identity/api/v2.0}" \
-                            "baseURL")
+                            "endpointTemplate")
             if root == None:
-                raise fault.BadRequestFault("Expecting baseURL")
+                raise fault.BadRequestFault("Expecting endpointTemplate")
             id = root.get("id")
             region = root.get("region")
             service = root.get("serviceName")
@@ -37,10 +37,10 @@ class BaseURL(object):
             admin_url = root.get("adminURL")
             internal_url = root.get("internalURL")
             enabled = root.get("enabled")
-            return BaseURL(id, region, service, public_url, admin_url,
+            return EndpointTemplate(id, region, service, public_url, admin_url,
                            internal_url, enabled)
         except etree.LxmlError as e:
-            raise fault.BadRequestFault("Cannot parse baseURL", str(e))
+            raise fault.BadRequestFault("Cannot parse endpointTemplate", str(e))
 
     @staticmethod
     def from_json(json_str):
@@ -53,33 +53,33 @@ class BaseURL(object):
             internal_url = None
             enabled = None
 
-            if not "baseURL" in obj:
-                raise fault.BadRequestFault("Expecting baseURL")
-            baseURL = obj["baseURL"]
-            if not "id" in baseURL:
+            if not "endpointTemplate" in obj:
+                raise fault.BadRequestFault("Expecting endpointTemplate")
+            endpoint_template = obj["endpointTemplate"]
+            if not "id" in endpoint_template:
                 id = None
             else:
-                id = baseURL["id"]
+                id = endpoint_template["id"]
             if id == None:
-                raise fault.BadRequestFault("Expecting BaseURL")
-
-            if 'region' in baseURL:
-                region = baseURL["region"]
-            if 'serviceName' in baseURL:
-                service = baseURL["serviceName"]
-            if 'publicURL' in baseURL:
-                public_url = baseURL["publicURL"]
-            if 'adminURL' in baseURL:
-                admin_url = baseURL["adminURL"]
-            if 'internalURL' in baseURL:
-                internal_url = baseURL["internalURL"]
-            if 'enabled' in baseURL:
-                enabled = baseURL["enabled"]
-
-            return BaseURL(id, region, service, public_url, admin_url,
+                raise fault.BadRequestFault("Expecting endpointTemplate")
+
+            if 'region' in endpoint_template:
+                region = endpoint_template["region"]
+            if 'serviceName' in endpoint_template:
+                service = endpoint_template["serviceName"]
+            if 'publicURL' in endpoint_template:
+                public_url = endpoint_template["publicURL"]
+            if 'adminURL' in endpoint_template:
+                admin_url = endpoint_template["adminURL"]
+            if 'internalURL' in endpoint_template:
+                internal_url = endpoint_template["internalURL"]
+            if 'enabled' in endpoint_template:
+                enabled = endpoint_template["enabled"]
+
+            return EndpointTemplate(id, region, service, public_url, admin_url,
                            internal_url, enabled)
         except (ValueError, TypeError) as e:
-            raise fault.BadRequestFault("Cannot parse baseURL", str(e))
+            raise fault.BadRequestFault("Cannot parse endpointTemplate", str(e))
 
     def __init__(self, id, region, service, public_url, admin_url,
                  internal_url, enabled):
@@ -92,7 +92,7 @@ class BaseURL(object):
         self.enabled = enabled
 
     def to_dom(self):
-        dom = etree.Element("baseURL",
+        dom = etree.Element("endpointTemplate",
                         xmlns="http://docs.openstack.org/identity/api/v2.0")
         if self.id:
             dom.set("id", str(self.id))
@@ -114,36 +114,36 @@ class BaseURL(object):
         return etree.tostring(self.to_dom())
 
     def to_dict(self):
-        baseURL = {}
+        endpoint_template = {}
         if self.id:
-            baseURL["id"] = self.id
+            endpoint_template["id"] = self.id
         if self.region:
-            baseURL["region"] = self.region
+            endpoint_template["region"] = self.region
         if self.service:
-            baseURL["serviceName"] = self.service
+            endpoint_template["serviceName"] = self.service
         if self.public_url:
-            baseURL["publicURL"] = self.public_url
+            endpoint_template["publicURL"] = self.public_url
         if self.admin_url:
-            baseURL["adminURL"] = self.admin_url
+            endpoint_template["adminURL"] = self.admin_url
         if self.internal_url:
-            baseURL["internalURL"] = self.internal_url
+            endpoint_template["internalURL"] = self.internal_url
         if self.enabled:
-            baseURL["enabled"] = self.enabled
-        return {'baseURL': baseURL}
+            endpoint_template["enabled"] = self.enabled
+        return {'endpointTemplate': endpoint_template}
 
     def to_json(self):
         return json.dumps(self.to_dict())
 
 
-class BaseURLs(object):
-    "A collection of baseURls."
+class EndpointTemplates(object):
+    "A collection of endpointTemplates."
 
     def __init__(self, values, links):
         self.values = values
         self.links = links
 
     def to_xml(self):
-        dom = etree.Element("baseURLs")
+        dom = etree.Element("endpointTemplates")
         dom.set(u"xmlns", "http://docs.openstack.org/identity/api/v2.0")
 
         for t in self.values:
@@ -155,18 +155,18 @@ class BaseURLs(object):
         return etree.tostring(dom)
 
     def to_json(self):
-        values = [t.to_dict()["baseURL"] for t in self.values]
+        values = [t.to_dict()["endpointTemplate"] for t in self.values]
         links = [t.to_dict()["links"] for t in self.links]
-        return json.dumps({"baseURLs": {"values": values, "links": links}})
+        return json.dumps({"endpointTemplates": {"values": values, "links": links}})
 
 
-class BaseURLRef(object):
+class Endpoint(object):
     def __init__(self, id, href):
         self.id = id
         self.href = href
 
     def to_dom(self):
-        dom = etree.Element("baseURLRef",
+        dom = etree.Element("endpoint",
                         xmlns="http://docs.openstack.org/identity/api/v2.0")
         if self.id:
             dom.set("id", str(self.id))
@@ -178,26 +178,26 @@ class BaseURLRef(object):
         return etree.tostring(self.to_dom())
 
     def to_dict(self):
-        baseURLRef = {}
+        endpoint = {}
         if self.id:
-            baseURLRef["id"] = self.id
+            endpoint["id"] = self.id
         if self.href:
-            baseURLRef["href"] = self.href
-        return {'baseURLRef': baseURLRef}
+            endpoint["href"] = self.href
+        return {'endpoint': endpoint}
 
     def to_json(self):
         return json.dumps(self.to_dict())
 
 
-class BaseURLRefs(object):
-    "A collection of baseURlRefs."
+class Endpoints(object):
+    "A collection of endpoints."
 
     def __init__(self, values, links):
         self.values = values
         self.links = links
 
     def to_xml(self):
-        dom = etree.Element("baseURLRefs")
+        dom = etree.Element("endpoints")
         dom.set(u"xmlns", "http://docs.openstack.org/identity/api/v2.0")
 
         for t in self.values:
@@ -209,6 +209,6 @@ class BaseURLRefs(object):
         return etree.tostring(dom)
 
     def to_json(self):
-        values = [t.to_dict()["baseURLRef"] for t in self.values]
+        values = [t.to_dict()["endpoint"] for t in self.values]
         links = [t.to_dict()["links"] for t in self.links]
-        return json.dumps({"baseURLRefs": {"values": values, "links": links}})
+        return json.dumps({"endpoints": {"values": values, "links": links}})
diff --git a/keystone/server.py b/keystone/server.py
index fc8b24d1..a36234bb 100755
--- a/keystone/server.py
+++ b/keystone/server.py
@@ -53,7 +53,7 @@ import keystone.db.sqlalchemy as db
 import keystone.logic.service as serv
 import keystone.logic.types.tenant as tenants
 import keystone.logic.types.role as roles
-import keystone.logic.types.baseURL as baseURLs
+import keystone.logic.types.endpoint as endpoints
 import keystone.logic.types.auth as auth
 import keystone.logic.types.user as users
 import keystone.common.template as template
@@ -453,46 +453,46 @@ class RolesController(wsgi.Controller):
         return utils.send_result(204, req, rval)
 
 
-class BaseURLsController(wsgi.Controller):
+class EndpointTemplatesController(wsgi.Controller):
     """
-        BaseURL Controller -
-        Controller for BaseURL related operations
+        EndpointTemplatesController Controller -
+        Controller for EndpointTemplates related operations
     """
 
     def __init__(self, options):
         self.options = options
 
     @utils.wrap_error
-    def get_baseurls(self, req):
+    def get_endpoint_templates(self, req):
         marker, limit, url = get_marker_limit_and_url(req)
-        baseURLs = service.get_baseurls(utils.get_auth_token(req),
+        endpoint_templates = service.get_endpoint_templates(utils.get_auth_token(req),
                                          marker, limit, url)
-        return utils.send_result(200, req, baseURLs)
+        return utils.send_result(200, req, endpoint_templates)
 
     @utils.wrap_error
-    def get_baseurl(self, req, baseURLId):
-        baseurl = service.get_baseurl(utils.get_auth_token(req), baseURLId)
-        return utils.send_result(200, req, baseurl)
+    def get_endpoint_template(self, req, endpoint_templates_id):
+        endpoint_template = service.get_endpoint_template(utils.get_auth_token(req), endpoint_templates_id)
+        return utils.send_result(200, req, endpoint_template)
 
     @utils.wrap_error
-    def get_baseurls_for_tenant(self, req, tenant_id):
+    def get_endpoints_for_tenant(self, req, tenant_id):
         marker, limit, url = get_marker_limit_and_url(req)
-        baseURLRefs = service.get_tenant_baseURLs(utils.get_auth_token(req),
+        endpoints = service.get_tenant_endpoints(utils.get_auth_token(req),
                                          marker, limit, url, tenant_id)
-        return utils.send_result(200, req, baseURLRefs)
+        return utils.send_result(200, req, endpoints)
 
     @utils.wrap_error
-    def add_baseurls_to_tenant(self, req, tenant_id):
-        baseurl = utils.get_normalized_request_content(baseURLs.BaseURL, req)
+    def add_endpoint_to_tenant(self, req, tenant_id):
+        endpoint = utils.get_normalized_request_content(endpoints.EndpointTemplate, req)
         return utils.send_result(201, req,
-                       service.create_baseurl_ref_to_tenant(
+                       service.create_endpoint_for_tenant(
                                             utils.get_auth_token(req),
-                                            tenant_id, baseurl, get_url(req)))
+                                            tenant_id, endpoint, get_url(req)))
 
     @utils.wrap_error
-    def remove_baseurls_from_tenant(self, req, tenant_id, baseurls_ref_id):
-        rval = service.delete_baseurls_ref(utils.get_auth_token(req),
-                                        baseurls_ref_id)
+    def remove_endpoint_from_tenant(self, req, tenant_id, endpoints_id):
+        rval = service.delete_endpoint(utils.get_auth_token(req),
+                                        endpoints_id)
         return utils.send_result(204, req, rval)
 
 
@@ -740,25 +740,25 @@ class KeystoneAdminAPI(wsgi.Router):
             controller=roles_controller, action="delete_role_ref",
             conditions=dict(method=["DELETE"]))
 
-        #BaseURLs and BaseURLRefs
-        baseurls_controller = BaseURLsController(options)
-        mapper.connect("/v2.0/baseURLs", controller=baseurls_controller,
-                    action="get_baseurls", conditions=dict(method=["GET"]))
-        mapper.connect("/v2.0/baseURLs/{baseURLId}",
-                       controller=baseurls_controller,
-                    action="get_baseurl", conditions=dict(method=["GET"]))
-        mapper.connect("/v2.0/tenants/{tenant_id}/baseURLRefs",
-                       controller=baseurls_controller,
-                    action="get_baseurls_for_tenant",
+        #EndpointTemplatesControllers and Endpoints
+        endpoint_templates_controller = EndpointTemplatesController(options)
+        mapper.connect("/v2.0/endpointTemplates", controller=endpoint_templates_controller,
+                    action="get_endpoint_templates", conditions=dict(method=["GET"]))
+        mapper.connect("/v2.0/endpointTemplates/{endpoint_templates_id}",
+                       controller=endpoint_templates_controller,
+                    action="get_endpoint_template", conditions=dict(method=["GET"]))
+        mapper.connect("/v2.0/tenants/{tenant_id}/endpoints",
+                       controller=endpoint_templates_controller,
+                    action="get_endpoints_for_tenant",
                     conditions=dict(method=["GET"]))
-        mapper.connect("/v2.0/tenants/{tenant_id}/baseURLRefs",
-                       controller=baseurls_controller,
-                     action="add_baseurls_to_tenant",
+        mapper.connect("/v2.0/tenants/{tenant_id}/endpoints",
+                       controller=endpoint_templates_controller,
+                     action="add_endpoint_to_tenant",
                      conditions=dict(method=["POST"]))
         mapper.connect(
-                "/v2.0/tenants/{tenant_id}/baseURLRefs/{baseurls_ref_id}",
-                controller=baseurls_controller,
-                action="remove_baseurls_from_tenant",
+                "/v2.0/tenants/{tenant_id}/endpoints/{endpoints_id}",
+                controller=endpoint_templates_controller,
+                action="remove_endpoint_from_tenant",
                 conditions=dict(method=["DELETE"]))
 
         # Miscellaneous Operations
diff --git a/keystone/test/unit/test_authentication.py b/keystone/test/unit/test_authentication.py
index 96bf271b..5f2c570c 100755
--- a/keystone/test/unit/test_authentication.py
+++ b/keystone/test/unit/test_authentication.py
@@ -37,19 +37,19 @@ class AuthenticationTest(unittest.TestCase):
         #self.user = utils.get_user()
         self.userdisabled = utils.get_userdisabled()
         self.auth_token = utils.get_auth_token()
-        utils.create_baseurls_ref(self.tenant, "1",
+        utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
-        utils.create_baseurls_ref(self.tenant, "2",
+        utils.create_endpoint(self.tenant, "2",
             str(self.auth_token))
-        utils.create_baseurls_ref(self.tenant, "3",
+        utils.create_endpoint(self.tenant, "3",
             str(self.auth_token))
-        utils.create_baseurls_ref(self.tenant, "4",
+        utils.create_endpoint(self.tenant, "4",
             str(self.auth_token))
         #self.exp_auth_token = utils.get_exp_auth_token()
         #self.disabled_token = utils.get_disabled_token()
 
     def tearDown(self):
-        utils.delete_all_baseurls_ref(self.tenant, self.auth_token)
+        utils.delete_all_endpoint(self.tenant, self.auth_token)
         utils.delete_token(self.token, self.auth_token)
 
     def test_a_authorize(self):
@@ -86,8 +86,8 @@ class AuthenticationTest(unittest.TestCase):
         resp, content = utils.get_token_legacy('joeuser', 'secrete')
         self.assertEqual(204, int(resp['status']))
         self.assertTrue(resp['x-auth-token'])
-        self.assertTrue(resp['x-server-management-url'])
-        self.assertTrue(resp['x-storage-url'])
+        #self.assertTrue(resp['x-server-management-url'])
+        #self.assertTrue(resp['x-storage-url'])
         self.assertTrue(resp['x-glance'])
 
     def test_a_authorize_user_disabled(self):
diff --git a/keystone/test/unit/test_common.py b/keystone/test/unit/test_common.py
index bfad2d62..06409937 100755
--- a/keystone/test/unit/test_common.py
+++ b/keystone/test/unit/test_common.py
@@ -778,32 +778,32 @@ def create_role_xml(role_id, auth_token):
                                        "ACCEPT": "application/xml"})
     return (resp, content)
     
-def create_baseurls_ref(tenant_id, baseurl_id, auth_token):
+def create_endpoint(tenant_id, endpoint_templates_id, auth_token):
     header = httplib2.Http(".cache")
 
-    url = '%stenants/%s/baseURLRefs' % (URL, tenant_id)
-    body = {"baseURL": {"id": baseurl_id}}
+    url = '%stenants/%s/endpoints' % (URL, tenant_id)
+    body = {"endpointTemplate": {"id": endpoint_templates_id}}
     resp, content = header.request(url, "POST", body=json.dumps(body),
                               headers={"Content-Type": "application/json",
                                        "X-Auth-Token": auth_token})
     return (resp, content)
     
-def create_baseurls_ref_xml(tenant_id, baseurl_id, auth_token):
+def create_endpoint_xml(tenant_id, endpoint_templates_id, auth_token):
     header = httplib2.Http(".cache")
-    url = '%stenants/%s/baseURLRefs' % (URL, tenant_id)
+    url = '%stenants/%s/endpoints' % (URL, tenant_id)
     body = '<?xml version="1.0" encoding="UTF-8"?>\
-            <baseURL xmlns="http://docs.openstack.org/identity/api/v2.0" \
+            <endpointTemplate xmlns="http://docs.openstack.org/identity/api/v2.0" \
             id="%s"/>\
-                    ' % (baseurl_id)
+                    ' % (endpoint_templates_id)
     resp, content = header.request(url, "POST", body=body,
                               headers={"Content-Type": "application/xml",
                                        "X-Auth-Token": auth_token,
                                        "ACCEPT": "application/xml"})
     return (resp, content)
    
-def delete_all_baseurls_ref(tenant_id, auth_token):
+def delete_all_endpoint(tenant_id, auth_token):
     header = httplib2.Http(".cache")
-    url = '%stenants/%s/baseURLRefs' % (URL, tenant_id)
+    url = '%stenants/%s/endpoints' % (URL, tenant_id)
     #test for Content-Type = application/json
     resp, content = header.request(url, "GET", body='{}',
                               headers={"Content-Type": "application/json",
@@ -817,9 +817,9 @@ def delete_all_baseurls_ref(tenant_id, auth_token):
     
     #verify content
     obj = json.loads(content)
-    base_url_refs = obj["baseURLRefs"]["values"]
-    for base_url_ref in base_url_refs:
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, tenant_id, base_url_ref["id"])
+    endpoints = obj["endpoints"]["values"]
+    for endpoint in endpoints:
+        url = '%stenants/%s/endpoints/%s' % (URL, tenant_id, endpoint["id"])
         header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(auth_token)})
diff --git a/keystone/test/unit/test_BaseURLs.py b/keystone/test/unit/test_endpoints.py
index 5cc99ff9..8a9a32cf 100755
--- a/keystone/test/unit/test_BaseURLs.py
+++ b/keystone/test/unit/test_endpoints.py
@@ -29,7 +29,7 @@ from test_common import URL
 
 from keystone.logic.types import fault
 
-class BaseURLsTest(unittest.TestCase):
+class EndpointTemplatesTest(unittest.TestCase):
     def setUp(self):
         self.tenant = utils.get_tenant()
         self.password = utils.get_password()
@@ -49,12 +49,12 @@ class BaseURLsTest(unittest.TestCase):
     def tearDown(self):
         utils.delete_user(self.user, self.auth_token)
         utils.delete_tenant(self.tenant, self.auth_token)
-        utils.delete_all_baseurls_ref(self.tenant, self.auth_token)
+        utils.delete_all_endpoint(self.tenant, self.auth_token)
 
-class GetBaseURLsTest(BaseURLsTest):
-    def test_get_baseURLs(self):
+class GetEndpointTemplatesTest(EndpointTemplatesTest):
+    def test_get_endpoint_templates(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -67,12 +67,12 @@ class GetBaseURLsTest(BaseURLsTest):
         
         #verify content
         obj = json.loads(content)
-        if not "baseURLs" in obj:
-            raise self.fail("Expecting BaseURLs")
+        if not "endpointTemplates" in obj:
+            raise self.fail("Expecting endpointTemplates")
 
-    def test_get_baseURLs_using_expired_auth_token(self):
+    def test_get_endpoint_templates_using_expired_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -83,9 +83,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403 , int(resp['status']))            
 
-    def test_get_baseURLs_using_disabled_auth_token(self):
+    def test_get_endpoint_templates_using_disabled_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -96,9 +96,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403 , int(resp['status']))
 
-    def test_get_baseURLs_using_missing_auth_token(self):
+    def test_get_endpoint_templates_using_missing_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -109,9 +109,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(401 , int(resp['status']))
 
-    def test_get_baseURLs_using_invalid_auth_token(self):
+    def test_get_endpoint_templates_using_invalid_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -122,9 +122,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(404 , int(resp['status']))
 
-    def test_get_baseURLs_xml(self):
+    def test_get_endpoint_templates_xml(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -139,14 +139,14 @@ class GetBaseURLsTest(BaseURLsTest):
         #verify content
         dom = etree.Element("root")
         dom.append(etree.fromstring(content))
-        baseURLs = dom.find("{http://docs.openstack.org/identity/api/v2.0}" \
-            "baseURLs")
-        if baseURLs == None:
-            self.fail("Expecting BaseURLs")
+        endpoint_templates = dom.find("{http://docs.openstack.org/identity/api/v2.0}" \
+            "endpointTemplates")
+        if endpoint_templates == None:
+            self.fail("Expecting endpointTemplates")
 
-    def test_get_baseURLs_xml_expired_auth_token(self):
+    def test_get_endpoint_templates_xml_expired_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -158,9 +158,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
         
-    def test_get_baseURLs_xml_disabled_auth_token(self):
+    def test_get_endpoint_templates_xml_disabled_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -172,9 +172,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
-    def test_get_baseURLs_xml_missing_auth_token(self):
+    def test_get_endpoint_templates_xml_missing_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -186,9 +186,9 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
-    def test_get_baseURLs_xml_invalid_auth_token(self):
+    def test_get_endpoint_templates_xml_invalid_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs' % (utils.URL)
+        url = '%sendpointTemplates' % (utils.URL)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -200,10 +200,10 @@ class GetBaseURLsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(404, int(resp['status']))
                          
-class GetBaseURLTest(BaseURLsTest):
-    def test_get_baseURL(self):
+class GetEndpointTemplateTest(EndpointTemplatesTest):
+    def test_get_endpoint(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs/%s' % (utils.URL, '1')
+        url = '%sendpointTemplates/%s' % (utils.URL, '1')
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -216,12 +216,12 @@ class GetBaseURLTest(BaseURLsTest):
         
         #verify content
         obj = json.loads(content)
-        if not "baseURL" in obj:
-            raise self.fail("Expecting BaseURL")
+        if not "endpointTemplate" in obj:
+            raise self.fail("Expecting endpointTemplate")
 
-    def test_get_baseURL_using_expired_auth_token(self):
+    def test_get_endpoint_using_expired_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs/%s' % (utils.URL, '1')
+        url = '%sendpointTemplates/%s' % (utils.URL, '1')
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -232,9 +232,9 @@ class GetBaseURLTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
-    def test_get_baseURL_using_disabled_auth_token(self):
+    def test_get_endpoint_using_disabled_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs/%s' % (utils.URL, '1')
+        url = '%sendpointTemplates/%s' % (utils.URL, '1')
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -245,9 +245,9 @@ class GetBaseURLTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
-    def test_get_baseURL_using_missing_auth_token(self):
+    def test_get_endpoint_using_missing_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs/%s' % (utils.URL, '1')
+        url = '%sendpointTemplates/%s' % (utils.URL, '1')
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -259,9 +259,9 @@ class GetBaseURLTest(BaseURLsTest):
         self.assertEqual(401, int(resp['status']))
 
 
-    def test_get_baseURL_using_invalid_auth_token(self):
+    def test_get_endpoint_using_invalid_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs/%s' % (utils.URL, '1')
+        url = '%sendpointTemplates/%s' % (utils.URL, '1')
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -272,9 +272,9 @@ class GetBaseURLTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(404, int(resp['status']))
 
-    def test_get_baseURL_xml(self):
+    def test_get_endpoint_xml(self):
         header = httplib2.Http(".cache")
-        url = '%sbaseURLs/%s' % (utils.URL, '1')
+        url = '%sendpointTemplates/%s' % (utils.URL, '1')
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -289,122 +289,122 @@ class GetBaseURLTest(BaseURLsTest):
         #verify content
         dom = etree.Element("root")
         dom.append(etree.fromstring(content))
-        baseURL = dom.find("{http://docs.openstack.org/identity/api/v2.0}" \
-            "baseURL")
-        if baseURL == None:
-            self.fail("Expecting BaseURL")
+        endpoint = dom.find("{http://docs.openstack.org/identity/api/v2.0}" \
+            "endpointTemplate")
+        if endpoint == None:
+            self.fail("Expecting endpointTemplate")
 
             
-class CreateBaseURLRefsTest(BaseURLsTest):
-    def test_baseurls_ref_create_json(self):
+class CreateEndpointRefsTest(EndpointTemplatesTest):
+    def test_endpoint_create_json(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
 
-    def test_baseurls_ref_create_json_using_expired_token(self):
+    def test_endpoint_create_json_using_expired_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.exp_auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(403, resp_val)
 
-    def test_baseurls_ref_create_json_using_disabled_token(self):
+    def test_endpoint_create_json_using_disabled_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.disabled_token))
         resp_val = int(resp['status'])
         self.assertEqual(403, resp_val)
 
-    def test_baseurls_ref_create_json_using_missing_token(self):
+    def test_endpoint_create_json_using_missing_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.missing_token))
         resp_val = int(resp['status'])
         self.assertEqual(401, resp_val)
 
-    def test_baseurls_ref_create_json_using_invalid_token(self):
+    def test_endpoint_create_json_using_invalid_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.invalid_token))
         resp_val = int(resp['status'])
         self.assertEqual(404, resp_val)
     
-    def test_baseurls_ref_create_xml(self):
+    def test_endpoint_create_xml(self):
         header = httplib2.Http(".cache")
         
-        resp, content = utils.create_baseurls_ref_xml(self.tenant, "1",
+        resp, content = utils.create_endpoint_xml(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, '1')
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, '1')
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.auth_token)})
         resp_val = int(resp['status'])
         self.assertEqual(204, resp_val)
 
-    def test_baseurls_ref_create_xml_using_expired_token(self):
+    def test_endpoint_create_xml_using_expired_token(self):
         header = httplib2.Http(".cache")
         
-        resp, content = utils.create_baseurls_ref_xml(self.tenant, "1",
+        resp, content = utils.create_endpoint_xml(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, '1')
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, '1')
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.exp_auth_token)})
         resp_val = int(resp['status'])
         self.assertEqual(403, resp_val)
         
-    def test_baseurls_ref_create_xml_using_disabled_token(self):
+    def test_endpoint_create_xml_using_disabled_token(self):
         header = httplib2.Http(".cache")
         
-        resp, content = utils.create_baseurls_ref_xml(self.tenant, "1",
+        resp, content = utils.create_endpoint_xml(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, '1')
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, '1')
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.disabled_token)})
         resp_val = int(resp['status'])
         self.assertEqual(403, resp_val)
 
-    def test_baseurls_ref_create_xml_using_missing_token(self):
+    def test_endpoint_create_xml_using_missing_token(self):
         header = httplib2.Http(".cache")
         
-        resp, content = utils.create_baseurls_ref_xml(self.tenant, "1",
+        resp, content = utils.create_endpoint_xml(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, '1')
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, '1')
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.missing_token)})
         resp_val = int(resp['status'])
         self.assertEqual(401, resp_val)
 
-    def test_baseurls_ref_create_xml_using_invalid_token(self):
+    def test_endpoint_create_xml_using_invalid_token(self):
         header = httplib2.Http(".cache")
         
-        resp, content = utils.create_baseurls_ref_xml(self.tenant, "1",
+        resp, content = utils.create_endpoint_xml(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, '1')
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, '1')
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.invalid_token)})
         resp_val = int(resp['status'])
         self.assertEqual(404, resp_val)
 
-class GetBaseURLRefsTest(BaseURLsTest):    
-    def test_get_baseurls_ref_xml(self):
+class GetEndPointTest(EndpointTemplatesTest):    
+    def test_get_endpoint_xml(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/xml
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -416,9 +416,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(200, int(resp['status']))
         
-    def test_get_baseurls_ref_xml_using_expired_auth_token(self):
+    def test_get_endpoint_xml_using_expired_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/xml
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -430,9 +430,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
-    def test_get_baseurls_ref_xml_using_disabled_auth_token(self):
+    def test_get_endpoint_xml_using_disabled_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/xml
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -444,9 +444,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
-    def test_get_baseurls_ref_xml_using_missing_auth_token(self):
+    def test_get_endpoint_xml_using_missing_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/xml
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -458,9 +458,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
-    def test_get_baseurls_ref_xml_using_invalid_auth_token(self):
+    def test_get_endpoint_xml_using_invalid_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/xml
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
@@ -472,9 +472,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(404, int(resp['status']))
         
-    def test_get_baseurls_ref_json(self):
+    def test_get_endpoint_json(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -486,12 +486,12 @@ class GetBaseURLRefsTest(BaseURLsTest):
             self.fail('Service Not Available')
         self.assertEqual(200, int(resp['status']))
         obj = json.loads(content)
-        if not "baseURLRefs" in obj:
-            raise self.fail("Expecting BaseURLRefs")
+        if not "endpoints" in obj:
+            raise self.fail("Expecting endpoints")
 
-    def test_get_baseurls_ref_json_using_expired_auth_token(self):
+    def test_get_endpoint_json_using_expired_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -504,9 +504,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
         self.assertEqual(403, int(resp['status']))
         obj = json.loads(content)
 
-    def test_get_baseurls_ref_json_using_disabled_auth_token(self):
+    def test_get_endpoint_json_using_disabled_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -519,9 +519,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
         self.assertEqual(403, int(resp['status']))
         obj = json.loads(content)
 
-    def test_get_baseurls_ref_json_using_missing_auth_token(self):
+    def test_get_endpoint_json_using_missing_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -534,9 +534,9 @@ class GetBaseURLRefsTest(BaseURLsTest):
         self.assertEqual(401, int(resp['status']))
         obj = json.loads(content)
 
-    def test_get_baseurls_ref_json_using_invalid_auth_token(self):
+    def test_get_endpoint_json_using_invalid_auth_token(self):
         header = httplib2.Http(".cache")
-        url = '%stenants/%s/baseURLRefs' % (URL, self.tenant)
+        url = '%stenants/%s/endpoints' % (URL, self.tenant)
         #test for Content-Type = application/json
         resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
@@ -549,116 +549,116 @@ class GetBaseURLRefsTest(BaseURLsTest):
         self.assertEqual(404, int(resp['status']))
         obj = json.loads(content)
 
-class DeleteBaseURLRefsTest(BaseURLsTest):            
-    def test_delete_baseurlref(self):
+class DeleteEndpointsTest(EndpointTemplatesTest):            
+    def test_delete_endpoint(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
         obj = json.loads(content)
-        if not "baseURLRef" in obj:
-            raise fault.BadRequestFault("Expecting baseURLRef")
-        base_url_ref = obj["baseURLRef"]
-        if not "id" in base_url_ref:
-                base_url_ref_id = None
+        if not "endpoint" in obj:
+            raise fault.BadRequestFault("Expecting endpoint")
+        endpoint = obj["endpoint"]
+        if not "id" in endpoint:
+                endpoint_id = None
         else:
-            base_url_ref_id = base_url_ref["id"]
-        if base_url_ref_id is None:
-            raise fault.BadRequestFault("Expecting baseURLRefID")
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, base_url_ref_id)
+            endpoint_id = endpoint["id"]
+        if endpoint_id is None:
+            raise fault.BadRequestFault("Expecting endpointID")
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, endpoint_id)
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.auth_token)})
         resp_val = int(resp['status'])
         self.assertEqual(204, resp_val)
 
-    def test_delete_baseurlref_using_expired_auth_token(self):
+    def test_delete_endpoint_using_expired_auth_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
         obj = json.loads(content)
-        if not "baseURLRef" in obj:
-            raise fault.BadRequestFault("Expecting baseURLRef")
-        base_url_ref = obj["baseURLRef"]
-        if not "id" in base_url_ref:
-                base_url_ref_id = None
+        if not "endpoint" in obj:
+            raise fault.BadRequestFault("Expecting endpoint")
+        endpoint = obj["endpoint"]
+        if not "id" in endpoint:
+                endpoint_id = None
         else:
-            base_url_ref_id = base_url_ref["id"]
-        if base_url_ref_id is None:
-            raise fault.BadRequestFault("Expecting baseURLRefID")
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, base_url_ref_id)
+            endpoint_id = endpoint["id"]
+        if endpoint_id is None:
+            raise fault.BadRequestFault("Expecting endpoint id")
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, endpoint_id)
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.exp_auth_token)})
         resp_val = int(resp['status'])
         self.assertEqual(403, resp_val)
 
-    def test_delete_baseurlref_using_disabled_auth_token(self):
+    def test_delete_endpoint_using_disabled_auth_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
         obj = json.loads(content)
-        if not "baseURLRef" in obj:
-            raise fault.BadRequestFault("Expecting baseURLRef")
-        base_url_ref = obj["baseURLRef"]
-        if not "id" in base_url_ref:
-                base_url_ref_id = None
+        if not "endpoint" in obj:
+            raise fault.BadRequestFault("Expecting endpoint")
+        endpoint = obj["endpoint"]
+        if not "id" in endpoint:
+                endpoint_id = None
         else:
-            base_url_ref_id = base_url_ref["id"]
-        if base_url_ref_id is None:
-            raise fault.BadRequestFault("Expecting baseURLRefID")
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, base_url_ref_id)
+            endpoint_id = endpoint["id"]
+        if endpoint_id is None:
+            raise fault.BadRequestFault("Expecting endpoint id")
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, endpoint_id)
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.disabled_token)})
         resp_val = int(resp['status'])
         self.assertEqual(403, resp_val)
  
-    def test_delete_baseurlref_using_missing_auth_token(self):
+    def test_delete_endpoint_using_missing_auth_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
         obj = json.loads(content)
-        if not "baseURLRef" in obj:
-            raise fault.BadRequestFault("Expecting baseURLRef")
-        base_url_ref = obj["baseURLRef"]
-        if not "id" in base_url_ref:
-                base_url_ref_id = None
+        if not "endpoint" in obj:
+            raise fault.BadRequestFault("Expecting endpoint")
+        endpoint = obj["endpoint"]
+        if not "id" in endpoint:
+                endpoint_id = None
         else:
-            base_url_ref_id = base_url_ref["id"]
-        if base_url_ref_id is None:
-            raise fault.BadRequestFault("Expecting baseURLRefID")
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, base_url_ref_id)
+            endpoint_id = endpoint["id"]
+        if endpoint_id is None:
+            raise fault.BadRequestFault("Expecting endpointID")
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, endpoint_id)
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.missing_token)})
         resp_val = int(resp['status'])
         self.assertEqual(401, resp_val)
 
-    def test_delete_baseurlref_using_invalid_auth_token(self):
+    def test_delete_endpoint_using_invalid_auth_token(self):
         header = httplib2.Http(".cache")
-        resp, content = utils.create_baseurls_ref(self.tenant, "1",
+        resp, content = utils.create_endpoint(self.tenant, "1",
             str(self.auth_token))
         resp_val = int(resp['status'])
         self.assertEqual(201, resp_val)
         obj = json.loads(content)
-        if not "baseURLRef" in obj:
-            raise fault.BadRequestFault("Expecting baseURLRef")
-        base_url_ref = obj["baseURLRef"]
-        if not "id" in base_url_ref:
-                base_url_ref_id = None
+        if not "endpoint" in obj:
+            raise fault.BadRequestFault("Expecting endpoint")
+        endpoint = obj["endpoint"]
+        if not "id" in endpoint:
+                endpoint_id = None
         else:
-            base_url_ref_id = base_url_ref["id"]
-        if base_url_ref_id is None:
-            raise fault.BadRequestFault("Expecting baseURLRefID")
-        url = '%stenants/%s/baseURLRefs/%s' % (URL, self.tenant, base_url_ref_id)
+            endpoint_id = endpoint["id"]
+        if endpoint_id is None:
+            raise fault.BadRequestFault("Expecting endpoint ID")
+        url = '%stenants/%s/endpoints/%s' % (URL, self.tenant, endpoint_id)
         resp, content = header.request(url, "DELETE", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": str(self.invalid_token)})
diff --git a/keystone/utils.py b/keystone/utils.py
index eb90b326..b5e63c44 100644
--- a/keystone/utils.py
+++ b/keystone/utils.py
@@ -39,7 +39,6 @@ if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'keystone', '__init__.py')):
 from queryext import exthandler
 import keystone.logic.types.fault as fault
 
-
 def is_xml_response(req):
     if not "Accept" in req.headers:
         return False