fixed pylint

7 files changed, 293 insertions, 252 deletions

diff --git a/test/unit/test_authentication.py b/test/unit/test_authentication.py
index 6254f282..6f7af0f7 100644
--- a/test/unit/test_authentication.py
+++ b/test/unit/test_authentication.py
@@ -12,7 +12,7 @@ from lxml import etree
 import test_common  as utils
 
 
-class authentication_test(unittest.TestCase):
+class AuthenticationTest(unittest.TestCase):
 
     def setUp(self):
         self.tenant = utils.get_tenant()
diff --git a/test/unit/test_groups.py b/test/unit/test_groups.py
index ce8676f5..43173f36 100644
--- a/test/unit/test_groups.py
+++ b/test/unit/test_groups.py
@@ -16,7 +16,7 @@ import test_common as utils
 ##
 
 
-class global_group_test(unittest.TestCase):
+class GlobalGroupTest(unittest.TestCase):
 
     def setUp(self):
         self.globaltenant = utils.get_global_tenant()
@@ -35,66 +35,71 @@ class global_group_test(unittest.TestCase):
         resp, content = utils.delete_tenant(self.globaltenant, self.auth_token)
 
 
-class create_global_group_test(global_group_test):
+class CreateGlobalGroupTest(GlobalGroupTest):
 
     def test_global_group_create(self):
-        respG, contentG = utils.delete_global_group(self.global_group,
+        resp_new, content_new = utils.delete_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_global_group(self.global_group,
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
 
-        if int(respG['status']) == 500:
+        if int(resp_new['status']) == 500:
             self.fail('IDM fault')
-        elif int(respG['status']) == 503:
+        elif int(resp_new['status']) == 503:
             self.fail('Service Not Available')
-        if int(respG['status']) not in (200, 201):
-            self.fail('Failed due to %d' % int(respG['status']))
+        if int(resp_new['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(resp_new['status']))
 
     def test_global_group_create_xml(self):
-        respG, contentG = utils.delete_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
-        respG, contentG = utils.create_global_group_xml(self.global_group,
+        resp_new, content_new = utils.delete_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                  self.global_group,
                                                   str(self.auth_token))
 
-        if int(respG['status']) == 500:
+        if int(resp_new['status']) == 500:
             self.fail('IDM fault')
-        elif int(respG['status']) == 503:
+        elif int(resp_new['status']) == 503:
             self.fail('Service Not Available')
 
-        if int(respG['status']) not in (200, 201):
-            self.fail('Failed due to %d' % int(respG['status']))
+        if int(resp_new['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(resp_new['status']))
 
     def test_global_group_create_again(self):
-        respG, contentG = utils.create_global_group(self.global_group,
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_global_group(self.global_group,
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        if int(respG['status']) == 500:
+        if int(resp_new['status']) == 500:
             self.fail('IDM fault')
-        elif int(respG['status']) == 503:
+        elif int(resp_new['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(409, int(respG['status']))
+        self.assertEqual(409, int(resp_new['status']))
 
     def test_global_group_create_again_xml(self):
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
-        contentG = etree.fromstring(contentG)
-        if int(respG['status']) == 500:
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                self.global_group,
+                                                str(self.auth_token))
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                self.global_group,
+                                                str(self.auth_token))
+        content_new = etree.fromstring(content_new)
+        if int(resp_new['status']) == 500:
             self.fail('IDM fault')
-        elif int(respG['status']) == 503:
+        elif int(resp_new['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(409, int(respG['status']))
+        self.assertEqual(409, int(resp_new['status']))
 
     def test_global_group_create_unauthorized_token(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
         url = '%sgroups' % (utils.URL)
         body = {"group": {"id": self.global_group,
                           "description": "A description ..."}}
-        resp, content = h.request(url, "POST", body=json.dumps(body),
+        resp, content = header.request(url, "POST", body=json.dumps(body),
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.token})
         if int(resp['status']) == 500:
@@ -104,14 +109,14 @@ class create_global_group_test(global_group_test):
         self.assertEqual(401, int(resp['status']))
 
     def test_global_group_create_unauthorized_token_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
                 id="%s"> \
                 <description>A description...</description> \
                 </group>' % self.global_group
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.token,
                                            "ACCEPT": "application/xml"})
@@ -122,11 +127,11 @@ class create_global_group_test(global_group_test):
         self.assertEqual(401, int(resp['status']))
 
     def test_global_group_create_expired_token(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = {"group": {"id": self.global_group,
                           "description": "A description ..."}}
-        resp, content = h.request(url, "POST", body=json.dumps(body),
+        resp, content = header.request(url, "POST", body=json.dumps(body),
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": \
                                                    self.exp_auth_token})
@@ -137,13 +142,13 @@ class create_global_group_test(global_group_test):
         self.assertEqual(403, int(resp['status']))
 
     def test_global_group_create_expired_token_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
                 id="%s"><description>A description...</description> \
                 </group>' % self.globaltenant
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.exp_auth_token,
                                            "ACCEPT": "application/xml"})
@@ -154,11 +159,11 @@ class create_global_group_test(global_group_test):
         self.assertEqual(403, int(resp['status']))
 
     def test_global_group_create_missing_token(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = {"group": {"id": self.global_group,
                           "description": "A description ..."}}
-        resp, content = h.request(url, "POST", body=json.dumps(body),
+        resp, content = header.request(url, "POST", body=json.dumps(body),
                                   headers={"Content-Type": "application/json"})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -167,13 +172,13 @@ class create_global_group_test(global_group_test):
         self.assertEqual(401, int(resp['status']))
 
     def test_global_group_create_missing_token_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
                 id="%s"><description>A description...</description> \
                 </group>' % self.global_group
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/xml",
                                            "ACCEPT": "application/xml"})
         if int(resp['status']) == 500:
@@ -183,11 +188,11 @@ class create_global_group_test(global_group_test):
         self.assertEqual(401, int(resp['status']))
 
     def test_global_group_create_disabled_token(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '{"group": { "id": "%s", \
                 "description": "A description ..." } }' % self.global_group
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": \
                                                    self.disabled_token})
@@ -198,13 +203,13 @@ class create_global_group_test(global_group_test):
         self.assertEqual(403, int(resp['status']))
 
     def test_global_group_create_disabled_token_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
                 id="%s"><description>A description...</description> \
                 </group>' % self.global_group
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.disabled_token,
                                            "ACCEPT": "application/xml"})
@@ -215,11 +220,11 @@ class create_global_group_test(global_group_test):
         self.assertEqual(403, int(resp['status']))
 
     def test_global_group_create_invalid_token(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '{"group": { "id": "%s", \
                 "description": "A description ..." } }' % self.globaltenant
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": 'nonexsitingtoken'})
         if int(resp['status']) == 500:
@@ -229,13 +234,13 @@ class create_global_group_test(global_group_test):
         self.assertEqual(404, int(resp['status']))
 
     def test_global_group_create_invalid_token_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         url = '%sgroups' % (utils.URL)
         body = '<?xml version="1.0" encoding="UTF-8"?> \
                 <group xmlns="http://docs.openstack.org/idm/api/v1.0" \
                 id="%s"><description>A description...</description> \
                 </group>' % self.global_group
-        resp, content = h.request(url, "POST", body=body,
+        resp, content = header.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": 'nonexsitingtoken',
                                            "ACCEPT": "application/xml"})
@@ -246,17 +251,17 @@ class create_global_group_test(global_group_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class get_global_groups_test(global_group_test):
+class GetGlobalGroupsTest(GlobalGroupTest):
 
     def test_get_global_groups(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.delete_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.delete_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_global_group(self.global_group,
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
 
         url = '%sgroups' % (utils.URL)
-        resp, content = h.request(url, "GET", body='{}',
+        resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         if int(resp['status']) == 500:
@@ -266,11 +271,12 @@ class get_global_groups_test(global_group_test):
         self.assertEqual(200, int(resp['status']))
 
     def test_get_global_groups_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
         url = '%sgroups' % (utils.URL)
-        resp, content = h.request(url, "GET", body='',
+        resp, content = header.request(url, "GET", body='',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
@@ -281,12 +287,12 @@ class get_global_groups_test(global_group_test):
         self.assertEqual(200, int(resp['status']))
 
     def test_get_global_groups_unauthorized_token(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups' % (utils.URL)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='{}',
+        resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.token})
         if int(resp['status']) == 500:
@@ -296,12 +302,13 @@ class get_global_groups_test(global_group_test):
         self.assertEqual(401, int(resp['status']))
 
     def test_get_global_groups_unauthorized_token_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
         url = '%sgroups' % (utils.URL)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='',
+        resp, content = header.request(url, "GET", body='',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.token,
                                            "ACCEPT": "application/xml"})
@@ -313,11 +320,11 @@ class get_global_groups_test(global_group_test):
 
     def test_get_global_groups_exp_token(self):
         h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups' % (utils.URL)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='{}',
+        resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": \
                                                    self.exp_auth_token})
@@ -328,12 +335,13 @@ class get_global_groups_test(global_group_test):
         self.assertEqual(403, int(resp['status']))
 
     def test_get_global_groups_exp_token_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
         url = '%sgroups' % (utils.URL)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='',
+        resp, content = header.request(url, "GET", body='',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.exp_auth_token,
                                            "ACCEPT": "application/xml"})
@@ -344,15 +352,15 @@ class get_global_groups_test(global_group_test):
         self.assertEqual(403, int(resp['status']))
 
 
-class get_global_group_test(global_group_test):
+class GetGlobalGroupGest(GlobalGroupTest):
 
     def test_get_global_group(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, self.global_group)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='{}',
+        resp, content = header.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         if int(resp['status']) == 500:
@@ -362,12 +370,13 @@ class get_global_group_test(global_group_test):
         self.assertEqual(200, int(resp['status']))
 
     def test_get_global_group_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, self.global_group)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='',
+        resp, content = header.request(url, "GET", body='',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
@@ -378,12 +387,12 @@ class get_global_group_test(global_group_test):
         self.assertEqual(200, int(resp['status']))
 
     def test_get_global_group_bad(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, 'global_group_bad')
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='',
+        resp, content = header.request(url, "GET", body='',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         if int(resp['status']) == 500:
@@ -393,12 +402,13 @@ class get_global_group_test(global_group_test):
         self.assertEqual(404, int(resp['status']))
 
     def test_get_global_group_bad_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
-                                                  str(self.auth_token))
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                    self.global_group,
+                                                    str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, 'global_group_bad')
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body='',
+        resp, content = header.request(url, "GET", body='',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
@@ -409,14 +419,14 @@ class get_global_group_test(global_group_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class update_global_groups_test(global_group_test):
+class UpdateGlobalGroupsTest(GlobalGroupTest):
 
     def test_update_global_group(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, self.global_group)
-        resp, content = h.request(url, "PUT", body='{"group":{\
+        resp, content = header.request(url, "PUT", body='{"group":{\
                 "id" : "%s","description" :\
                 "A New description of the group..."}}' % self.global_group,
                 headers={"Content-Type": "application/json",
@@ -432,8 +442,8 @@ class update_global_groups_test(global_group_test):
                          str(body['group']['description']))
 
     def test_update_global_group_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                                   str(self.auth_token))
 
         url = '%sgroups/%s' % (utils.URL, self.global_group)
@@ -442,7 +452,7 @@ class update_global_groups_test(global_group_test):
                 id="%s"><description>A NEW description...</description> \
                 </group>' % (self.global_group)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "PUT", body=data,
+        resp, content = header.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
@@ -458,15 +468,15 @@ class update_global_groups_test(global_group_test):
         self.assertEqual('A NEW description...', desc.text)
 
     def test_update_global_group_bad(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, self.global_group)
         data = '{"group": { "description_bad": "A NEW description...", \
                 "id":"%s"  }}'\
                 % (self.global_group)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "PUT", body=data,
+        resp, content = header.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         if int(resp['status']) == 500:
@@ -476,8 +486,9 @@ class update_global_groups_test(global_group_test):
         self.assertEqual(400, int(resp['status']))
 
     def test_update_global_group_bad_xml(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group_xml(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group_xml(\
+                                                self.global_group,
                                                   str(self.auth_token))
         url = '%sgroups/%s' % (utils.URL, self.global_group)
         data = '<?xml version="1.0" encoding="UTF-8"?> \
@@ -485,7 +496,7 @@ class update_global_groups_test(global_group_test):
                 id="%s"><description_bad>A NEW description...</description> \
                 </group>' % (self.global_group)
         #test for Content-Type = application/json
-        resp, content = h.request(url, "PUT", body=data,
+        resp, content = header.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
@@ -497,20 +508,20 @@ class update_global_groups_test(global_group_test):
         self.assertEqual(400, int(resp['status']))
 
     def test_update_global_group_not_found(self):
-        h = httplib2.Http(".cache")
-        respG, contentG = utils.create_global_group(self.global_group,
+        header = httplib2.Http(".cache")
+        resp_new, content_new = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
         url = '%sgroups/NonexistingID' % (utils.URL)
         data = '{"group": { "description": "A NEW description...", \
                 "id":"NonexistingID"}}'
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body=data,
+        resp, content = header.request(url, "GET", body=data,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         self.assertEqual(404, int(resp['status']))
 
     def test_update_global_group_not_found_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_tenant_xml(self.globaltenant,
                                           str(self.auth_token))
         url = '%sgroups/NonexistingID' % (utils.URL)
@@ -520,7 +531,7 @@ class update_global_groups_test(global_group_test):
                 <description_bad>A NEW description...</description> \
                 </group>'
         #test for Content-Type = application/json
-        resp, content = h.request(url, "GET", body=data,
+        resp, content = header.request(url, "GET", body=data,
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
@@ -531,7 +542,7 @@ class update_global_groups_test(global_group_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class delete_global_group_test(global_group_test):
+class DeleteGlobalGroupTest(GlobalGroupTest):
 
     def test_delete_global_group_not_found(self):
         resp, content = utils.delete_global_group("test_global_group_1",
@@ -546,23 +557,25 @@ class delete_global_group_test(global_group_test):
     def test_delete_global_group(self):
         resp, content = utils.create_tenant(self.globaltenant,
                                             str(self.auth_token))
-        respG, contentG = utils.create_tenant_group('test_global_group_delete',
-                                              self.globaltenant,
-                                              str(self.auth_token))
-        respG, contentG = utils.delete_global_group('test_global_group_delete',
+        resp_new, content_new = utils.create_tenant_group(\
+                                                'test_global_group_delete',
+                                                self.globaltenant,
                                               str(self.auth_token))
+        resp_new, content_new = utils.delete_global_group(\
+                                                'test_global_group_delete',
+                                                str(self.auth_token))
         resp, content = utils.delete_tenant(self.globaltenant,
                                       str(self.auth_token))
-        self.assertEqual(204, int(respG['status']))
+        self.assertEqual(204, int(resp_new['status']))
 
     def test_delete_global_group_xml(self):
         resp, content = utils.create_tenant_xml(self.globaltenant,
                                                 str(self.auth_token))
-        respG, contentG = utils.create_tenant_group_xml(\
+        resp_new, content_new = utils.create_tenant_group_xml(\
                                                   'test_global_group_delete',
                                                   self.globaltenant,
                                                   str(self.auth_token))
-        respG, contentG = utils.delete_global_group_xml(\
+        resp_new, content_new = utils.delete_global_group_xml(\
                                                   'test_global_group_delete',
                                                   str(self.auth_token))
         resp, content = utils.delete_tenant_xml(self.globaltenant,
@@ -570,7 +583,7 @@ class delete_global_group_test(global_group_test):
         self.assertEqual(204, int(resp['status']))
 
 
-class add_user_global_group_test(unittest.TestCase):
+class AddUserGlobalGroupTest(unittest.TestCase):
 
     def setUp(self):
         self.tenant = utils.get_global_tenant()
@@ -584,9 +597,10 @@ class add_user_global_group_test(unittest.TestCase):
         self.global_group = 'test_global_group'
 
     def tearDown(self):
-        respG, contentG = utils.delete_user_global_group(self.global_group,
-                                                   self.user,
-                                                   str(self.auth_token))
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
+                                                    self.user,
+                                                    str(self.auth_token))
 
         resp = utils.delete_user(self.tenant, self.user,
                                       str(self.auth_token))
@@ -594,12 +608,12 @@ class add_user_global_group_test(unittest.TestCase):
                                             self.auth_token)
 
     def test_add_user_global_group(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
 
@@ -607,16 +621,17 @@ class add_user_global_group_test(unittest.TestCase):
             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']))
+        if int(resp_new['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(resp_new['status']))
 
     def test_add_user_global_group_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.add_user_global_group_xml(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
 
@@ -624,19 +639,19 @@ class add_user_global_group_test(unittest.TestCase):
             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']))
+        if int(resp_new['status']) not in (200, 201):
+            self.fail('Failed due to %d' % int(resp_new['status']))
 
     def test_add_user_global_group_conflict(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
 
@@ -644,18 +659,20 @@ class add_user_global_group_test(unittest.TestCase):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(409, int(respG['status']))
+        self.assertEqual(409, int(resp_new['status']))
 
     def test_add_user_global_group_conflict_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.add_user_global_group_xml(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.add_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.add_user_global_group_xml(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
 
@@ -663,15 +680,15 @@ class add_user_global_group_test(unittest.TestCase):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(409, int(respG['status']))
+        self.assertEqual(409, int(resp_new['status']))
 
     def test_add_user_global_group_unauthorized(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.token))
 
@@ -679,15 +696,16 @@ class add_user_global_group_test(unittest.TestCase):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401, int(respG['status']))
+        self.assertEqual(401, int(resp_new['status']))
 
     def test_add_user_global_group_unauthorized_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.add_user_global_group_xml(\
+                                                    self.global_group,
                                                     self.user,
                                                     str(self.token))
 
@@ -695,15 +713,16 @@ class add_user_global_group_test(unittest.TestCase):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401, int(respG['status']))
+        self.assertEqual(401, int(resp_new['status']))
 
     def test_add_user_global_group_forbidden(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.disabled_token))
 
@@ -711,28 +730,28 @@ class add_user_global_group_test(unittest.TestCase):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(respG['status']))
+        self.assertEqual(403, int(resp_new['status']))
 
     def test_add_user_global_group_forbidden_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.add_user_global_group_xml(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.disabled_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(respG['status']))
+        self.assertEqual(403, int(resp_new['status']))
 
 
-class get_users_tenant_group_test(unittest.TestCase):
+class GetUsersTenantGroupTest(unittest.TestCase):
 
     def setUp(self):
-        
         self.tenant = utils.get_global_tenant()
         self.token = utils.get_token('joeuser', 'secrete', self.tenant,
                                      'token')
@@ -744,158 +763,174 @@ class get_users_tenant_group_test(unittest.TestCase):
         self.global_group = 'test_global_group'
 
     def tearDown(self):
-        respG, contentG = utils.delete_user_global_group(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
-        respG = utils.delete_user(self.tenant, self.user,
+        resp_new = utils.delete_user(self.tenant, self.user,
                                       str(self.auth_token))
         resp, content = utils.delete_global_group(self.global_group,
                                             self.auth_token)
 
     def test_get_users_global_group(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group(self.global_group,
+        resp_new, content_new = utils.get_user_global_group(\
+                                                self.global_group,
                                                 str(self.auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(200, int(respG['status']))
+        self.assertEqual(200, int(resp_new['status']))
 
     def test_get_users_global_group_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.add_user_global_group_xml(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.get_user_global_group_xml(\
+                                                self.global_group,
                                                 str(self.auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(200, int(respG['status']))
+        self.assertEqual(200, int(resp_new['status']))
 
     def test_get_users_global_group_unauthorized(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
 
-        respG, contentG = utils.get_user_global_group(self.global_group,
+        resp_new, content_new = utils.get_user_global_group(\
+                                                self.global_group,
                                                 str(self.token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401, int(respG['status']))
+        self.assertEqual(401, int(resp_new['status']))
 
     def test_get_users_global_group_unauthorized_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.get_user_global_group_xml(\
+                                                self.global_group,
                                                 str(self.token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401, int(respG['status']))
+        self.assertEqual(401, int(resp_new['status']))
 
     def test_get_users_global_group_forbidden(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group(self.global_group,
+        resp_new, content_new = utils.get_user_global_group(\
+                                                self.global_group,
                                                 str(self.disabled_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(respG['status']))
+        self.assertEqual(403, int(resp_new['status']))
 
     def test_get_users_global_group_forbidden_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.get_user_global_group_xml(\
+                                                self.global_group,
                                                 str(self.disabled_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(respG['status']))
+        self.assertEqual(403, int(resp_new['status']))
 
     def test_get_users_global_group_expired(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(\
+                                                self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group(self.global_group,
+        resp_new, content_new = utils.get_user_global_group(\
+                                                self.global_group,
                                                 str(self.exp_auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(respG['status']))
+        self.assertEqual(403, int(resp_new['status']))
 
     def test_get_users_global_group_expired_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.get_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.get_user_global_group_xml(\
+                                                self.global_group,
                                                 str(self.exp_auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403, int(respG['status']))
+        self.assertEqual(403, int(resp_new['status']))
 
 
-class delete_users_global_group_test(unittest.TestCase):
+class DeleteUsersGlobalGroupTest(unittest.TestCase):
 
     def setUp(self):
         self.tenant = utils.get_global_tenant()
@@ -909,7 +944,8 @@ class delete_users_global_group_test(unittest.TestCase):
         self.global_group = 'test_global_group'
 
     def tearDown(self):
-        respG, contentG = utils.delete_user_global_group(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
 
@@ -919,16 +955,17 @@ class delete_users_global_group_test(unittest.TestCase):
                                             self.auth_token)
 
     def test_delete_user_global_group(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
 
-        respG, contentG = utils.delete_user_global_group(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
 
@@ -936,68 +973,72 @@ class delete_users_global_group_test(unittest.TestCase):
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(204, int(respG['status']))
+        self.assertEqual(204, int(resp_new['status']))
 
     def test_delete_user_global_group_xml(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.auth_token))
-        respG, contentG = utils.delete_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group_xml(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(204, int(respG['status']))
+        self.assertEqual(204, int(resp_new['status']))
 
     def test_delete_user_global_group_notfound(self):
-        h = httplib2.Http(".cache")
+        header = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.disabled_token))
-        respG, contentG = utils.delete_user_global_group(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
-        respG, contentG = utils.delete_user_global_group(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
-        self.assertEqual(404, int(respG['status']))
+        self.assertEqual(404, int(resp_new['status']))
 
     def test_delete_user_global_group_notfound_xml(self):
         h = httplib2.Http(".cache")
         resp, content = utils.create_global_group(self.global_group,
                                               str(self.auth_token))
-        respG, contentG = utils.create_user(self.tenant, self.user,
+        if int(resp['status']) == 500:
+            self.fail('IDM fault')
+        elif int(resp['status']) == 503:
+            self.fail('Service Not Available')
+        resp_new, content_new = utils.create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = utils.add_user_global_group(self.global_group,
+        resp_new, content_new = utils.add_user_global_group(self.global_group,
                                                 self.user,
                                                 str(self.disabled_token))
-        respG, contentG = utils.delete_user_global_group(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
-        respG, contentG = utils.delete_user_global_group_xml(self.global_group,
+        resp_new, content_new = utils.delete_user_global_group_xml(\
+                                                    self.global_group,
                                                    self.user,
                                                    str(self.auth_token))
-
-        if int(resp['status']) == 500:
-            self.fail('IDM fault')
-        elif int(resp['status']) == 503:
-            self.fail('Service Not Available')
-        self.assertEqual(404, int(respG['status']))
+        self.assertEqual(404, int(resp_new['status']))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/unit/test_tenant_groups.py b/test/unit/test_tenant_groups.py
index 040d84fe..ca733d10 100644
--- a/test/unit/test_tenant_groups.py
+++ b/test/unit/test_tenant_groups.py
@@ -11,7 +11,7 @@ from lxml import etree
 import test_common as util
 
 
-class tenant_group_test(unittest.TestCase):
+class TenantGroupTest(unittest.TestCase):
 
     def setUp(self):
         self.tenant = util.get_tenant()
@@ -31,7 +31,7 @@ class tenant_group_test(unittest.TestCase):
         resp, content = util.delete_tenant(self.tenant, self.auth_token)
 
 
-class create_tenant_group_test(tenant_group_test):
+class CreateTenantGroupTest(TenantGroupTest):
 
     def test_tenant_group_create(self):
 
@@ -313,7 +313,7 @@ class create_tenant_group_test(tenant_group_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class get_tenant_groups_test(tenant_group_test):
+class GetTenantGroupsTest(TenantGroupTest):
 
     def test_get_tenant_groups(self):
         header = httplib2.Http(".cache")
@@ -424,7 +424,7 @@ class get_tenant_groups_test(tenant_group_test):
         self.assertEqual(403, int(resp['status']))
 
 
-class get_tenant_group_test(tenant_group_test):
+class GetTenantGroupTest(TenantGroupTest):
 
     def test_get_tenant_group(self):
         header = httplib2.Http(".cache")
@@ -540,7 +540,7 @@ class get_tenant_group_test(tenant_group_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class update_tenant_group_test(tenant_group_test):
+class UpdateTenantGroupTest(TenantGroupTest):
 
     def test_update_tenant_group(self):
         header = httplib2.Http(".cache")
@@ -706,7 +706,7 @@ class update_tenant_group_test(tenant_group_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class delete_tenant_group_test(tenant_group_test):
+class DeleteTenantGroupTest(TenantGroupTest):
 
     def test_delete_tenant_group_not_found(self):
         resp, content = util.delete_tenant_group("test_tenant_delete111",
@@ -747,7 +747,7 @@ class delete_tenant_group_test(tenant_group_test):
         self.assertEqual(204, int(resp['status']))
 
 
-class add_user_tenant_group_test(tenant_group_test):
+class AddUserTenantGroupTest(TenantGroupTest):
 
     def setUp(self):
         self.tenant = 'test_tenant'
@@ -929,7 +929,7 @@ class add_user_tenant_group_test(tenant_group_test):
         self.assertEqual(403, int(resp['status']))
 
 
-class get_users_tenant_group_test(tenant_group_test):
+class GetUsersTenantGroupTest(TenantGroupTest):
 
     def setUp(self):
         self.tenant = 'test_tenant'
@@ -1124,7 +1124,7 @@ class get_users_tenant_group_test(tenant_group_test):
         self.assertEqual(403, int(resp['status']))
 
 
-class delete_users_tenant_group_test(tenant_group_test):
+class DeleteUsersTenantGroupTest(TenantGroupTest):
 
     def test_delete_user_tenant_group(self):
         resp, content = util.create_tenant(self.tenant, str(self.auth_token))
diff --git a/test/unit/test_tenants.py b/test/unit/test_tenants.py
index 3bcc0da5..256f9a9c 100644
--- a/test/unit/test_tenants.py
+++ b/test/unit/test_tenants.py
@@ -10,7 +10,7 @@ from lxml import etree
 import test_common as utils
 
 
-class tenant_test(unittest.TestCase):
+class TenantTest(unittest.TestCase):
 
     def setUp(self):
         self.tenant = 'test_tenant'
@@ -26,7 +26,7 @@ class tenant_test(unittest.TestCase):
         resp, content = utils.delete_tenant(self.tenant, self.auth_token)
 
 
-class create_tenant_test(tenant_test):
+class CreateTenantTest(TenantTest):
 
     def test_tenant_create(self):
         resp, content = utils.delete_tenant(self.tenant, str(self.auth_token))
@@ -303,7 +303,7 @@ class create_tenant_test(tenant_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class get_tenants_test(tenant_test):
+class GetTenantsTest(TenantTest):
 
     def test_get_tenants(self):
         header = httplib2.Http(".cache")
@@ -393,7 +393,7 @@ class get_tenants_test(tenant_test):
         self.assertEqual(403, int(resp['status']))
 
 
-class get_tenant_test(tenant_test):
+class GetTenantTest(TenantTest):
 
     def test_get_tenant(self):
         header = httplib2.Http(".cache")
@@ -483,7 +483,7 @@ class get_tenant_test(tenant_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class update_tenant_test(tenant_test):
+class UpdateTenantTest(TenantTest):
 
     def test_update_tenant(self):
         header = httplib2.Http(".cache")
@@ -604,7 +604,7 @@ class update_tenant_test(tenant_test):
         self.assertEqual(404, int(resp['status']))
 
 
-class delete_tenant_test(tenant_test):
+class DeleteTenantTest(TenantTest):
 
     def test_delete_tenant_not_found(self):
         #resp,content=utils.create_tenant("test_tenant_delete",
diff --git a/test/unit/test_token.py b/test/unit/test_token.py
index 5f858cd5..9eee2391 100644
--- a/test/unit/test_token.py
+++ b/test/unit/test_token.py
@@ -8,7 +8,7 @@ import httplib2
 import test_common as utils
 
 
-class validate_token(unittest.TestCase):
+class ValidateToken(unittest.TestCase):
 
     def setUp(self):
         self.tenant = utils.get_tenant()
diff --git a/test/unit/test_users.py b/test/unit/test_users.py
index 91e27f72..b3f472c0 100644
--- a/test/unit/test_users.py
+++ b/test/unit/test_users.py
@@ -12,7 +12,7 @@ import test_common as utils
 from test_common import URL
 
 
-class user_test(unittest.TestCase):
+class UserTest(unittest.TestCase):
 
     def setUp(self):
         self.token = utils.get_token('joeuser', 'secrete', 'token')
@@ -31,7 +31,7 @@ class user_test(unittest.TestCase):
         utils.delete_user(self.tenant, self.user, str(self.auth_token))
 
 
-class create_user_test(user_test):
+class CreateUserTest(UserTest):
 
     def test_a_user_create_json(self):
         utils.delete_user(self.tenant, self.user, str(self.auth_token))
@@ -160,7 +160,7 @@ class create_user_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
 
-class get_user_test(user_test):
+class GetUserTest(UserTest):
 
     def test_a_user_get(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
@@ -301,7 +301,7 @@ class get_user_test(user_test):
                           utils.content_type(resp))
 
 
-class delete_user_test(user_test):
+class DeleteUserTest(UserTest):
 
     def test_a_user_delete(self):
         utils.create_user(self.tenant, self.user,
@@ -428,7 +428,7 @@ class delete_user_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
 
-class get_users_test(user_test):
+class GetUsersTest(UserTest):
 
     def test_users_get(self):
         resp, content = utils.users_get_json(self.tenant, self.auth_token)
@@ -545,7 +545,7 @@ class get_users_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
 
-class get_users_group_test(user_test):
+class GetUsersGroupTest(UserTest):
 
     def test_users_group_get(self):
         resp, content = utils.users_group_get_json(self.tenant,
@@ -686,7 +686,7 @@ class get_users_group_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
 
-class update_user_test(user_test):
+class UpdateUserTest(UserTest):
 
     def test_user_update(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
@@ -924,7 +924,7 @@ class update_user_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
 
-class set_password_test(user_test):
+class SetPasswordTest(UserTest):
 
     def test_user_password(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
@@ -1134,7 +1134,7 @@ class set_password_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
 
-class set_enabled_test(user_test):
+class SetEnabledEest(UserTest):
 
     def test_user_enabled(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
diff --git a/test/unit/test_version.py b/test/unit/test_version.py
index 76b013ab..6dd5ba86 100644
--- a/test/unit/test_version.py
+++ b/test/unit/test_version.py
@@ -8,7 +8,7 @@ import httplib2
 import test_common as utils
 
 
-class version_test(unittest.TestCase):
+class VersionTest(unittest.TestCase):
 
     #Given _a_ to make inherited test cases in an order.
     #here to call below method will call as last test case