Added missing tests, mad e enable and disable password work

5 files changed, 2823 insertions, 1028 deletions

diff --git a/keystone/auth_server.py b/keystone/auth_server.py
index 6203dde4..b4904c77 100755
--- a/keystone/auth_server.py
+++ b/keystone/auth_server.py
@@ -160,11 +160,11 @@ def send_result(code, req, result):
             resp.headers['content-type'] = "application/xml"
         else:
             content = result.to_json()
+            print content
             resp.headers['content-type'] = "application/json"
 
         resp.content_type_params={'charset' : 'UTF-8'}
         resp.unicode_body = content.decode('UTF-8')
-
     return resp
 
 class StaticFilesController(wsgi.Controller):
@@ -412,9 +412,9 @@ class UserController(wsgi.Controller):
                              req.environ.get("SERVER_PORT"),
                              req.environ['PATH_INFO'])
 
-        groups = service.get_user_groups(get_auth_token(),
+        groups = service.get_user_groups(get_auth_token(req),
                                         tenant_id,user_id, marker, limit,url)
-        return send_result(200, groups)
+        return send_result(200,req, groups)
     
     @wrap_error
     def get_user(self, req, tenant_id, user_id):
@@ -436,14 +436,13 @@ class UserController(wsgi.Controller):
     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)
+        return send_result(200, req, rval)
 
-    # To be checked with Abdul not finished yet
     @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)
+        return send_result(200, req, rval)
 
 
 
@@ -573,6 +572,8 @@ class KeystoneAPI(wsgi.Router):
                 action="create_user", conditions=dict(method=["POST"]))
         mapper.connect("/v1.0/tenants/{tenant_id}/users", 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", conditions=dict(method=["GET"]))
         mapper.connect("/v1.0/tenants/{tenant_id}/users/{user_id}", controller=user_controller,
diff --git a/keystone/db/sqlalchemy/api.py b/keystone/db/sqlalchemy/api.py
index 049c1bac..eafd23a2 100644
--- a/keystone/db/sqlalchemy/api.py
+++ b/keystone/db/sqlalchemy/api.py
@@ -660,18 +660,35 @@ def user_get_by_tenant(id, tenant_id, session=None):
         session = get_session()
     user_tenant = session.query(models.UserTenantAssociation).filter_by(
     tenant_id=tenant_id, user_id=id).first()
-
     return user_tenant
 
-def user_delete_tenant(id, tenantId, session=None):
+def user_get_by_group(id, session=None):
+    if not session:
+        session = get_session()
+    user_group = session.query(models.Group).filter_by(tenant_id=id).all()
+    return user_group
+
+def user_delete_tenant(id, tenant_id, session=None):
     if not session:
         session = get_session()
     with session.begin():
-        user_ref = user_get_by_tenant(id, tenantId, session)
-        session.delete(user_ref)
-        user_ref = user_get(id, session)
-        session.delete(user_ref)
-        
+        user_tenant_ref = user_get_by_tenant(id, tenant_id, session)
+        print user_tenant_ref
+        session.delete(user_tenant_ref)
+        user_group_ref = user_get_by_group(tenant_id,session)
+        print user_group_ref
+        if user_group_ref is not None:
+            for user_group in user_group_ref:
+                group_users=session.query(models.UserGroupAssociation).filter_by( \
+                                         user_id=id, group_id = user_group.id).all()
+                for group_user in group_users:
+                    session.delete(group_user)
+        user_tenant_ref= session.query(models.UserTenantAssociation).filter_by( \
+                         user_id=id).first()
+        if user_tenant_ref is None:
+            user_ref = user_get(id, session)
+            session.delete(user_ref)
+            
 def user_tenant_group(values):
     user_ref = models.UserGroupAssociation()
     user_ref.update(values)
diff --git a/keystone/logic/service.py b/keystone/logic/service.py
index cc852af0..131803ea 100644
--- a/keystone/logic/service.py
+++ b/keystone/logic/service.py
@@ -458,9 +458,11 @@ class IDMService(object):
 
         if tenant_id == None:
             raise fault.BadRequestFault("Expecting a Tenant Id")
-
-        if db_api.tenant_get(tenant_id) == None:
+        dtenant = db_api.tenant_get(tenant_id)
+        if dtenant is  None:
             raise fault.ItemNotFoundFault("The tenant not found")
+        if not dtenant.enabled:
+            raise fault.TenantDisabledFault("Your account has been disabled")
         ts = []
         dtenantusers = db_api.users_get_by_tenant_get_page(tenant_id, marker,
                                                           limit)
@@ -520,6 +522,8 @@ 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")
 
@@ -530,10 +534,7 @@ class IDMService(object):
         if not isinstance(user, users.User):
             raise fault.BadRequestFault("Expecting a User")
         True
-        duser = db_api.user_get_update(user_id)
-        if duser == None:
-            raise fault.ItemNotFoundFault("The user could not be found")
-        if db_api.user_get_email(user.email) != None:
+        if db_api.user_get_email(user.email) is not None:
             raise fault.EmailConflictFault(
                 "Email already exists")
 
@@ -572,7 +573,7 @@ class IDMService(object):
 
         db_api.user_update(user_id, values)
 
-        return users.User(user.password, '', '', '', '')
+        return users.User_Update(user.password, None, None, None, None,None)
 
     def enable_disable_user(self, admin_token, user_id, user,tenant_id):
         self.__validate_token(admin_token)
@@ -585,12 +586,7 @@ class IDMService(object):
 
         duser = db_api.user_get(user_id)
         if not duser:
-            raise fault.ItemNotFoundFault("The user could not be found")
-
-        if not duser.enabled:
-            raise fault.UserDisabledFault("User has been disabled")
-
-
+            raise fault.ItemNotFoundFault("The user could not be found" )
         if not isinstance(user, users.User):
             raise fault.BadRequestFault("Expecting a User")
         True
@@ -602,7 +598,7 @@ class IDMService(object):
 
         db_api.user_update(user_id, values)
 
-        return users.User('','','','',user.enabled)
+        return users.User_Update(None,None,None,None,user.enabled,None)
 
     def delete_user(self, admin_token, user_id, tenant_id):
         self.__validate_token(admin_token)
@@ -631,6 +627,9 @@ class IDMService(object):
 
         if db_api.tenant_get(tenant_id) == None:
             raise fault.ItemNotFoundFault("The tenant not found")
+        
+        if not db_api.tenant_get(tenant_id).enabled:
+            raise fault.TenantDisabledFault("Your account has been disabled")
 
         ts = []
         dusergroups = db_api.groups_get_by_user_get_page(user_id, marker,
diff --git a/keystone/logic/types/user.py b/keystone/logic/types/user.py
index a2496806..f3a56a5d 100644
--- a/keystone/logic/types/user.py
+++ b/keystone/logic/types/user.py
@@ -140,8 +140,7 @@ class User_Update(object):
         self.password = password
         self.email = email
         self.enabled = enabled and True or False
-        if group is not None:
-            self.group=group
+        self.group=group
     @staticmethod
     def from_xml(xml_str):
         try:
@@ -212,11 +211,11 @@ class User_Update(object):
             dom.set("tenantId",self.tenant_id)
         if self.user_id:
             dom.set("id",self.user_id)
-        if self.enabled:
+        if self.enabled is not None:
             dom.set("enabled",string.lower(str(self.enabled)))
         if self.password:
             dom.set("password",self.password)
-        if self.group:
+        if self.group is not None:
             print '78'
             for group in self.group:
                 dom.append(group.to_dom())
@@ -236,9 +235,9 @@ class User_Update(object):
             user["password"]=self.password
         if self.email:
             user["email"]=self.email
-        if self.enabled:
+        if self.enabled is not None:
             user["enabled"]=self.enabled
-        if self.group:
+        if self.group is not None:
             values=[t.to_dict()["group"] for t in self.group]
             user["groups"] = {"values": values}
         return {'user': user}
diff --git a/test/unit/test_identity.py b/test/unit/test_identity.py
index e6079366..f7a77f35 100644
--- a/test/unit/test_identity.py
+++ b/test/unit/test_identity.py
@@ -3,7 +3,7 @@ import sys
 # Need to access identity module
 sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
                                 '..', '..', '..', '..', 'keystone')))
-from keystone import auth_server
+#from keystone import auth_server
 import unittest
 from webtest import TestApp
 import httplib2
@@ -23,6 +23,7 @@ def get_token(user, pswd, kind=''):
         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
@@ -200,6 +201,54 @@ def create_global_group_xml(auth_token):
                               "ACCEPT": "application/xml"})
     return (resp, content)
 
+def create_user_json(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_json(tenant, userid, auth_token):
+    h = httplib2.Http(".cache")
+    url = '%stenants/%s/users/%s' % (URL, tenant, userid)
+    print url
+    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 delete_global_group_xml(groupid, auth_token):
     h = httplib2.Http(".cache")
@@ -210,6 +259,16 @@ def delete_global_group_xml(groupid, auth_token):
                                      "ACCEPT": "application/xml"})
     return (resp, content)
 
+def get_userid():
+    return 'test_user11'
+
+
+def get_password():
+    return 'secrete'
+
+
+def get_email():
+    return 'joetest@rackspace.com'
 
 def get_tenant():
     return '1234'
@@ -220,8 +279,7 @@ def get_user():
 
 
 def get_userdisabled():
-    return '1234'
-
+    return 'disabled'
 
 def get_auth_token():
     return '999888777666'
@@ -230,12 +288,34 @@ def get_auth_token():
 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 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]
+    return resp['content-type'].split(';')[0]
 
 class identity_test(unittest.TestCase):
 
@@ -1078,1039 +1158,2738 @@ class delete_tenant_test(tenant_test):
 
 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'
-
-	def tearDown(self):
-		resp, content = delete_tenant_group('test_tenant_group', \
+    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'
+
+    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)
+        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('test_tenant', str(self.auth_token))
-		resp, content = create_tenant('test_tenant', str(self.auth_token))
+    def test_tenant_group_create(self):
+        resp, content = delete_tenant('test_tenant', str(self.auth_token))
+        resp, content = create_tenant('test_tenant', str(self.auth_token))
 
-		respG, contentG = delete_tenant_group('test_tenant_group', \
-				     'test_tenant', str(self.auth_token))
-		respG, contentG = create_tenant_group('test_tenant_group', \
+        respG, contentG = delete_tenant_group('test_tenant_group', \
+                     'test_tenant', str(self.auth_token))
+        respG, contentG = create_tenant_group('test_tenant_group', \
                                     'test_tenant', str(self.auth_token))
 
-		self.tenant = 'test_tenant'
-		self.tenant_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']) 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('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))
-
-	    self.tenant = 'test_tenant'
-	    self.tenant_group = 'test_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("test_tenant", str(self.auth_token))
-
-	    respG, contentG = create_tenant_group('test_tenant_group', \
-					    "test_tenant", str(self.auth_token))
-	    respG, contentG = create_tenant_group('test_tenant_group', \
-					    "test_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))
-
-	    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_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 ..."
-			       }}
-	    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(403, int(resp['status']))
-
-	def test_tenant_group_create_forbidden_token_xml(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 = '<?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(403, int(resp['status']))
-
-	def test_tenant_group_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 ..."
-			       }}
-	    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(401, 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))
-	    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(401, int(resp['status']))
-
-	def test_tenant_group_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 ..."}}
-	    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))
-	    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("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})
-
-	    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))
-	    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("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'})
-
-	    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_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 = '%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(401, int(resp['status']))
+        self.tenant = 'test_tenant'
+        self.tenant_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']) 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('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))
+
+        self.tenant = 'test_tenant'
+        self.tenant_group = 'test_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("test_tenant", str(self.auth_token))
+
+        respG, contentG = create_tenant_group('test_tenant_group', \
+                        "test_tenant", str(self.auth_token))
+        respG, contentG = create_tenant_group('test_tenant_group', \
+                        "test_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))
+
+        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_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 ..."
+                   }}
+        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(403, int(resp['status']))
+
+    def test_tenant_group_create_forbidden_token_xml(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 = '<?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(403, int(resp['status']))
+
+    def test_tenant_group_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 ..."
+                   }}
+        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(401, 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))
+        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(401, int(resp['status']))
+
+    def test_tenant_group_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 ..."}}
+        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))
+        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("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})
+
+        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))
+        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("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'})
+
+        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_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 = '%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(401, 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_forbidden_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(403, int(resp['status']))
-
-	def test_get_tenant_groups_forbidden_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(403, 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(401, 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(401, int(resp['status']))
+    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_forbidden_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(403, int(resp['status']))
+
+    def test_get_tenant_groups_forbidden_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(403, 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(401, 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(401, 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_xml(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/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']))
+    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_xml(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/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))
-	    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 = create_tenant_xml(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>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))
-	    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))
-	    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))
-	    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']))
+    def test_update_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)
+
+        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 = create_tenant_xml(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>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))
+        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))
+        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))
+        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", \
-					    "test_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", \
-						"test_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_xml("test_tenant_delete", \
-					      str(self.auth_token))
-	    respG, contentG = create_tenant_group_xml('test_tenant_group_delete', \
-					    "test_tenant_delete", str(self.auth_token))
-	    respG, contentG = delete_tenant_group_xml('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']))
+    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", \
+                        "test_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", \
+                        "test_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_xml("test_tenant_delete", \
+                          str(self.auth_token))
+        respG, contentG = create_tenant_group_xml('test_tenant_group_delete', \
+                        "test_tenant_delete", str(self.auth_token))
+        respG, contentG = delete_tenant_group_xml('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 user_test(unittest.TestCase):
+
+    def setUp(self):
+        self.token = get_token('joeuser', 'secrete', 'token')
+        self.tenant = get_tenant()
+        self.userid = get_userid()
+        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_json(self.tenant,\
+                self.userid, str(self.auth_token))
+       
+        #resp, content = delete_user_xml(self.tenant,\
+                #self.userid, str(self.auth_token))
+
+class create_user_test(user_test):
+
+    def test_a_user_create_json(self):
+        resp, content = create_user_json('1234', 'test_user11',\
+                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('1234', 'test_user11', \
+                str(self.auth_token))
+        resp, content = create_user_xml('1234', 'test_user11', \
+                str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val,content_type(resp))
+        print 'here'
+        print resp
+        print content
+        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_json('0000', 'test_user11',\
+                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', 'test_user11',\
+                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_json("1234", "test_user11", \
+                str(self.auth_token))
+        resp_val = int(resp['status'])
+        handle_user_resp(self,content, resp_val,content_type(resp))
+        resp, content = create_user_json("1234", "test_user11", \
+                str(self.auth_token))
+        self.assertEqual(409, int(resp['status']))
+
+    def test_a_user_again_xml(self):
+        resp, content = create_user_xml("1234", "test_user11", \
+                str(self.auth_token))
+        resp, content = create_user_xml("1234", "test_user11", \
+                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_json('1234', 'test_user11', \
+                str(self.exp_auth_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_expired_token_xml(self):
+        resp, content = create_user_xml('1234', 'test_user11', \
+                str(self.exp_auth_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_disabled_token(self):
+        resp, content = create_user_json('1234', 'test_user11', \
+                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('1234', 'test_user11', \
+                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_json('1234', 'test_user11', \
+                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('1234', 'test_user11', \
+                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_json('1234', 'test_user11', \
+                str(self.invalid_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_invalid_token_xml(self):
+        resp, content = create_user_xml('1234', 'test_user11', \
+                str(self.invalid_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))
+
+
+class get_user_test(user_test):
+
+    def test_a_user_get_json(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_json(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.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_xml(self.user,self.tenant,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_json(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(401,resp_val)
+    
+    def test_a_user_get_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_json(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(401,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_json(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_json(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_json(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_json(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_json(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(401,resp_val)
+    
+    def test_a_user_get_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_json(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(401,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'])
+        print resp,content
+        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)
+        #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))
+    
+    def test_a_user_get_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, "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_json(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.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.user,self.tenant,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_json(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(401,resp_val)
+    
+    def test_a_user_delete_expired_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_json(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(401,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_json(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_json(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_json(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(401,resp_val)
+    
+    def test_a_user_delete_invalid_token_xml(self):
+        h = httplib2.Http(".cache")
+        resp, content = create_user_json(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(401,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'])
+        print resp,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_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'])
+        print resp,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))
+
+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(401,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(401,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(401,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(401,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')
+        print resp,content
+        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_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_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_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(401,resp_val)
+    
+    def test_users_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(401,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/%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_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_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_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_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(401,resp_val)
+    
+    def test_users_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(401,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/%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')
+        print resp,content
+        self.assertEqual(403,resp_val)
+    
+    def test_users_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_json(self.tenant,self.user , \
+                str(self.auth_token))
+        print resp,content
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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))
+        print resp,content
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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_json(self.tenant,self.user , \
+                str(self.auth_token))
+        print resp,content
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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))
+        print resp,content
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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)
+        print url
+        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'])
+        print resp,content
+        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_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'])
+        print resp,content
+        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))
+    
+    def test_user_update_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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)
+        print url
+        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'])
+        print resp,content
+        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_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'])
+        print resp,content
+        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))
+    
+    def test_user_update_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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_json(self.tenant,self.user , \
+                str(self.auth_token))
+        print resp,content
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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))
+        print resp,content
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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_json(self.tenant,self.user , \
+                str(self.auth_token))
+        print resp,content
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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))
+        print resp,content
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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)
+        print url
+        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'])
+        print resp,content
+        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_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'])
+        print resp,content
+        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))
+    
+    def test_user_password_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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)
+        print url
+        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'])
+        print resp,content
+        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_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'])
+        print resp,content
+        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))
+    
+    def test_user_password_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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_json(self.tenant,self.user , \
+                str(self.auth_token))
+        print resp,content
+        url = '%stenants/%s/users/%s/enabled' % (URL,self.tenant,self.user)
+        print url
+        data = '{"user": { "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'])
+        print resp,content
+        content=json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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))
+        print resp,content
+        url = '%stenants/%s/users/%s/enabled' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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_json(self.tenant,self.user , \
+                str(self.auth_token))
+        print resp,content
+        url = '%stenants/%s/users/%s/enabled' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=json.loads(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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))
+        print resp,content
+        url = '%stenants/%s/users/%s/enabled' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        content=etree.fromstring(content)
+        if resp_val == 500:
+            self.fail('IDM fault')
+        elif resp_val == 503:
+            self.fail('Service Not Available')
+        delete_user_json(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)
+        print url
+        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'])
+        print resp,content
+        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_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'])
+        print resp,content
+        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))
+    
+    def test_user_enabled_disabled_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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)
+        print url
+        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'])
+        print resp,content
+        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_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'])
+        print resp,content
+        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))
+    
+    def test_user_enabled_missing_token_json(self):
+        h = httplib2.Http(".cache")
+        url = '%stenants/%s/users/%s/enabled' % (URL,self.tenant,self.user)
+        print url
+        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'])
+        print resp,content
+        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'])
+        print resp,content
+        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 get_user_test(user_test):
 
 class global_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'
-
-	def tearDown(self):
-		resp, content = delete_tenant_group('test_tenant_group', \
+    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'
+
+    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)
+        resp, content = delete_tenant(self.tenant, self.auth_token)
 
 
 
 class create_global_group_test(global_group_test):
 
-	def test_global_group_create(self):
+    def test_global_group_create(self):
 
-	    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'
+        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(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']))
+        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):
+    def test_global_group_create_again(self):
 
-	    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))
+        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))
 
-	    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']
+        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']
 
 class create_tenant_group_test(tenant_group_test):
 
-	def test_tenant_group_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 ..."
-			       }}
-	    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(403, int(resp['status']))
-
-
-	def test_tenant_group_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 ..."
-			       }}
-	    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(401, int(resp['status']))
-
-	def test_tenant_group_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 ..."}}
-	    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_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})
-
-	    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("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'})
-
-	    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_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
-	    self.tenant = 'test_tenant'
-	    self.tenant_group = 'test_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):
-
-	    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))
-
-	    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_forbidden_token_xml(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 = '<?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(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))
-	    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(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))
-	    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_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 = '%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_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 = '%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(401, int(resp['status']))
+    def test_tenant_group_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 ..."
+                   }}
+        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(403, int(resp['status']))
+
+
+    def test_tenant_group_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 ..."
+                   }}
+        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(401, int(resp['status']))
+
+    def test_tenant_group_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 ..."}}
+        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_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})
+
+        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("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'})
+
+        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_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
+        self.tenant = 'test_tenant'
+        self.tenant_group = 'test_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):
+
+        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))
+
+        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_forbidden_token_xml(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 = '<?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(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))
+        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(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))
+        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_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 = '%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_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 = '%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(401, int(resp['status']))
 
 if __name__ == '__main__':
     unittest.main()