Merge branch 'master' of https://git.hcleai.com/keystone

Resolved Conflicts with Sirish' and Abdul's Merge
Conflicts:
	keystone/db/sqlalchemy/api.py
	keystone/server.py

13 files changed, 8589 insertions, 218 deletions

diff --git a/keystone/db/sqlalchemy/api.py b/keystone/db/sqlalchemy/api.py
index af91a2c5..5471ae12 100644
--- a/keystone/db/sqlalchemy/api.py
+++ b/keystone/db/sqlalchemy/api.py
@@ -62,6 +62,8 @@ def tenant_get_page_markers(marker, limit, session=None):
                         models.Tenant.id).first()
     last = session.query(models.Tenant).order_by(\
                         models.Tenant.id.desc()).first()
+    if first is None :
+        return (None, None)
     if marker is None:
         marker = first.id
     next = session.query(models.Tenant).filter("id > :marker").params(\
@@ -223,7 +225,7 @@ def tenant_group_delete(id, tenant_id, session=None):
         session.delete(tenantgroup_ref)
 
 
-def user_get_by_group(user_id, group_id, session=None):
+def get_user_by_group(user_id, group_id, session=None):
     if not session:
         session = get_session()
     result = session.query(models.UserGroupAssociation).filter_by(\
@@ -242,7 +244,7 @@ def user_tenant_group_delete(id, group_id, session=None):
     if not session:
         session = get_session()
     with session.begin():
-        usertenantgroup_ref = user_get_by_group(id, group_id, session)
+        usertenantgroup_ref = get_user_by_group(id, group_id, session)
         session.delete(usertenantgroup_ref)
 
 
@@ -306,6 +308,8 @@ def users_tenant_group_get_page_markers(group_id, marker, limit, session=None):
                         models.User.id).first()
     last = session.query(models.User).order_by(\
                         models.User.id.desc()).first()
+    if first is None:
+        return (None, None)
     if marker is None:
         marker = first.id
     next = session.query(user).join(
@@ -383,6 +387,8 @@ def group_get_page_markers(marker, limit, session=None):
                         models.Group.id).first()
     last = session.query(models.Group).order_by(\
                         models.Group.id.desc()).first()
+    if first is None:
+        return (None, None)
     if marker is None:
         marker = first.id
     next = session.query(models.Group).filter("id > :marker").params(\
@@ -504,16 +510,16 @@ def users_get_by_tenant_get_page_markers(tenant_id, marker, limit,\
                         join((uta, uta.user_id == user.id)).\
                         filter(uta.tenant_id == tenant_id).\
                         order_by(user.id.desc()).first()
+    if first is None:
+        return (None, None)
     if marker is None:
         marker = first.id
-    next, nextuta = session.query(user, uta).join((uta,
-                    uta.user_id == user.id)).\
+    next = session.query(user, uta).join((uta, uta.user_id == user.id)).\
                     filter(uta.tenant_id == tenant_id).\
-                    filter("id >= :marker").params(
-                    marker='%s' % marker).order_by(
-                    user.id).limit(int(limit) + 1).all()
-    prev, prevuta = session.query(user, uta).join((uta, \
-                    uta.user_id == user.id)).\
+                    filter("id > :marker").params(\
+                    marker='%s' % marker).order_by(user.id).\
+                    limit(int(limit)).all()
+    prev = session.query(user, uta).join((uta, uta.user_id == user.id)).\
                     filter(uta.tenant_id == tenant_id).\
                     filter("id < :marker").params(
                     marker='%s' % marker).order_by(
@@ -585,6 +591,8 @@ def groups_get_by_user_get_page_markers(user_id, marker, limit, session=None):
                         join((uga, uga.group_id == group.id)).\
                         filter(uga.user_id == user_id).\
                         order_by(group.id.desc()).first()
+    if first is None:
+        return (None, None)
     if marker is None:
         marker = first.id
     next = session.query(group, uga).join(
@@ -652,8 +660,10 @@ def user_delete_tenant(id, tenant_id, session=None):
         session = get_session()
     with session.begin():
         user_tenant_ref = user_get_by_tenant(id, tenant_id, session)
+
         session.delete(user_tenant_ref)
-        user_group_ref = user_get_by_group(tenant_id, session)
+        user_group_ref = user_get_by_group(tenant_id,session)
+
         if user_group_ref is not None:
             for user_group in user_group_ref:
                 group_users=session.query(models.UserGroupAssociation).filter_by( \
@@ -666,17 +676,3 @@ def user_delete_tenant(id, tenant_id, session=None):
             user_ref = user_get(id, session)
             session.delete(user_ref)
 
-def user_tenant_group(values):
-    user_ref = models.UserGroupAssociation()
-    user_ref.update(values)
-    user_ref.save()
-    return user_ref
-
-
-def user_tenant_group_delete(id, group_id, session=None):
-    if not session:
-        session = get_session()
-    with session.begin():
-        usertenantgroup_ref = user_get_by_group(id, group_id, session)
-        session.delete(usertenantgroup_ref)
-
diff --git a/keystone/logic/service.py b/keystone/logic/service.py
index 4fd1b0de..1b22a0a2 100644
--- a/keystone/logic/service.py
+++ b/keystone/logic/service.py
@@ -379,7 +379,7 @@ class IDMService(object):
             raise fault.ItemNotFoundFault("A tenant group with"
                                            " that id not found")
         
-        if db_api.user_get_by_group(user, group) != None:
+        if db_api.get_user_by_group(user, group) != None:
             raise fault.UserGroupConflictFault(
                 "A user with that id already exists in group")
         
@@ -407,7 +407,7 @@ class IDMService(object):
             raise fault.ItemNotFoundFault("A tenant group with"
                                           " that id not found")
         
-        if db_api.user_get_by_group(user, group) == None:
+        if db_api.get_user_by_group(user, group) == None:
             raise fault.ItemNotFoundFault("A user with that id "
                                           "in a group not found")
         
@@ -539,8 +539,7 @@ class IDMService(object):
             raise fault.TenantDisabledFault("Your account has been disabled")
 
         duser = db_api.user_get(user_id)
-        print 'here'
-        print duser
+        
         if not duser:
             raise fault.ItemNotFoundFault("The user could not be found")
 
@@ -550,7 +549,7 @@ class IDMService(object):
 
         if not isinstance(user, users.User):
             raise fault.BadRequestFault("Expecting a User")
-        True
+        
         if db_api.user_get_email(user.email) is not None:
             raise fault.EmailConflictFault(
                 "Email already exists")
@@ -581,7 +580,7 @@ class IDMService(object):
 
         if not isinstance(user, users.User):
             raise fault.BadRequestFault("Expecting a User")
-        True
+        
         duser = db_api.user_get(user_id)
         if duser == None:
             raise fault.ItemNotFoundFault("The user could not be found")
@@ -606,13 +605,13 @@ class IDMService(object):
             raise fault.ItemNotFoundFault("The user could not be found" )
         if not isinstance(user, users.User):
             raise fault.BadRequestFault("Expecting a User")
-        True
+        
         duser = db_api.user_get(user_id)
         if duser == None:
             raise fault.ItemNotFoundFault("The user could not be found")
 
         values = {'enabled': user.enabled}
-
+        
         db_api.user_update(user_id, values)
 
         return users.User_Update(None,None,None,None,user.enabled,None)
@@ -827,7 +826,7 @@ class IDMService(object):
             raise fault.ItemNotFoundFault("A global tenant group with"
                                           " that id not found")
 
-        if db_api.user_get_by_group(user, group) != None:
+        if db_api.get_user_by_group(user, group) != None:
             raise fault.UserGroupConflictFault(
                 "A user with that id already exists in group")
 
@@ -856,7 +855,7 @@ class IDMService(object):
             raise fault.ItemNotFoundFault("A global tenant group with "
                                           "that id not found")
 
-        if db_api.user_get_by_group(user, group) == None:
+        if db_api.get_user_by_group(user, group) == None:
             raise fault.ItemNotFoundFault("A user with that id in a "
                                           "group not found")
 
diff --git a/keystone/logic/types/user.py b/keystone/logic/types/user.py
index 2c50de65..ea54054d 100644
--- a/keystone/logic/types/user.py
+++ b/keystone/logic/types/user.py
@@ -217,7 +217,7 @@ class User_Update(object):
         if self.password:
             dom.set("password", self.password)
         if self.group is not None:
-            print '78'
+            
             for group in self.group:
                 dom.append(group.to_dom())
         return dom
diff --git a/keystone/server.py b/keystone/server.py
index 39a309e1..0eebf641 100755
--- a/keystone/server.py
+++ b/keystone/server.py
@@ -474,16 +474,15 @@ class UserController(wsgi.Controller):
     @wrap_error
     def set_user_password(self, req, user_id, tenant_id):
         user = get_normalized_request_content(users.User_Update, req)
-        rval = service.set_user_password(get_auth_token(req),
-                user_id, user, tenant_id)
-        return send_result(204, req, rval)
+        rval = service.set_user_password(get_auth_token(req), user_id, user, tenant_id)
+        return send_result(200, req, rval)
+
 
     @wrap_error
     def set_user_enabled(self, req, user_id, tenant_id):
         user = get_normalized_request_content(users.User_Update, req)
-        rval = service.enable_disable_user(get_auth_token(req), user_id,
-                                           user, tenant_id)
-        return send_result(204, req, rval)
+        rval = service.enable_disable_user(get_auth_token(req), user_id, user, tenant_id)
+        return send_result(200, req, rval)
 
 
 class GroupsController(wsgi.Controller):
@@ -654,6 +653,10 @@ class KeystoneAPI(wsgi.Router):
                     controller=user_controller,
                     action="get_tenant_users",
                     conditions=dict(method=["GET"]))
+        mapper.connect("/v1.0/tenants/{tenant_id}/users/{user_id}/groups",
+                    controller=user_controller,
+                    action="get_user_groups",
+                    conditions=dict(method=["GET"]))
         mapper.connect("/v1.0/tenants/{tenant_id}/users/{user_id}",
                     controller=user_controller,
                     action="get_user",
@@ -670,10 +673,10 @@ class KeystoneAPI(wsgi.Router):
                     controller=user_controller,
                     action="set_user_password",
                     conditions=dict(method=["PUT"]))
-        mapper.connect("/v1.0/tenants/{tenant_id}/users/{user_id}/enabled",
-                    controller=user_controller,
-                    action="set_user_enabled",
-                    conditions=dict(method=["PUT"]))
+
+        # Test this, test failed
+        mapper.connect("/v1.0/tenants/{tenant_id}/users/{user_id}/enabled", controller=user_controller,
+                action="set_user_enabled", conditions=dict(method=["PUT"]))
 
         #Global Groups
         groups_controller = GroupsController(options)
diff --git a/test/unit/test_authentication.py b/test/unit/test_authentication.py
new file mode 100644
index 00000000..43838143
--- /dev/null
+++ b/test/unit/test_authentication.py
@@ -0,0 +1,109 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+
+class authentication_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+
+    def tearDown(self):
+        delete_token(self.token, self.auth_token)
+
+    def test_a_authorize(self):
+        resp, content = get_token('joeuser', 'secrete')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_authorize_xml(self):
+        resp, content = get_token_xml('joeuser', 'secrete')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_authorize_user_disabled(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = {"passwordCredentials": {"username": "disabled",
+                                        "password": "secrete"}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                headers={"Content-Type": "application/json"})
+        content = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_authorize_user_disabled_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <passwordCredentials \
+                xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="secrete" username="disabled" \
+                />'
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_authorize_user_wrong(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = {"passwordCredentials": {"username-w": "disabled",
+                                        "password": "secrete"}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                headers={"Content-Type": "application/json"})
+        content = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_authorize_user_wrong_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <passwordCredentials \
+                xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="secrete" username-w="disabled" \
+                />'
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/test/unit/test_common.py b/test/unit/test_common.py
new file mode 100644
index 00000000..60be989d
--- /dev/null
+++ b/test/unit/test_common.py
@@ -0,0 +1,438 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+
+URL = 'http://localhost:8080/v1.0/'
+
+
+def get_token(user, pswd, kind=''):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = {"passwordCredentials": {"username": user,
+                                        "password": pswd}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json"})
+        content = json.loads(content)
+
+        token = str(content['auth']['token']['id'])
+        if kind == 'token':
+            return token
+        else:
+            return (resp, content)
+
+
+def delete_token(token, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stoken/%s' % (URL, token)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_tenant(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+
+    url = '%stenants' % (URL)
+    body = {"tenant": {"id": tenantid,
+                       "description": "A description ...",
+                       "enabled": True}}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_tenant_group(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+
+    url = '%stenant/%s/groups' % (URL, tenantid)
+    body = {"group": {"id": groupid,
+                       "description": "A description ..."
+                         }}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def delete_tenant(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s' % (URL, tenantid)
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def delete_tenant_group(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenant/%s/groups/%s' % (URL, tenantid, groupid)
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_global_group(groupid, auth_token):
+    h = httplib2.Http(".cache")
+
+    url = '%sgroups' % (URL)
+    body = {"group": {"id": groupid,
+                       "description": "A description ..."
+                         }}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_global_group_xml(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups' % (URL)
+    body = '<?xml version="1.0" encoding="UTF-8"?>\
+            <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            id="%s"><description>A Description of the group</description>\
+                    </group>' % groupid
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_global_group(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s' % (URL, groupid)
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def delete_global_group_xml(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s' % (URL, groupid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def get_token_xml(user, pswd, type=''):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <passwordCredentials \
+                xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="%s" username="%s" \
+                tenantId="77654"/> ' % (pswd, user)
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                         "ACCEPT": "application/xml"})
+        dom = etree.fromstring(content)
+        root = dom.find("{http://docs.openstack.org/idm/api/v1.0}token")
+        token_root = root.attrib
+        token = str(token_root['id'])
+        if type == 'token':
+            return token
+        else:
+            return (resp, content)
+
+
+def delete_token_xml(token, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stoken/%s' % (URL, token)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def create_tenant_xml(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants' % (URL)
+    body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % tenantid
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def create_tenant_group_xml(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenant/%s/groups' % (URL, tenantid)
+    body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             id="%s"> \
+            <description>A description...</description> \
+            </group>' % groupid
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_tenant_xml(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s' % (URL, tenantid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_tenant_group_xml(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenant/%s/groups/%s' % (URL, tenantid, groupid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def create_user(tenantid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users' % (URL, tenantid)
+    body = {"user": {"password": "secrete",
+                     "id": userid,
+                     "tenantId": tenantid,
+                     "email": "%s@rackspace.com" % userid,
+                     "enabled": True}}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def delete_user(tenant, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users/%s' % (URL, tenant, userid)
+    
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    
+    return (resp, content)
+
+def create_user_xml(tenantid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users' % (URL, tenantid)
+    body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            email="joetest@rackspace.com" \
+            tenantId="%s" id="%s" \
+            enabled="true" password="secrete"/>' % (tenantid, userid)
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def delete_user_xml(tenantid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users/%s' % (URL, tenantid, userid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def add_user_tenant_group(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def add_user_tenant_group_xml(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def delete_user_tenant_group(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def delete_user_tenant_group_xml(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def get_user_tenant_group(tenantid, groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users' % (URL, tenantid, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def get_user_tenant_group_xml(tenantid, groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users' % (URL, tenantid, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def add_user_global_group(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def add_user_global_group_xml(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def delete_user_global_group(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def delete_user_global_group_xml(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def get_user_global_group(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users' % (URL, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+   
+    return (resp, content)
+
+def get_userid():
+    return 'test_user11'
+
+
+def get_password():
+    return 'secrete'
+
+
+def get_email():
+    return 'joetest@rackspace.com'
+
+def get_user_global_group_xml(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users' % (URL, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+  
+def get_tenant():
+    return '1234'
+
+
+def get_user():
+    return 'test_user'
+
+
+def get_userdisabled():
+    return 'disabled'
+
+def get_auth_token():
+    return '999888777666'
+
+
+def get_exp_auth_token():
+    return '000999'
+
+def get_none_token():
+    return ''
+
+def get_non_existing_token():
+    return 'invalid_token'
+
+def get_disabled_token():
+    return '999888777'
+
+
+def content_type(resp):
+    return resp['content-type'].split(';')[0]
+
+def get_global_tenant():
+    return 'GlobalTenant'
+
+def handle_user_resp(self,content, respvalue,resptype):
+    if respvalue == 200:
+        if resptype == 'application/json':
+            content = json.loads(content)
+            self.tenant = content['user']['tenantId']
+            self.userid = content['user']['id']
+        if resptype == 'application/xml':
+            content=etree.fromstring(content)
+            self.tenant=content.get("tenantId")
+            self.id=content.get("id")
+
+
+    if respvalue == 500:
+        self.fail('IDM fault')
+    elif respvalue == 503:
+        self.fail('Service Not Available')
+
+def content_type(resp):
+    return resp['content-type'].split(';')[0]
+
diff --git a/test/unit/test_groups.py b/test/unit/test_groups.py
new file mode 100644
index 00000000..1e6e4be1
--- /dev/null
+++ b/test/unit/test_groups.py
@@ -0,0 +1,1041 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+##
+## Global Group Tests
+##
+class global_group_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.globaltenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.global_group = 'test_global_group_add'
+
+    def tearDown(self):
+        resp, content = delete_global_group(self.global_group,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.globaltenant, self.auth_token)
+
+
+class create_global_group_test(global_group_test):
+
+    def test_global_group_create(self):
+        respG, contentG = delete_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+
+    def test_global_group_create_xml(self):
+        respG, contentG = delete_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+
+    def test_global_group_create_again(self):
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+
+    def test_global_group_create_again_xml(self):
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        contentG = etree.fromstring(contentG)
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+
+    def test_global_group_create_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        body = {"group": {"id": self.global_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_expired_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = {"group": {"id": self.global_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.globaltenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_missing_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = {"group": {"id": self.global_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_disabled_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '{"group": { "id": "%s", \
+                "description": "A description ..." } }' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_invalid_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '{"group": { "id": "%s", \
+                "description": "A description ..." } }' % self.globaltenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": 'nonexsitingtoken'})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_global_group_create_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": 'nonexsitingtoken',
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class get_global_groups_test(global_group_test):
+
+    def test_get_global_groups(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = delete_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        
+        url = '%sgroups' % (URL)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_groups_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_groups_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_global_groups_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_global_groups_exp_token(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_get_global_groups_exp_token_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+
+class get_global_group_test(global_group_test):
+
+    def test_get_global_group(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_group_bad(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, 'global_group_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_global_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups/%s' % (URL , 'global_group_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    
+
+class update_global_groups_test(global_group_test):
+
+    def test_update_global_group(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        resp, content = h.request(url, "PUT", body='{"group":{\
+                "id" : "%s","description" :\
+                "A New description of the group..."}}' % self.global_group,
+                headers={"Content-Type": "application/json",
+                         "X-Auth-Token": self.auth_token})
+        body = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(self.global_group, body['group']['id'])
+        self.assertEqual('A New description of the group...',
+                         str(body['group']['description']))
+
+    def test_update_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                                  str(self.auth_token))
+        
+        url = '%sgroups/%s' % (URL, self.global_group)
+        data = u'<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A NEW description...</description> \
+                </group>' % (self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        
+        body = etree.fromstring(content)
+        desc = body.find("{http://docs.openstack.org/idm/api/v1.0}description")
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(str(self.global_group), str(body.get('id')))
+        self.assertEqual('A NEW description...', desc.text)
+
+    def test_update_global_group_bad(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        data = '{"group": { "description_bad": "A NEW description...", \
+                "id":"%s"  }}'\
+                % (self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_global_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description_bad>A NEW description...</description> \
+                </group>' % (self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_global_group_not_found(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/NonexistingID' % (URL)
+        data = '{"group": { "description": "A NEW description...", \
+                "id":"NonexistingID"}}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        self.assertEqual(404, int(resp['status']))
+
+    def test_update_global_group_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.globaltenant,
+                                          str(self.auth_token))
+        url = '%sgroups/NonexistingID' % (URL)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="NonexistingID"> \
+                <description_bad>A NEW description...</description> \
+                </group>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class delete_global_group_test(global_group_test):
+
+    def test_delete_global_group_not_found(self):
+        resp, content = delete_global_group("test_global_group_1",
+                                            str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_global_group_not_found_xml(self):
+        resp, content = delete_global_group_xml("test_global_group_1",
+                                                str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_global_group(self):
+        resp, content = create_tenant(self.globaltenant, str(self.auth_token))
+        respG, contentG = create_tenant_group('test_global_group_delete',
+                                              self.globaltenant,
+                                              str(self.auth_token))
+        respG, contentG = delete_global_group('test_global_group_delete',
+                                              str(self.auth_token))
+        resp, content = delete_tenant(self.globaltenant,
+                                      str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+    def test_delete_global_group_xml(self):
+        resp, content = create_tenant_xml(self.globaltenant,
+                                          str(self.auth_token))
+        respG, contentG = create_tenant_group_xml('test_global_group_delete',
+                                                  self.globaltenant,
+                                                  str(self.auth_token))
+        respG, contentG = delete_global_group_xml('test_global_group_delete',
+                                                  str(self.auth_token))
+        resp, content = delete_tenant_xml(self.globaltenant,
+                                          str(self.auth_token))
+        self.assertEqual(204, int(resp['status']))
+
+   
+
+
+class add_user_global_group_test(unittest.TestCase):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.global_group = 'test_global_group'
+        
+        
+
+    def tearDown(self):
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_global_group(self.global_group,
+                                            self.auth_token)
+        
+        
+        
+    def test_add_user_global_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.global_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_global_group_conflict(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+    
+    def test_add_user_global_group_conflict_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.global_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_global_group_xml(self.global_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+    def test_add_user_global_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, str(self.token)
+                                                )
+        
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_global_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.global_group,
+                                                self.user, str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_global_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_add_user_global_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.global_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+
+class get_users_tenant_group_test(unittest.TestCase):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.global_group = 'test_global_group'
+        
+        
+
+    def tearDown(self):
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_global_group(self.global_group,
+                                            self.auth_token)       
+    def test_get_users_global_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group(self.global_group,
+                                                str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+    
+    def test_get_users_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.global_group,
+                                                str(self.auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+        
+    def test_get_users_global_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        
+        respG, contentG = get_user_global_group(self.global_group,
+                                                str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_global_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.global_group,
+                                                str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_global_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group(self.global_group,
+                                                str(self.disabled_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_global_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.global_group,
+                                                str(self.disabled_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_global_group_expired(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group(self.global_group,
+                                                str(self.exp_auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_global_group_expired_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.global_group,
+                                                str(self.exp_auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+class delete_users_global_group_test(unittest.TestCase):  
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.global_group = 'test_global_group'
+        
+        
+
+    def tearDown(self):
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_global_group(self.global_group,
+                                            self.auth_token)
+    def test_delete_user_global_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+        
+    
+    def test_delete_user_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_global_group_xml(self.global_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+    
+    def test_delete_user_global_group_notfound(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+        
+    def test_delete_user_global_group_notfound_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.global_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        respG, contentG = delete_user_global_group(self.global_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_global_group_xml(self.global_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/test/unit/test_identity.py b/test/unit/test_identity.py
index 66b5c5aa..76c0a808 100644
--- a/test/unit/test_identity.py
+++ b/test/unit/test_identity.py
@@ -1,4 +1,4 @@
-import os
+"""import os
 import sys
 # Need to access identity module
 sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
@@ -12,7 +12,8 @@ import json
 from lxml import etree
 import unittest
 from webtest import TestApp
-
+"""
+"""
 URL = 'http://localhost:8080/v1.0/'
 
 
@@ -486,8 +487,8 @@ def handle_user_resp(self,content, respvalue,resptype):
 
 def content_type(resp):
     return resp['content-type'].split(';')[0]
-
-class identity_test(unittest.TestCase):
+"""
+"""class identity_test(unittest.TestCase):
 
     #Given _a_ to make inherited test cases in an order.
     #here to call below method will call as last test case
@@ -509,8 +510,8 @@ class identity_test(unittest.TestCase):
 
         self.assertEqual(200, int(resp['status']))
         self.assertEqual('application/xml', content_type(resp))
-
-
+"""
+"""
 class authorize_test(identity_test):
 
     def setUp(self):
@@ -602,8 +603,8 @@ class authorize_test(identity_test):
             self.fail('Service Not Available')
         self.assertEqual(400, int(resp['status']))
         self.assertEqual('application/xml', content_type(resp))
-
-
+"""
+"""
 class validate_token(authorize_test):
 
     def test_validate_token_true(self):
@@ -694,8 +695,8 @@ class validate_token(authorize_test):
         self.assertEqual(401, int(resp['status']))
         self.assertEqual('application/json', content_type(resp))
 
-
-class tenant_test(unittest.TestCase):
+"""
+"""class tenant_test(unittest.TestCase):
 
     def setUp(self):
         self.token = get_token('joeuser', 'secrete', 'token')
@@ -708,8 +709,8 @@ class tenant_test(unittest.TestCase):
 
     def tearDown(self):
         resp, content = delete_tenant(self.tenant, self.auth_token)
-
-
+"""
+"""
 class create_tenant_test(tenant_test):
 
     def test_tenant_create(self):
@@ -1322,8 +1323,8 @@ class delete_tenant_test(tenant_test):
         resp, content = delete_tenant_xml("test_tenant_delete",
                                           str(self.auth_token))
         self.assertEqual(204, int(resp['status']))
-
-
+"""
+"""
 class tenant_group_test(unittest.TestCase):
 
     def setUp(self):
@@ -1346,7 +1347,7 @@ class tenant_group_test(unittest.TestCase):
 class create_tenant_group_test(tenant_group_test):
 
     def test_tenant_group_create(self):
-<<<<<<< HEAD
+
         resp, content = delete_tenant(self.tenant, str(self.auth_token))
         resp, content = create_tenant(self.tenant, str(self.auth_token))
         respG, contentG = delete_tenant_group(self.tenant_group,
@@ -2519,8 +2520,8 @@ class delete_users_tenant_group_test(add_user_tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(404, int(respG['status']))
 
-
-##
+"""
+"""##
 ## Global Group Tests
 ##
 class global_group_test(unittest.TestCase):
@@ -2999,7 +3000,7 @@ class update_global_groups_test(global_group_test):
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
-=======
+
         resp, content = delete_tenant('test_tenant', str(self.auth_token))
         resp, content = create_tenant('test_tenant', str(self.auth_token))
 
@@ -3125,14 +3126,12 @@ class update_global_groups_test(global_group_test):
                     headers={"Content-Type": "application/xml", \
                          "X-Auth-Token": self.token,
                          "ACCEPT": "application/xml"})
-
->>>>>>> 91c82cfcefd8d0a7719dfbcca6c3e50ec438d074
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-<<<<<<< HEAD
-        self.assertEqual(400, int(resp['status']))
+
+        self.assertEqual(403, int(resp['status']))
 
     def test_update_global_group_not_found(self):
         h = httplib2.Http(".cache")
@@ -3145,9 +3144,7 @@ class update_global_groups_test(global_group_test):
         resp, content = h.request(url, "GET", body=data,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
-=======
-
-        self.assertEqual(403, int(resp['status']))
+        self.assertEqual(404, int(resp['status']))
 
     def test_tenant_group_create_expired_token(self):
         h = httplib2.Http(".cache")
@@ -3162,14 +3159,12 @@ class update_global_groups_test(global_group_test):
         resp, content = h.request(url, "POST", body=json.dumps(body),
                     headers={"Content-Type": "application/json",
                          "X-Auth-Token": self.exp_auth_token})
-
->>>>>>> 91c82cfcefd8d0a7719dfbcca6c3e50ec438d074
-        if int(resp['status']) == 500:
+       if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-<<<<<<< HEAD
-        self.assertEqual(404, int(resp['status']))
+
+        self.assertEqual(403, int(resp['status']))
 
     def test_update_global_group_not_found_xml(self):
         h = httplib2.Http(".cache")
@@ -3190,7 +3185,7 @@ class update_global_groups_test(global_group_test):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(404, int(resp['status']))
+        self.assertEqual(403, int(resp['status']))
 
 
 class delete_global_group_test(global_group_test):
@@ -3226,10 +3221,7 @@ class delete_global_group_test(global_group_test):
                                                   str(self.auth_token))
         resp, content = delete_tenant_xml(self.globaltenant,
                                           str(self.auth_token))
-        self.assertEqual(204, int(respG['status']))
-
-=======
-        self.assertEqual(401, int(resp['status']))
+        self.assertEqual(204, int(resp['status']))
 
     def test_tenant_group_create_expired_token_xml(self):
         h = httplib2.Http(".cache")
@@ -3440,9 +3432,7 @@ class get_tenant_groups_test(tenant_group_test):
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
->>>>>>> 91c82cfcefd8d0a7719dfbcca6c3e50ec438d074
 
-<<<<<<< HEAD
     def test_get_tenant_groups_forbidden_token_xml(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -3768,7 +3758,7 @@ class delete_tenant_group_test(tenant_test):
         resp, content = delete_tenant_xml("test_tenant_delete", \
                         str(self.auth_token))
         self.assertEqual(204, int(respG['status']))
-
+""""""
 class user_test(unittest.TestCase):
 
     def setUp(self):
@@ -5463,13 +5453,1097 @@ class set_enabled_test(user_test):
         self.assertEqual('application/xml', content_type(resp))
 
 
+"""
 
 
 
+"""class add_user_global_group_test(unittest.TestCase):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_global_group'
+        
+        
 
-#class get_user_test(user_test):
+    def tearDown(self):
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_global_group(self.tenant_group,
+                                            self.auth_token)
+        
+        
+        
+    def test_add_user_global_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_global_group_conflict(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+    
+    def test_add_user_global_group_conflict_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_global_group_xml(self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+    def test_add_user_global_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, str(self.token)
+                                                )
+        
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_global_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.tenant_group,
+                                                self.user, str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_global_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_add_user_global_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.tenant_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
 
-class global_group_test(unittest.TestCase):
+class get_users_tenant_group_test(unittest.TestCase):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_global_group'
+        
+        
+
+    def tearDown(self):
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_global_group(self.tenant_group,
+                                            self.auth_token)       
+    def test_get_users_global_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group(self.tenant_group,
+                                                str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+    
+    def test_get_users_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group_xml(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.tenant_group,
+                                                str(self.auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+        
+    def test_get_users_global_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        
+        respG, contentG = get_user_global_group(self.tenant_group,
+                                                str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_global_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.tenant_group,
+                                                str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_global_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group(self.tenant_group,
+                                                str(self.disabled_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_global_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.tenant_group,
+                                                str(self.disabled_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_global_group_expired(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group(self.tenant_group,
+                                                str(self.exp_auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_global_group_expired_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = get_user_global_group_xml(self.tenant_group,
+                                                str(self.exp_auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+class delete_users_global_group_test(unittest.TestCase):  
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_global_group'
+        
+        
+
+    def tearDown(self):
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_global_group(self.tenant_group,
+                                            self.auth_token)
+    def test_delete_user_global_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+        
+    
+    def test_delete_user_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_global_group_xml(self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+    
+    def test_delete_user_global_group_notfound(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+        
+    def test_delete_user_global_group_notfound_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_global_group(self.tenant_group,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_global_group(self.tenant_group,
+                                                self.user, 
+                                                str(self.disabled_token)
+                                                )
+        respG, contentG = delete_user_global_group(self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_global_group_xml(self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+"""
+"""if __name__ == '__main__':
+    unittest.main()
+"""
+
+
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+
+URL = 'http://localhost:8080/v1.0/'
+
+
+def get_token(user, pswd, kind=''):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = {"passwordCredentials": {"username": user,
+                                        "password": pswd}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json"})
+        content = json.loads(content)
+        token = str(content['auth']['token']['id'])
+        if kind == 'token':
+            return token
+        else:
+            return (resp, content)
+
+
+def delete_token(token, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stoken/%s' % (URL, token)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_tenant(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+
+    url = '%stenants' % (URL)
+    body = {"tenant": {"id": tenantid,
+                       "description": "A description ...",
+                       "enabled": True}}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_tenant_group(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+
+    url = '%stenant/%s/groups' % (URL, tenantid)
+    body = {"group": {"id": groupid,
+                       "description": "A description ..."
+                         }}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def delete_tenant(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s' % (URL, tenantid)
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def delete_tenant_group(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenant/%s/groups/%s' % (URL, tenantid, groupid)
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_global_group(groupid, auth_token):
+    h = httplib2.Http(".cache")
+
+    url = '%sgroups' % (URL)
+    body = {"group": {"id": groupid,
+                       "description": "A description ..."
+                         }}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def create_global_group_xml(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups' % (URL)
+    body = '<?xml version="1.0" encoding="UTF-8"?>\
+            <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            id="%s"><description>A Description of the group</description>\
+                    </group>' % groupid
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_global_group(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s' % (URL, groupid)
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def delete_global_group_xml(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s' % (URL, groupid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def get_token_xml(user, pswd, type=''):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <passwordCredentials \
+                xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="%s" username="%s" \
+                tenantId="77654"/> ' % (pswd, user)
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                         "ACCEPT": "application/xml"})
+        dom = etree.fromstring(content)
+        root = dom.find("{http://docs.openstack.org/idm/api/v1.0}token")
+        token_root = root.attrib
+        token = str(token_root['id'])
+        if type == 'token':
+            return token
+        else:
+            return (resp, content)
+
+
+def delete_token_xml(token, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stoken/%s' % (URL, token)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def create_tenant_xml(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants' % (URL)
+    body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % tenantid
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def create_tenant_group_xml(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenant/%s/groups' % (URL, tenantid)
+    body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             id="%s"> \
+            <description>A description...</description> \
+            </group>' % groupid
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_tenant_xml(tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s' % (URL, tenantid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_tenant_group_xml(groupid, tenantid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenant/%s/groups/%s' % (URL, tenantid, groupid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def create_user(tenantid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users' % (URL, tenantid)
+    body = {"user": {"password": "secrete",
+                     "id": userid,
+                     "tenantId": tenantid,
+                     "email": "%s@rackspace.com" % userid,
+                     "enabled": True}}
+    resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+
+def delete_user(tenant, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users/%s' % (URL, tenant, userid)
+    
+    resp, content = h.request(url, "DELETE", body='{}',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    
+    return (resp, content)
+
+def create_user_xml(tenantid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users' % (URL, tenantid)
+    body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            email="joetest@rackspace.com" \
+            tenantId="%s" id="%s" \
+            enabled="true" password="secrete"/>' % (tenantid, userid)
+    resp, content = h.request(url, "POST", body=body,
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def delete_user_xml(tenantid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users/%s' % (URL, tenantid, userid)
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def add_user_tenant_group(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def add_user_tenant_group_xml(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def delete_user_tenant_group(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def delete_user_tenant_group_xml(tenantid, groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users/%s' % (URL, tenantid, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def get_user_tenant_group(tenantid, groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users' % (URL, tenantid, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def get_user_tenant_group_xml(tenantid, groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/groups/%s/users' % (URL, tenantid, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+
+def add_user_global_group(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def add_user_global_group_xml(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "PUT", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def delete_user_global_group(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+    return (resp, content)
+
+def delete_user_global_group_xml(groupid, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users/%s' % (URL, groupid, userid)
+    
+    resp, content = h.request(url, "DELETE", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+
+def get_user_global_group(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users' % (URL, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": auth_token})
+   
+    return (resp, content)
+
+def get_user_global_group_xml(groupid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%sgroups/%s/users' % (URL, groupid)
+    
+    resp, content = h.request(url, "GET", body='',
+                              headers={"Content-Type": "application/xml",
+                                       "X-Auth-Token": auth_token,
+                                       "ACCEPT": "application/xml"})
+    return (resp, content)
+  
+def get_tenant():
+    return '1234'
+
+
+def get_user():
+    return 'test_user'
+
+
+def get_userdisabled():
+    return '1234'
+
+
+def get_auth_token():
+    return '999888777666'
+
+
+def get_exp_auth_token():
+    return '000999'
+
+
+def get_disabled_token():
+    return '999888777'
+
+
+def content_type(resp):
+    return resp['content-type'].split(';')[0]
+
+def get_global_tenant():
+    return 'GlobalTenant'
+
+class identity_test(unittest.TestCase):
+
+    #Given _a_ to make inherited test cases in an order.
+    #here to call below method will call as last test case
+
+    def test_a_get_version_json(self):
+        h = httplib2.Http(".cache")
+        url = URL
+        resp, content = h.request(url, "GET", body="",
+                                  headers={"Content-Type":"application/json"})
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_get_version_xml(self):
+        h = httplib2.Http(".cache")
+        url = URL
+        resp, content = h.request(url, "GET", body="",
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+
+class authorize_test(identity_test):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+
+    def tearDown(self):
+        delete_token(self.token, self.auth_token)
+
+    def test_a_authorize(self):
+        resp, content = get_token('joeuser', 'secrete')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_authorize_xml(self):
+        resp, content = get_token_xml('joeuser', 'secrete')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_authorize_user_disabled(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = {"passwordCredentials": {"username": "disabled",
+                                        "password": "secrete"}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                headers={"Content-Type": "application/json"})
+        content = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_authorize_user_disabled_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <passwordCredentials \
+                xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="secrete" username="disabled" \
+                />'
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_authorize_user_wrong(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = {"passwordCredentials": {"username-w": "disabled",
+                                        "password": "secrete"}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                headers={"Content-Type": "application/json"})
+        content = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_authorize_user_wrong_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken' % URL
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <passwordCredentials \
+                xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="secrete" username-w="disabled" \
+                />'
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+
+class validate_token(authorize_test):
+
+    def test_validate_token_true(self):
+        h = httplib2.Http(".cache")
+
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.token, self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_validate_token_true_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.token, self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_validate_token_expired(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.exp_auth_token,
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_validate_token_expired_xml(self):
+        h = httplib2.Http(".cache")
+
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.exp_auth_token,
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_validate_token_invalid(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, 'NonExistingToken',
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_validate_token_invalid_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, 'NonExistingToken',
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+
+class tenant_test(unittest.TestCase):
 
     def setUp(self):
         self.token = get_token('joeuser', 'secrete', 'token')
@@ -5479,109 +6553,173 @@ class global_group_test(unittest.TestCase):
         self.auth_token = get_auth_token()
         self.exp_auth_token = get_exp_auth_token()
         self.disabled_token = get_disabled_token()
-        self.tenant_group = 'test_tenant_group'
 
     def tearDown(self):
-        resp, content = delete_tenant_group('test_tenant_group', \
-                                    self.tenant, self.auth_token)
         resp, content = delete_tenant(self.tenant, self.auth_token)
 
 
+class create_tenant_test(tenant_test):
 
-class create_global_group_test(global_group_test):
+    def test_tenant_create(self):
+        resp, content = delete_tenant('test_tenant', str(self.auth_token))
 
-    def test_global_group_create(self):
+        resp, content = create_tenant('test_tenant', str(self.auth_token))
+        self.tenant = 'test_tenant'
 
-        respG, contentG = delete_global_group('test_tenant_group', \
-                        str(self.auth_token))
-        respG, contentG = create_global_group(str(self.auth_token))
-        self.group = 'test_tenant_group'
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
 
-        if int(respG['status']) == 500:
+        if int(resp['status']) not in (200, 201):
+
+            self.fail('Failed due to %d' % int(resp['status']))
+
+    def test_tenant_create_xml(self):
+        resp, content = delete_tenant_xml('test_tenant', str(self.auth_token))
+        resp, content = create_tenant_xml('test_tenant', str(self.auth_token))
+        self.tenant = 'test_tenant'
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
             self.fail('IDM fault')
-        elif int(respG['status']) == 503:
+        elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        if int(respG['status']) not in (200, 201):
-            self.fail('Failed due to %d' % int(respG['status']))
 
+        if int(resp['status']) not in (200, 201):
 
-    def test_global_group_create_again(self):
+            self.fail('Failed due to %d' % int(resp['status']))
 
-        respG, contentG = create_global_group('test_tenant_group', \
-                         str(self.auth_token))
-        respG, contentG = create_global_group('test_tenant_group', \
-                        "test_tenant", str(self.auth_token))
+    def test_tenant_create_again(self):
 
-        if int(respG['status']) == 200:
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
-            self.tenant_group = contentG['group']['id']
-        if int(respG['status']) == 500:
+        if int(resp['status']) == 500:
             self.fail('IDM fault')
-        elif int(respG['status']) == 503:
+        elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(409, int(respG['status']))
-        if int(respG['status']) == 200:
+        self.assertEqual(409, int(resp['status']))
+        if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
-            self.tenant_group = contentG['group']['id']
 
-class create_tenant_group_test(tenant_group_test):
+    def test_tenant_create_again_xml(self):
 
-    def test_tenant_group_create_forbidden_token(self):
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get("id")
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(resp['status']))
+        if int(resp['status']) == 200:
+            self.tenant = content.get("id")
+
+    def test_tenant_create_forbidden_token(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant("test_tenant", str(self.auth_token))
-        respG, contentG = create_tenant_group_xml('test_tenant_group', \
-                        "test_tenant", str(self.auth_token))
         if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
 
-        if int(respG['status']) == 200:
-            self.tenant_group = respG['group']['id']
-
-        url = '%stenant/%s/groups' % (URL, self.tenant)
-        body = {"group": {"id": self.tenant_group,
-                   "description": "A description ..."
-                   }}
+        url = '%stenants' % (URL)
+        body = {"tenant": {"id": self.tenant,
+                           "description": "A description ...",
+                           "enabled": True}}
         resp, content = h.request(url, "POST", body=json.dumps(body),
-                      headers={"Content-Type": "application/json",
-                         "X-Auth-Token": self.token})
+                                  headers={"Content-Type": "application/json",
+                                         "X-Auth-Token": self.token})
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(resp['status']))
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_forbidden_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
 
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
 
-    def test_tenant_group_create_expired_token(self):
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_expired_token(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant("test_tenant", str(self.auth_token))
         if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
 
-        url = '%stenant/%s/groups' % (URL, self.tenant)
-        body = {"group": {"id": self.tenant_group,
-                   "description": "A description ..."
-                   }}
+        url = '%stenants' % (URL)
+        body = {"tenant": {"id": self.tenant,
+                           "description": "A description ...",
+                           "enabled": True}}
         resp, content = h.request(url, "POST", body=json.dumps(body),
-                    headers={"Content-Type": "application/json",
-                         "X-Auth-Token": self.exp_auth_token})
+                                headers={"Content-Type": "application/json",
+                                         "X-Auth-Token": self.exp_auth_token})
+
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401, int(resp['status']))
+        self.assertEqual(403, int(resp['status']))
 
-    def test_tenant_group_create_missing_token(self):
+    def test_tenant_create_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_create_missing_token(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant("test_tenant", str(self.auth_token))
         if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
 
-        url = '%stenant/%s/groups' % (URL, self.tenant)
-        body = {"group": {"id": self.tenant_group,
-                   "description": "A description ..."}}
+        url = '%stenants' % (URL)
+        body = {"tenant": {"id": self.tenant,
+                           "description": "A description ...",
+                           "enabled": True}}
         resp, content = h.request(url, "POST", body=json.dumps(body),
-                    headers={"Content-Type": "application/json"})
+                                headers={"Content-Type": "application/json"})
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -5589,18 +6727,44 @@ class create_tenant_group_test(tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
-    def test_tenant_group_create_disabled_token(self):
+    def test_tenant_create_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_disabled_token(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant("test_tenant", str(self.auth_token))
         if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
 
-        url = '%stenant/%s/groups' % (URL, self.tenant)
-        body = '{"group": { "id": "%s", \
-            "description": "A description ..." } }' % self.tenant_group
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/json",\
-                         "X-Auth-Token": self.disabled_token})
+        url = '%stenants' % (URL)
+        body = '{"tenant": { "id": "%s", \
+                "description": "A description ...", "enabled"\
+                :true  } }' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token
+                                           })
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -5608,147 +6772,647 @@ class create_tenant_group_test(tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
-    def test_tenant_group_create_invalid_token(self):
+    def test_tenant_create_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_create_invalid_token(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant("test_tenant", str(self.auth_token))
         if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
 
-        url = '%stenant/%s/groups' % (URL, self.tenant)
-        body = '{"group": { "id": "%s", \
-            "description": "A description ..." } }' % self.tenant
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/json",\
-                         "X-Auth-Token": 'nonexsitingtoken'})
+        url = '%stenants' % (URL)
+        body = '{"tenant": { "id": "%s", \
+                "description": "A description ...", "enabled"\
+                :true  } }' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": 'nonexsitingtoken'})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_tenant_create_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": 'nonexsitingtoken',
+                                           "ACCEPT": "application/xml"})
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class get_tenants_test(tenant_test):
+
+    def test_get_tenants(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenants_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenants_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
+    def test_get_tenants_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
 
+    def test_get_tenants_exp_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_get_tenants_exp_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+
+class get_tenant_test(tenant_test):
+
+    def test_get_tenant(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, 'tenant_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, 'tenant_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class update_tenant_test(tenant_test):
+
+    def test_update_tenant(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '{"tenant": { "description": "A NEW description..." ,\
+                "enabled":true }}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        body = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(int(self.tenant), int(body['tenant']['id']))
+        self.assertEqual('A NEW description...', body['tenant']['description'])
+
+    def test_update_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             enabled="true"> \
+             <description>A NEW description...</description> \
+             </tenant>'
+
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        body = etree.fromstring(content)
+        desc = body.find("{http://docs.openstack.org/idm/api/v1.0}description")
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(int(self.tenant), int(body.get('id')))
+        self.assertEqual('A NEW description...', desc.text)
+
+    def test_update_tenant_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '{"tenant": { "description_bad": "A NEW description...",\
+                "enabled":true  }}'
+        #test for Content-Type = application/json
+
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             enabled="true"> \
+             <description_bad>A NEW description...</description> \
+             </tenant>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        data = '{"tenant": { "description": "A NEW description...",\
+                "enabled":true  }}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_update_tenant_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             enabled="true"> \
+             <description_bad>A NEW description...</description> \
+             </tenant>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class delete_tenant_test(tenant_test):
+
+    def test_delete_tenant_not_found(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant("test_tenant_delete111",
+                                      str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant_not_found_xml(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant_xml("test_tenant_delete111",
+                                          str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant(self):
+        resp, content = create_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        resp, content = delete_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        self.assertEqual(204, int(resp['status']))
+
+    def test_delete_tenant_xml(self):
+        resp, content = create_tenant_xml("test_tenant_delete",
+                                          str(self.auth_token))
+        resp, content = delete_tenant_xml("test_tenant_delete",
+                                          str(self.auth_token))
+        self.assertEqual(204, int(resp['status']))
 
-    def test_tenant_group_create_xml(self):
-        resp, content = delete_tenant_xml('test_tenant', str(self.auth_token))
-        resp, content = create_tenant_xml('test_tenant', str(self.auth_token))
-        respG, contentG = delete_tenant_group_xml('test_tenant_group', \
-                        "test_tenant", str(self.auth_token))
-        respG, contentG = create_tenant_group_xml('test_tenant_group', \
-                        "test_tenant", str(self.auth_token))
 
-        print contentG
+class tenant_group_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
         self.tenant = 'test_tenant'
-        self.tenant_group = 'test_tenant_group'
-        content = etree.fromstring(content)
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_tenant_group_add'
+
+    def tearDown(self):
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+
+
+class create_tenant_group_test(tenant_group_test):
+
+    def test_tenant_group_create(self):
+        resp, content = delete_tenant(self.tenant, str(self.auth_token))
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = delete_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
 
+    def test_tenant_group_create_xml(self):
+        resp, content = delete_tenant_xml(self.tenant, str(self.auth_token))
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        respG, contentG = delete_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        self.tenant = self.tenant
+        self.tenant_group = self.tenant_group
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
         if int(respG['status']) not in (200, 201):
             self.fail('Failed due to %d' % int(respG['status']))
 
-    def test_tenant_group_create_again_xml(self):
+    def test_tenant_group_create_again(self):
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        if int(respG['status']) == 200:
+            self.tenant = content['tenant']['id']
+            self.tenant_group = contentG['group']['id']
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+            self.assertEqual(409, int(respG['status']))
+        if int(respG['status']) == 200:
+            self.tenant = content['tenant']['id']
+            self.tenant_group = contentG['group']['id']
 
+    def test_tenant_group_create_again_xml(self):
         resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
-
-        respG, contentG = create_tenant_group_xml('test_tenant_group', \
-                        "test_tenant", str(self.auth_token))
-        respG, contentG = create_tenant_group_xml('test_tenant_group', \
-                        "test_tenant", str(self.auth_token))
-
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
         content = etree.fromstring(content)
         contentG = etree.fromstring(contentG)
         if int(respG['status']) == 200:
             self.tenant = content.get("id")
             self.tenant_group = contentG.get("id")
-
         if int(respG['status']) == 500:
             self.fail('IDM fault')
         elif int(respG['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(409, int(respG['status']))
+            self.assertEqual(409, int(respG['status']))
         if int(respG['status']) == 200:
             self.tenant = content.get("id")
             self.tenant_group = contentG.get("id")
 
-    def test_tenant_group_create_forbidden_token_xml(self):
+    def test_tenant_group_create_unauthorized_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
         if int(resp['status']) == 200:
             self.tenant = content['tenant']['id']
+        if int(respG['status']) == 200:
+            self.tenant_group = respG['group']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = {"group": {"id": self.tenant_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                             headers={"Content-Type": "application/json",
+                                      "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+            self.assertEqual(401, int(resp['status']))
 
+    def test_tenant_group_create_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
         url = '%stenant/%s/groups' % (URL, self.tenant)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
-        <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
-         id="%s"> \
-        <description>A description...</description> \
-        </group>' % self.tenant_group
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/xml", \
-                         "X-Auth-Token": self.token,
-                         "ACCEPT": "application/xml"})
-
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
 
+    def test_tenant_group_create_expired_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = {"group": {"id": self.tenant_group,
+                "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": self.exp_auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
     def test_tenant_group_create_expired_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
         content = etree.fromstring(content)
         if int(resp['status']) == 200:
             self.tenant = content.get('id')
-
         url = '%stenant/%s/groups' % (URL, self.tenant)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
-        <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
-         id="%s"> \
-        <description>A description...</description> \
-        </group>' % self.tenant
-
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/xml", \
-                         "X-Auth-Token": self.exp_auth_token,
-                         "ACCEPT": "application/xml"})
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                 id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
 
+    def test_tenant_group_create_missing_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = {"group": {"id": self.tenant_group,
+                "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                          headers={"Content-Type": "application/json"})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
+
     def test_tenant_group_create_missing_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
         content = etree.fromstring(content)
         if int(resp['status']) == 200:
             self.tenant = content.get('id')
-
         url = '%stenant/%s/groups' % (URL, self.tenant)
-
         body = '<?xml version="1.0" encoding="UTF-8"?> \
-        <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
-        id="%s"> \
-        <description>A description...</description> \
-        </group>' % self.tenant_group
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/xml",
-                         "ACCEPT": "application/xml"})
-
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
+
+    def test_tenant_group_create_disabled_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '{"group": { "id": "%s", \
+            "description": "A description ..." } }' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
     def test_tenant_group_create_disabled_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
         content = etree.fromstring(content)
         if int(resp['status']) == 200:
             self.tenant = content.get('id')
@@ -5759,41 +7423,1510 @@ class create_tenant_group_test(tenant_group_test):
         id="%s"> \
         <description>A description...</description> \
         </group>' % self.tenant_group
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/xml",
-                         "X-Auth-Token": self.disabled_token,
-                         "ACCEPT": "application/xml"})
-
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(403, int(resp['status']))
 
+    def test_tenant_group_create_invalid_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '{"group": { "id": "%s", \
+            "description": "A description ..." } }' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": 'nonexsitingtoken'})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
     def test_tenant_group_create_invalid_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
         content = etree.fromstring(content)
         if int(resp['status']) == 200:
             self.tenant = content.get('id')
 
         url = '%stenant/%s/groups' % (URL, self.tenant)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
-        <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
-         id="%s"> \
-        <description>A description...</description> \
-        </group>' % self.tenant_group
-        resp, content = h.request(url, "POST", body=body,\
-                    headers={"Content-Type": "application/xml",\
-                         "X-Auth-Token": 'nonexsitingtoken',
-                         "ACCEPT": "application/xml"})
+                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                 id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": 'nonexsitingtoken',
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class get_tenant_groups_test(tenant_group_test):
+
+    def test_get_tenant_groups(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_groups_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
 
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_groups_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
+    def test_get_tenant_groups_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_tenant_groups_exp_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_get_tenant_groups_exp_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+
+class get_tenant_group_test(tenant_group_test):
+
+    def test_get_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        #test for Content-Type = application/xml
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_group_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, 'tenant_bad', self.tenant_group)
+
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, 'tenant_bad', self.tenant_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_group_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, 'nonexistinggroup')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+              self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+              self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_group_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, 'nonexistinggroup')
+
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class update_tenant_group_test(tenant_group_test):
+
+    def test_update_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        
+        data = '{"group": { "id":"%s","description": "A NEW description..." ,\
+                "tenantId":"%s" }}' % (self.tenant_group, self.tenant)
+        #test for Content-Type = application/json
+        
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        
+        
+        body = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(self.tenant_group, body['group']['id'])
+        self.assertEqual('A NEW description...', body['group']['description'])
+
+    def test_update_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = delete_tenant(self.tenant, str(self.auth_token))
+        
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant , self.tenant_group)
+        
+        data = '<group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             tenantId="%s" id="%s"> \
+             <description>A NEW description...</description> \
+             </group>' % (self.tenant, self.tenant_group)
+        
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.auth_token,
+                                         "ACCEPT": "application/xml"})
+        
+        
+        body = etree.fromstring(content)
+        desc = body.find("{http://docs.openstack.org/idm/api/v1.0}description")
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(str(self.tenant_group), str(body.get('id')))
+        self.assertEqual('A NEW description...', desc.text)
+
+    def test_update_tenant_group_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        data = '{"group": { "description_bad": "A NEW description...",\
+            "id":"%s","tenantId":"%s"  }}' % (self.tenant_group, self.tenant)
+        #test for Content-Type = application/json
+
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             tenantId="%s" id="%s"> \
+             <description_bad>A NEW description...</description> \
+             </group>' % (self.tenant, self.tenant_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_group_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/NonexistingID' % (URL, self.tenant)
+
+        data = '{"group": { "description": "A NEW description...",\
+            "id":"NonexistingID", "tenantId"="test_tenant"  }}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_update_tenant_group_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenant/%s/groups/NonexistingID' % (URL, self.tenant)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             id="NonexistingID", "tenant_id"="test_tenant"> \
+             <description_bad>A NEW description...</description> \
+             </group>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class delete_tenant_group_test(tenant_test):
+
+    def test_delete_tenant_group_not_found(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant_group("test_tenant_delete111",
+                                            self.tenant,
+                                            str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant_group_not_found_xml(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant_group_xml("test_tenant_delete111",
+                                                self.tenant,
+                                                str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant_group(self):
+        resp, content = create_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        respG, contentG = create_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        respG, contentG = delete_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        resp, content = delete_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+    def test_delete_tenant_group_xml(self):
+        resp, content = create_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        respG, contentG = create_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        respG, contentG = delete_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        resp, content = delete_tenant_xml("test_tenant_delete",
+                                          str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+
+class add_user_tenant_group_test(unittest.TestCase):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = 'test_tenant'
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_tenant_group_add'
+
+    def tearDown(self):
+        respG, contentG = delete_user_tenant_group(self.tenant,
+                                                   self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+        
+        
+    def test_add_user_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_tenant_group_conflict(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+    
+    def test_add_user_tenant_group_conflict_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+    def test_add_user_tenant_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_tenant_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, self.token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_tenant_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.disabled_token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_add_user_tenant_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, self.disabled_token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+
+class get_users_tenant_group_test(add_user_tenant_group_test):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = 'test_tenant'
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_tenant_group_add'
+
+    def tearDown(self):
+        respG, contentG = delete_user_tenant_group(self.tenant,
+                                                   self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+           
+    def test_get_users_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
+                                                str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+    
+    def test_get_users_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+        
+    def test_get_users_tenant_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        
+        respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
+                                                str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_tenant_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_tenant_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group(self.tenant, 
+                                                self.tenant_group,
+                                                str(self.disabled_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_tenant_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.disabled_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_tenant_group_expired(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
+                                                str(self.exp_auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_tenant_group_expired_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.exp_auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+class delete_users_tenant_group_test(add_user_tenant_group_test):  
+    
+    def test_delete_user_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_tenant_group(self.tenant, 
+                                                   self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+        
+    
+    def test_delete_user_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        respG, contentG = delete_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+    
+    def test_delete_user_tenant_group_notfound(self):
+        h = httplib2.Http(".cache")
+        
+        respG, contentG = delete_user_tenant_group(self.tenant, 
+                                                   self.tenant_group,
+                                                   'NonExistinguser', 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+        
+    def test_delete_user_tenant_group_notfound_xml(self):
+        h = httplib2.Http(".cache")
+        
+        respG, contentG = delete_user_tenant_group_xml(self.tenant, 
+                                                   self.tenant_group,
+                                                   'NonExistinguser', 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+
+
+##
+## Global Group Tests
+##
+class global_group_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.globaltenant = get_global_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.global_group = 'test_global_group_add'
+
+    def tearDown(self):
+        resp, content = delete_global_group(self.global_group,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.globaltenant, self.auth_token)
+
+
+class create_global_group_test(global_group_test):
+
+    def test_global_group_create(self):
+        respG, contentG = delete_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+
+    def test_global_group_create_xml(self):
+        respG, contentG = delete_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+
+    def test_global_group_create_again(self):
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+
+    def test_global_group_create_again_xml(self):
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        contentG = etree.fromstring(contentG)
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+
+    def test_global_group_create_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        body = {"group": {"id": self.global_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_expired_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = {"group": {"id": self.global_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.globaltenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_missing_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = {"group": {"id": self.global_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_global_group_create_disabled_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '{"group": { "id": "%s", \
+                "description": "A description ..." } }' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_global_group_create_invalid_token(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '{"group": { "id": "%s", \
+                "description": "A description ..." } }' % self.globaltenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": 'nonexsitingtoken'})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_global_group_create_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%sgroups' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.global_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": 'nonexsitingtoken',
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class get_global_groups_test(global_group_test):
+
+    def test_get_global_groups(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = delete_global_group(self.global_group,
+                                              str(self.auth_token))
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        
+        url = '%sgroups' % (URL)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_groups_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_groups_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_global_groups_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_global_groups_exp_token(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_get_global_groups_exp_token_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+
+class get_global_group_test(global_group_test):
+
+    def test_get_global_group(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_global_group_bad(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, 'global_group_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_global_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups/%s' % (URL , 'global_group_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    
+
+class update_global_groups_test(global_group_test):
+
+    def test_update_global_group(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        resp, content = h.request(url, "PUT", body='{"group":{\
+                "id" : "%s","description" :\
+                "A New description of the group..."}}' % self.global_group,
+                headers={"Content-Type": "application/json",
+                         "X-Auth-Token": self.auth_token})
+        body = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(self.global_group, body['group']['id'])
+        self.assertEqual('A New description of the group...',
+                         str(body['group']['description']))
+
+    def test_update_global_group_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                                  str(self.auth_token))
+        
+        url = '%sgroups/%s' % (URL, self.global_group)
+        data = u'<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A NEW description...</description> \
+                </group>' % (self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        
+        body = etree.fromstring(content)
+        desc = body.find("{http://docs.openstack.org/idm/api/v1.0}description")
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(str(self.global_group), str(body.get('id')))
+        self.assertEqual('A NEW description...', desc.text)
+
+    def test_update_global_group_bad(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        data = '{"group": { "description_bad": "A NEW description...", \
+                "id":"%s"  }}'\
+                % (self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_global_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group_xml(self.global_group,
+                                                  str(self.auth_token))
+        url = '%sgroups/%s' % (URL, self.global_group)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description_bad>A NEW description...</description> \
+                </group>' % (self.global_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_global_group_not_found(self):
+        h = httplib2.Http(".cache")
+        respG, contentG = create_global_group(self.global_group,
+                                              str(self.auth_token))
+        url = '%sgroups/NonexistingID' % (URL)
+        data = '{"group": { "description": "A NEW description...", \
+                "id":"NonexistingID"}}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_update_global_group_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.globaltenant,
+                                          str(self.auth_token))
+        url = '%sgroups/NonexistingID' % (URL)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="NonexistingID"> \
+                <description_bad>A NEW description...</description> \
+                </group>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class delete_global_group_test(global_group_test):
+
+    def test_delete_global_group_not_found(self):
+        resp, content = delete_global_group("test_global_group_1",
+                                            str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_global_group_not_found_xml(self):
+        resp, content = delete_global_group_xml("test_global_group_1",
+                                                str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_global_group(self):
+        resp, content = create_tenant(self.globaltenant, str(self.auth_token))
+        respG, contentG = create_tenant_group('test_global_group_delete',
+                                              self.globaltenant,
+                                              str(self.auth_token))
+        respG, contentG = delete_global_group('test_global_group_delete',
+                                              str(self.auth_token))
+        resp, content = delete_tenant(self.globaltenant,
+                                      str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+    def test_delete_global_group_xml(self):
+        resp, content = create_tenant_xml(self.globaltenant,
+                                          str(self.auth_token))
+        respG, contentG = create_tenant_group_xml('test_global_group_delete',
+                                                  self.globaltenant,
+                                                  str(self.auth_token))
+        respG, contentG = delete_global_group_xml('test_global_group_delete',
+                                                  str(self.auth_token))
+        resp, content = delete_tenant_xml(self.globaltenant,
+                                          str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+
 class add_user_global_group_test(unittest.TestCase):
     
     def setUp(self):
diff --git a/test/unit/test_tenant_groups.py b/test/unit/test_tenant_groups.py
new file mode 100644
index 00000000..b7761329
--- /dev/null
+++ b/test/unit/test_tenant_groups.py
@@ -0,0 +1,1213 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+
+
+class tenant_group_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_tenant_group_add'
+
+    def tearDown(self):
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+
+
+class create_tenant_group_test(tenant_group_test):
+
+    def test_tenant_group_create(self):
+
+        resp, content = delete_tenant(self.tenant, str(self.auth_token))
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = delete_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+
+    def test_tenant_group_create_xml(self):
+        resp, content = delete_tenant_xml(self.tenant, str(self.auth_token))
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        respG, contentG = delete_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        self.tenant = self.tenant
+        self.tenant_group = self.tenant_group
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+
+    def test_tenant_group_create_again(self):
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        if int(respG['status']) == 200:
+            self.tenant = content['tenant']['id']
+            self.tenant_group = contentG['group']['id']
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+            self.assertEqual(409, int(respG['status']))
+        if int(respG['status']) == 200:
+            self.tenant = content['tenant']['id']
+            self.tenant_group = contentG['group']['id']
+
+    def test_tenant_group_create_again_xml(self):
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        content = etree.fromstring(content)
+        contentG = etree.fromstring(contentG)
+        if int(respG['status']) == 200:
+            self.tenant = content.get("id")
+            self.tenant_group = contentG.get("id")
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+            self.assertEqual(409, int(respG['status']))
+        if int(respG['status']) == 200:
+            self.tenant = content.get("id")
+            self.tenant_group = contentG.get("id")
+
+    def test_tenant_group_create_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        if int(respG['status']) == 200:
+            self.tenant_group = respG['group']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = {"group": {"id": self.tenant_group,
+                          "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                             headers={"Content-Type": "application/json",
+                                      "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+            self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_group_create_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"><description>A description...</description> \
+                </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_group_create_expired_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = {"group": {"id": self.tenant_group,
+                "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                              headers={"Content-Type": "application/json",
+                                       "X-Auth-Token": self.exp_auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_group_create_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                 id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_group_create_missing_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = {"group": {"id": self.tenant_group,
+                "description": "A description ..."}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                          headers={"Content-Type": "application/json"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+
+    def test_tenant_group_create_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+
+    def test_tenant_group_create_disabled_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '{"group": { "id": "%s", \
+            "description": "A description ..." } }' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_group_create_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+        <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+        id="%s"> \
+        <description>A description...</description> \
+        </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_group_create_invalid_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '{"group": { "id": "%s", \
+            "description": "A description ..." } }' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": 'nonexsitingtoken'})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_tenant_group_create_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                 id="%s"> \
+                <description>A description...</description> \
+                </group>' % self.tenant_group
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": 'nonexsitingtoken',
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class get_tenant_groups_test(tenant_group_test):
+
+    def test_get_tenant_groups(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_groups_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+
+        respG, contentG = create_tenant_group_xml(self.tenant_group,
+                                                  self.tenant,
+                                                  str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_groups_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_tenant_groups_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_tenant_groups_exp_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_get_tenant_groups_exp_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+
+class get_tenant_group_test(tenant_group_test):
+
+    def test_get_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        #test for Content-Type = application/xml
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_group_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, 'tenant_bad', self.tenant_group)
+
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, 'tenant_bad', self.tenant_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_group_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, 'nonexistinggroup')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+              self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+              self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_group_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, 'nonexistinggroup')
+
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class update_tenant_group_test(tenant_group_test):
+
+    def test_update_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        
+        data = '{"group": { "id":"%s","description": "A NEW description..." ,\
+                "tenantId":"%s" }}' % (self.tenant_group, self.tenant)
+        #test for Content-Type = application/json
+        
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        
+        
+        body = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(self.tenant_group, body['group']['id'])
+        self.assertEqual('A NEW description...', body['group']['description'])
+
+    def test_update_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = delete_tenant(self.tenant, str(self.auth_token))
+        
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant , self.tenant_group)
+        
+        data = '<group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             tenantId="%s" id="%s"> \
+             <description>A NEW description...</description> \
+             </group>' % (self.tenant, self.tenant_group)
+        
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.auth_token,
+                                         "ACCEPT": "application/xml"})
+        
+        
+        body = etree.fromstring(content)
+        desc = body.find("{http://docs.openstack.org/idm/api/v1.0}description")
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(str(self.tenant_group), str(body.get('id')))
+        self.assertEqual('A NEW description...', desc.text)
+
+    def test_update_tenant_group_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        data = '{"group": { "description_bad": "A NEW description...",\
+            "id":"%s","tenantId":"%s"  }}' % (self.tenant_group, self.tenant)
+        #test for Content-Type = application/json
+
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_group_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             tenantId="%s" id="%s"> \
+             <description_bad>A NEW description...</description> \
+             </group>' % (self.tenant, self.tenant_group)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_group_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        url = '%stenant/%s/groups/NonexistingID' % (URL, self.tenant)
+
+        data = '{"group": { "description": "A NEW description...",\
+            "id":"NonexistingID", "tenantId"="test_tenant"  }}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_update_tenant_group_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenant/%s/groups/NonexistingID' % (URL, self.tenant)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             id="NonexistingID", "tenant_id"="test_tenant"> \
+             <description_bad>A NEW description...</description> \
+             </group>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class delete_tenant_group_test(tenant_group_test):
+
+    def test_delete_tenant_group_not_found(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant_group("test_tenant_delete111",
+                                            self.tenant,
+                                            str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant_group_not_found_xml(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant_group_xml("test_tenant_delete111",
+                                                self.tenant,
+                                                str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant_group(self):
+        resp, content = create_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        respG, contentG = create_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        respG, contentG = delete_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        resp, content = delete_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+    def test_delete_tenant_group_xml(self):
+        resp, content = create_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        respG, contentG = create_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        respG, contentG = delete_tenant_group('test_tenant_group_delete',
+                                              "test_tenant_delete",
+                                              str(self.auth_token))
+        resp, content = delete_tenant_xml("test_tenant_delete",
+                                          str(self.auth_token))
+        self.assertEqual(204, int(respG['status']))
+
+
+class add_user_tenant_group_test(tenant_group_test):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = 'test_tenant'
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_tenant_group_add'
+
+    def tearDown(self):
+        respG, contentG = delete_user_tenant_group(self.tenant,
+                                                   self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+        
+        
+    def test_add_user_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        if int(respG['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(respG['status']))
+        
+    
+    def test_add_user_tenant_group_conflict(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+    
+    def test_add_user_tenant_group_conflict_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(respG['status']))
+        
+    def test_add_user_tenant_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_tenant_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, self.token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_add_user_tenant_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.disabled_token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_add_user_tenant_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+                                                self.user, self.disabled_token)
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+
+class get_users_tenant_group_test(tenant_group_test):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = 'test_tenant'
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.tenant_group = 'test_tenant_group_add'
+
+    def tearDown(self):
+        respG, contentG = delete_user_tenant_group(self.tenant,
+                                                   self.tenant_group,
+                                                   self.user,
+                                                   str(self.auth_token))
+        
+        respG, contentG = delete_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        resp, content = delete_tenant_group(self.tenant_group,
+                                            self.tenant,
+                                            self.auth_token)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+           
+    def test_get_users_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
+                                                str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+    
+    def test_get_users_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(respG['status']))
+        
+        
+    def test_get_users_tenant_group_unauthorized(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        
+        respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
+                                                str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_tenant_group_unauthorized_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(respG['status']))
+        
+    def test_get_users_tenant_group_forbidden(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group(self.tenant, 
+                                                self.tenant_group,
+                                                str(self.disabled_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_tenant_group_forbidden_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.disabled_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_tenant_group_expired(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
+                                                str(self.exp_auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+    def test_get_users_tenant_group_expired_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, self.auth_token)
+        respG, contentG = get_user_tenant_group_xml(self.tenant, 
+                                                    self.tenant_group,
+                                                    str(self.exp_auth_token)
+                                                )
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(respG['status']))
+    
+class delete_users_tenant_group_test(tenant_group_test):  
+    
+    def test_delete_user_tenant_group(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
+                                                self.user, str(self.auth_token)
+                                                )
+        respG, contentG = delete_user_tenant_group(self.tenant, 
+                                                   self.tenant_group,
+                                                   self.user, 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+        
+    
+    def test_delete_user_tenant_group_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        respG, contentG = create_tenant_group(self.tenant_group,
+                                              self.tenant,
+                                              str(self.auth_token))
+        respG, contentG = create_user(self.tenant, self.user,
+                                      str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        respG, contentG = delete_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    str(self.auth_token))
+        
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, int(respG['status']))
+    
+    def test_delete_user_tenant_group_notfound(self):
+        h = httplib2.Http(".cache")
+        
+        respG, contentG = delete_user_tenant_group(self.tenant, 
+                                                   self.tenant_group,
+                                                   'NonExistinguser', 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+        
+    def test_delete_user_tenant_group_notfound_xml(self):
+        h = httplib2.Http(".cache")
+        
+        respG, contentG = delete_user_tenant_group_xml(self.tenant, 
+                                                   self.tenant_group,
+                                                   'NonExistinguser', 
+                                                   str(self.auth_token)
+                                                )
+        
+        if int(respG['status']) == 500:
+            self.fail('IDM fault')
+        elif int(respG['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(respG['status']))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/test/unit/test_tenants.py b/test/unit/test_tenants.py
new file mode 100644
index 00000000..a4713c52
--- /dev/null
+++ b/test/unit/test_tenants.py
@@ -0,0 +1,643 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+class tenant_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+
+    def tearDown(self):
+        resp, content = delete_tenant(self.tenant, self.auth_token)
+        
+
+class create_tenant_test(tenant_test):
+     
+    def test_tenant_create(self):
+        resp, content = delete_tenant('test_tenant', str(self.auth_token))
+        resp, content = create_tenant('test_tenant', str(self.auth_token))
+        self.tenant = 'test_tenant'
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+
+        if int(resp['status']) not in (200, 201):
+
+            self.fail('Failed due to %d' % int(resp['status']))
+
+    def test_tenant_create_xml(self):
+        resp, content = delete_tenant_xml('test_tenant', str(self.auth_token))
+        resp, content = create_tenant_xml('test_tenant', str(self.auth_token))
+        self.tenant = 'test_tenant'
+        content = etree.fromstring(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+
+        if int(resp['status']) not in (200, 201):
+
+            self.fail('Failed due to %d' % int(resp['status']))
+
+    def test_tenant_create_again(self):
+
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(resp['status']))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+    def test_tenant_create_again_xml(self):
+
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get("id")
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, int(resp['status']))
+        if int(resp['status']) == 200:
+            self.tenant = content.get("id")
+
+    def test_tenant_create_forbidden_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenants' % (URL)
+        body = {"tenant": {"id": self.tenant,
+                           "description": "A description ...",
+                           "enabled": True}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                  headers={"Content-Type": "application/json",
+                                         "X-Auth-Token": self.token})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_forbidden_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_expired_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenants' % (URL)
+        body = {"tenant": {"id": self.tenant,
+                           "description": "A description ...",
+                           "enabled": True}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                headers={"Content-Type": "application/json",
+                                         "X-Auth-Token": self.exp_auth_token})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_create_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_create_missing_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenants' % (URL)
+        body = {"tenant": {"id": self.tenant,
+                           "description": "A description ...",
+                           "enabled": True}}
+        resp, content = h.request(url, "POST", body=json.dumps(body),
+                                headers={"Content-Type": "application/json"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_tenant_create_disabled_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenants' % (URL)
+        body = '{"tenant": { "id": "%s", \
+                "description": "A description ...", "enabled"\
+                :true  } }' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token
+                                           })
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_create_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_tenant_create_invalid_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant("test_tenant", str(self.auth_token))
+        if int(resp['status']) == 200:
+            self.tenant = content['tenant']['id']
+
+        url = '%stenants' % (URL)
+        body = '{"tenant": { "id": "%s", \
+                "description": "A description ...", "enabled"\
+                :true  } }' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": 'nonexsitingtoken'})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_tenant_create_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml("test_tenant", str(self.auth_token))
+        content = etree.fromstring(content)
+        if int(resp['status']) == 200:
+            self.tenant = content.get('id')
+
+        url = '%stenants' % (URL)
+        body = '<?xml version="1.0" encoding="UTF-8"?> \
+            <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+            enabled="true" id="%s"> \
+            <description>A description...</description> \
+            </tenant>' % self.tenant
+        resp, content = h.request(url, "POST", body=body,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": 'nonexsitingtoken',
+                                           "ACCEPT": "application/xml"})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class get_tenants_test(tenant_test):
+
+    def test_get_tenants(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenants_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenants_unauthorized_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_tenants_unauthorized_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+
+    def test_get_tenants_exp_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+    def test_get_tenants_exp_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+
+
+class get_tenant_test(tenant_test):
+
+    def test_get_tenant(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+
+    def test_get_tenant_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, 'tenant_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, 'tenant_bad')
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_get_tenant_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class update_tenant_test(tenant_test):
+
+    def test_update_tenant(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '{"tenant": { "description": "A NEW description..." ,\
+                "enabled":true }}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        body = json.loads(content)
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(int(self.tenant), int(body['tenant']['id']))
+        self.assertEqual('A NEW description...', body['tenant']['description'])
+
+    def test_update_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             enabled="true"> \
+             <description>A NEW description...</description> \
+             </tenant>'
+
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        body = etree.fromstring(content)
+        desc = body.find("{http://docs.openstack.org/idm/api/v1.0}description")
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual(int(self.tenant), int(body.get('id')))
+        self.assertEqual('A NEW description...', desc.text)
+
+    def test_update_tenant_bad(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '{"tenant": { "description_bad": "A NEW description...",\
+                "enabled":true  }}'
+        #test for Content-Type = application/json
+
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_bad_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/%s' % (URL, self.tenant)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             enabled="true"> \
+             <description_bad>A NEW description...</description> \
+             </tenant>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(400, int(resp['status']))
+
+    def test_update_tenant_not_found(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        data = '{"tenant": { "description": "A NEW description...",\
+                "enabled":true  }}'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+    def test_update_tenant_not_found_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_tenant(self.tenant, str(self.auth_token))
+        url = '%stenants/NonexistingID' % (URL)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+             <tenant xmlns="http://docs.openstack.org/idm/api/v1.0" \
+             enabled="true"> \
+             <description_bad>A NEW description...</description> \
+             </tenant>'
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, int(resp['status']))
+
+
+class delete_tenant_test(tenant_test):
+
+    def test_delete_tenant_not_found(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant("test_tenant_delete111",
+                                      str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant_not_found_xml(self):
+        #resp,content=create_tenant("test_tenant_delete", str(self.auth_token))
+        resp, content = delete_tenant_xml("test_tenant_delete111",
+                                          str(self.auth_token))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_delete_tenant(self):
+        resp, content = create_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        resp, content = delete_tenant("test_tenant_delete",
+                                      str(self.auth_token))
+        self.assertEqual(204, int(resp['status']))
+
+    def test_delete_tenant_xml(self):
+        resp, content = create_tenant_xml("test_tenant_delete",
+                                          str(self.auth_token))
+        resp, content = delete_tenant_xml("test_tenant_delete",
+                                          str(self.auth_token))
+        self.assertEqual(204, int(resp['status']))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/test/unit/test_token.py b/test/unit/test_token.py
new file mode 100644
index 00000000..b75592dc
--- /dev/null
+++ b/test/unit/test_token.py
@@ -0,0 +1,119 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+
+class validate_token(unittest.TestCase):
+    
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+
+    def tearDown(self):
+        delete_token(self.token, self.auth_token)
+        
+    def test_validate_token_true(self):
+        h = httplib2.Http(".cache")
+
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.token, self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_validate_token_true_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.token, self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_validate_token_expired(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.exp_auth_token,
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_validate_token_expired_xml(self):
+        h = httplib2.Http(".cache")
+
+        url = '%stoken/%s?belongsTo=%s' % (URL, self.exp_auth_token,
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_validate_token_invalid(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, 'NonExistingToken',
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_validate_token_invalid_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stoken/%s?belongsTo=%s' % (URL, 'NonExistingToken',
+                                           self.tenant)
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/test/unit/test_users.py b/test/unit/test_users.py
new file mode 100644
index 00000000..31afe408
--- /dev/null
+++ b/test/unit/test_users.py
@@ -0,0 +1,1638 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+class user_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.password = get_password()
+        self.email = get_email()
+        self.user = get_user()
+        self.userdisabled = get_userdisabled()
+        self.auth_token = get_auth_token()
+        self.exp_auth_token = get_exp_auth_token()
+        self.disabled_token = get_disabled_token()
+        self.missing_token = get_none_token()
+        self.invalid_token = get_non_existing_token()
+
+    def tearDown(self):
+
+        resp, content = delete_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+
+
+class create_user_test(user_test):
+
+    def test_a_user_create_json(self):
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val, content_type(resp))
+        self.assertEqual(201,resp_val)
+
+    def test_a_user_create_xml(self):
+        resp, content = delete_user_xml(self.tenant, self.user, 
+                                        str(self.auth_token))
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val, content_type(resp))
+        
+        self.assertEqual(201,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_create_json_disabled_tenant(self):
+        resp, content = create_user('0000', self.user, 
+                                    str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val, content_type(resp))
+        self.assertEqual(403,resp_val)
+
+    def test_a_user_create_json_disabled_tenant_xml(self):
+        resp, content = create_user_xml('0000', self.user, 
+                                        str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val, content_type(resp))
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_again_json(self):
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val, content_type(resp))
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        self.assertEqual(409, int(resp['status']))
+
+    def test_a_user_again_xml(self):
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.auth_token))
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.auth_token))
+        content = etree.fromstring(content)
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val, content_type(resp))
+        self.assertEqual(409, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_create_expired_token(self):
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.exp_auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content,resp_val, content_type(resp))
+        self.assertEqual(403, int(resp['status']))
+
+    def test_a_user_create_expired_token_xml(self):
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.exp_auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content,resp_val, content_type(resp))
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_create_disabled_token(self):
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.disabled_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, int(resp['status']))
+
+    def test_a_user_create_disabled_token_xml(self):
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.disabled_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_create_missing_token(self):
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.missing_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(401, int(resp['status']))
+
+    def test_a_user_create_missing_token_xml(self):
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.missing_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(401, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_create_invalid_token(self):
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.invalid_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,  content,resp_val, content_type(resp))
+        self.assertEqual(404, int(resp['status']))
+
+    def test_a_user_create_invalid_token_xml(self):
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.invalid_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,  content,resp_val, content_type(resp))
+        self.assertEqual(404, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+
+
+class get_user_test(user_test):
+
+    def test_a_user_get_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json", 
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(200, resp_val)
+
+    def test_a_user_get_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant, self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(200, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_get_expired_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403,resp_val)
+
+    def test_a_user_get_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_get_disabled_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token}
+                                  )
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+
+    def test_a_user_get_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_get_missing_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant,
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(401, resp_val)
+
+    def test_a_user_get_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(401,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_get_invalid_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(404,resp_val)
+
+    def test_a_user_get_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.invalid_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(404, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_get_disabled_user(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, 
+                                         self.userdisabled)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+
+    def test_a_user_get_disabled_user_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.userdisabled)
+        
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_get_disabled_tenant(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, '0000', self.userdisabled)
+        
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+
+    def test_a_user_get_disabled_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, '0000', self.userdisabled)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "GET", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+
+class delete_user_test(user_test):
+
+    def test_a_user_delete_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, resp_val)
+
+    def test_a_user_delete_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant, self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "DELETE", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(204, resp_val)
+
+    def test_a_user_delete_expired_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_a_user_delete_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_delete_missing_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+
+    def test_a_user_delete_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_delete_invalid_token(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+
+    def test_a_user_delete_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.user, self.tenant, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.invalid_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_a_user_delete_disabled_tenant(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, '0000', self.userdisabled)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_a_user_delete_disabled_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, '0000', self.userdisabled)
+        #test for Content-Type = application/json
+        resp, content = h.request(url, "DELETE", body='',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+class get_users_test(user_test):
+
+    def test_users_get_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, resp_val)
+
+    def test_users_get_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_get_expired_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token}
+                                  )
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_users_get_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_get_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token}
+                                  )
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_users_get_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_get_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+
+    def test_users_get_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_get_invalid_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL, self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+
+    def test_users_get_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL,self.tenant)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.invalid_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_get_disabled_tenant_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL,"0000")
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        
+        self.assertEqual(403,resp_val)
+
+    def test_users_get_disabled_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users' % (URL,"0000")
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+class get_users_group_test(user_test):
+
+    def test_users_group_get_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200,resp_val)
+
+    def test_users_group_get_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(200,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_group_get_expired_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+
+    def test_users_group_get_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_group_get_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token}
+                                  )
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+
+    def test_users_group_get_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_group_get_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401,resp_val)
+
+    def test_users_group_get_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_group_get_invalid_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404,resp_val)
+
+    def test_users_group_get_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, self.tenant, self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.invalid_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_users_group_get_disabled_tenant_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, "0000", self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        
+        self.assertEqual(403,resp_val)
+
+    def test_users_group_get_disabled_tenant_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/groups' % (URL, "0000", self.user)
+        resp, content = h.request(url, "GET", body='{}',
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+class update_user_test(user_test):
+
+    def test_user_update_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        
+        data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(200,resp_val)
+        self.assertEqual('updatedjoeuser@rackspace.com',content['user']['email'])
+
+    def test_user_update_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(200,resp_val)
+        self.assertEqual('updatedjoeuser@rackspace.com',content.get("email"))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_update_user_disabled_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL,self.tenant, self.userdisabled)
+        data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+
+    def test_user_update_user_disabled_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL,self.tenant, self.userdisabled)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_update_email_conflict_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '{"user": { "email": "joe@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/json", 
+                                         "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, resp_val)
+
+    def test_user_update_email_conflict_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="joe@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.auth_token,
+                                         "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(409, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_update_bad_request_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '{"user_bad": { "bad": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(400, resp_val)
+
+    def test_user_update_bad_request_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(400,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+
+    def test_user_update_expired_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data, 
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token
+                                           })
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_user_update_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.exp_auth_token,
+                                         "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_update_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token
+                                           })
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_user_update_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.disabled_token,
+                                         "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_update_invalid_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        
+        data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+
+    def test_user_update_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.invalid_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_update_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+
+    def test_user_update_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                email="updatedjoeuser@rackspace.com" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+
+class set_password_test(user_test):
+
+    def test_user_password_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant,self.user, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        data = '{"user": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(200,resp_val)
+        self.assertEqual('p@ssword',content['user']['password'])
+
+    def test_user_password_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user,
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(200,resp_val)
+        self.assertEqual('p@ssword', content.get("password"))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_password_user_disabled_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.userdisabled)
+        data = '{"user": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/json", "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+
+    def test_user_password_user_disabled_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.userdisabled)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_password_bad_request_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant, self.user, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '{"user_bad": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(400,resp_val)
+
+    def test_user_password_bad_request_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user, 
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(400,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+
+    def test_user_password_expired_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '{"user": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json", 
+                                           "X-Auth-Token": self.exp_auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_user_password_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.exp_auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_password_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '{"user": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_user_password_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.disabled_token,
+                                         "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_password_invalid_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '{"user": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404,resp_val)
+
+    def test_user_password_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.invalid_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404,resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_password_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '{"user": { "password": "p@ssword"}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+
+    def test_user_password_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                password="p@ssword" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+
+class set_enabled_test(user_test):
+
+    def test_user_enabled_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant,self.user, 
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = {"user": { "enabled": True}}
+        resp, content = h.request(url, "PUT", body=json.dumps(data),
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(200, resp_val)
+        self.assertEqual(True, content['user']['enabled'])
+
+    def test_user_enabled_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user, str(self.auth_token))
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                enabled="true" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(200, resp_val)
+        self.assertEqual('true',content.get("enabled"))
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_enabled_bad_request_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user(self.tenant,self.user,
+                                    str(self.auth_token))
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '{"user_bad": { "enabled": true}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(400, resp_val)
+
+    def test_user_enabled_bad_request_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_xml(self.tenant,self.user,
+                                        str(self.auth_token))
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                enabled="true" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.auth_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user(self.tenant,self.user, str(self.auth_token))
+        self.assertEqual(400, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+
+    def test_user_enabled_expired_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '{"user": { "enabled": true}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.exp_auth_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_user_enabled_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                enabled="true" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/xml",
+                                         "X-Auth-Token": self.exp_auth_token,
+                                         "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_enabled_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '{"user": { "enabled": true}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.disabled_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+
+    def test_user_enabled_disabled_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                enabled="true" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.disabled_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(403, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_enabled_invalid_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '{"user": { "enabled": true}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.invalid_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+
+    def test_user_enabled_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                enabled="true" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                headers={"Content-Type": "application/xml",\
+                                         "X-Auth-Token": self.invalid_token,
+                                         "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(404, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+    def test_user_enabled_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
+        data = '{"user": { "enabled": true}}'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/json",
+                                           "X-Auth-Token": self.missing_token})
+        resp_val = int(resp['status'])
+        content = json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+
+    def test_user_enabled_missing_token_xml(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        data = '<?xml version="1.0" encoding="UTF-8"?> \
+                <user xmlns="http://docs.openstack.org/idm/api/v1.0" \
+                enabled="true" />'
+        resp, content = h.request(url, "PUT", body=data,
+                                  headers={"Content-Type": "application/xml",
+                                           "X-Auth-Token": self.missing_token,
+                                           "ACCEPT": "application/xml"})
+        resp_val = int(resp['status'])
+        content = etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        self.assertEqual(401, resp_val)
+        self.assertEqual('application/xml', content_type(resp))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/test/unit/test_version.py b/test/unit/test_version.py
new file mode 100644
index 00000000..b5e536a5
--- /dev/null
+++ b/test/unit/test_version.py
@@ -0,0 +1,39 @@
+import os
+import sys
+# Need to access identity module
+sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
+                                '..', '..', '..', '..', 'keystone')))
+import unittest
+from webtest import TestApp
+import httplib2
+import json
+from lxml import etree
+import unittest
+from webtest import TestApp
+from test_common import *
+
+class version_test(unittest.TestCase):
+
+    #Given _a_ to make inherited test cases in an order.
+    #here to call below method will call as last test case
+
+    def test_a_get_version_json(self):
+        h = httplib2.Http(".cache")
+        url = URL
+        resp, content = h.request(url, "GET", body="",
+                                  headers={"Content-Type":"application/json"})
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/json', content_type(resp))
+
+    def test_a_get_version_xml(self):
+        h = httplib2.Http(".cache")
+        url = URL
+        resp, content = h.request(url, "GET", body="",
+                                  headers={"Content-Type": "application/xml",
+                                           "ACCEPT": "application/xml"})
+
+        self.assertEqual(200, int(resp['status']))
+        self.assertEqual('application/xml', content_type(resp))
+        
+if __name__ == '__main__':
+    unittest.main()