Added PEP8 for remaining test cases

5 files changed, 212 insertions, 234 deletions

diff --git a/test/unit/test_tenant_groups.py b/test/unit/test_tenant_groups.py
index f15bd909..3a0b9369 100644
--- a/test/unit/test_tenant_groups.py
+++ b/test/unit/test_tenant_groups.py
@@ -13,7 +13,6 @@ from webtest import TestApp
 from test_common import *
 
 
-
 class tenant_group_test(unittest.TestCase):
 
     def setUp(self):
@@ -211,7 +210,6 @@ class create_tenant_group_test(tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
-
     def test_tenant_group_create_missing_token_xml(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant_xml(self.tenant, str(self.auth_token))
@@ -233,7 +231,6 @@ class create_tenant_group_test(tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(401, int(resp['status']))
 
-
     def test_tenant_group_create_disabled_token(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -245,7 +242,7 @@ class create_tenant_group_test(tenant_group_test):
             "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})
+                                          "X-Auth-Token": self.disabled_token})
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -405,7 +402,7 @@ class get_tenant_groups_test(tenant_group_test):
         #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})
+                                          "X-Auth-Token": self.exp_auth_token})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
@@ -516,9 +513,9 @@ class get_tenant_group_test(tenant_group_test):
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         if int(resp['status']) == 500:
-              self.fail('IDM fault')
+            self.fail('IDM fault')
         elif int(resp['status']) == 503:
-              self.fail('Service Not Available')
+            self.fail('Service Not Available')
         self.assertEqual(404, int(resp['status']))
 
     def test_get_tenant_group_not_found_xml(self):
@@ -586,7 +583,7 @@ class update_tenant_group_test(tenant_group_test):
                                               self.tenant,
                                               str(self.auth_token))
 
-        url = '%stenant/%s/groups/%s' % (URL, self.tenant , self.tenant_group)
+        url = '%stenant/%s/groups/%s' % (URL, self.tenant, self.tenant_group)
 
         data = '<group xmlns="http://docs.openstack.org/idm/api/v1.0" \
              tenantId="%s" id="%s"> \
@@ -773,7 +770,6 @@ class add_user_tenant_group_test(tenant_group_test):
                                             self.auth_token)
         resp, content = delete_tenant(self.tenant, self.auth_token)
 
-
     def test_add_user_tenant_group(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -785,8 +781,7 @@ class add_user_tenant_group_test(tenant_group_test):
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
         respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
+                                               self.user, str(self.auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -795,7 +790,6 @@ class add_user_tenant_group_test(tenant_group_test):
         if int(respG['status']) not in (200, 201):
             self.fail('Failed due to %d' % int(respG['status']))
 
-
     def test_add_user_tenant_group_xml(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -816,7 +810,6 @@ class add_user_tenant_group_test(tenant_group_test):
         if int(respG['status']) not in (200, 201):
             self.fail('Failed due to %d' % int(respG['status']))
 
-
     def test_add_user_tenant_group_conflict(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -826,12 +819,9 @@ class add_user_tenant_group_test(tenant_group_test):
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
         respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
+                                              self.user, str(self.auth_token))
         respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
-
+                                              self.user, str(self.auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
@@ -846,12 +836,13 @@ class add_user_tenant_group_test(tenant_group_test):
                                               str(self.auth_token))
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
-        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                self.tenant_group,
+                                              self.user, str(self.auth_token))
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                self.tenant_group,
+                                                self.user,
+                                                str(self.auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -886,7 +877,8 @@ class add_user_tenant_group_test(tenant_group_test):
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
 
-        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
                                                 self.user, self.token)
 
         if int(resp['status']) == 500:
@@ -922,8 +914,10 @@ class add_user_tenant_group_test(tenant_group_test):
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
 
-        respG, contentG = add_user_tenant_group_xml(self.tenant, self.tenant_group,
-                                                self.user, self.disabled_token)
+        respG, contentG = add_user_tenant_group_xml(self.tenant,
+                                                    self.tenant_group,
+                                                    self.user,
+                                                    self.disabled_token)
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -967,11 +961,9 @@ class get_users_tenant_group_test(tenant_group_test):
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
         respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
+                                              self.user, str(self.auth_token))
         respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
-                                                str(self.auth_token)
-                                                )
+                                                str(self.auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -979,7 +971,6 @@ class get_users_tenant_group_test(tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(200, int(respG['status']))
 
-
     def test_get_users_tenant_group_xml(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -994,15 +985,13 @@ class get_users_tenant_group_test(tenant_group_test):
                                                     str(self.auth_token))
         respG, contentG = get_user_tenant_group_xml(self.tenant,
                                                     self.tenant_group,
-                                                    str(self.auth_token)
-                                                )
+                                                    str(self.auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(200, int(respG['status']))
 
-
     def test_get_users_tenant_group_unauthorized(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -1012,12 +1001,13 @@ class get_users_tenant_group_test(tenant_group_test):
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
 
-        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
-                                                self.user, self.auth_token)
+        respG, contentG = add_user_tenant_group(self.tenant,
+                                                self.tenant_group,
+                                                self.user,
+                                                self.auth_token)
 
         respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
-                                                str(self.token)
-                                                )
+                                                str(self.token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -1038,8 +1028,7 @@ class get_users_tenant_group_test(tenant_group_test):
                                                 self.user, self.auth_token)
         respG, contentG = get_user_tenant_group_xml(self.tenant,
                                                     self.tenant_group,
-                                                    str(self.token)
-                                                )
+                                                    str(self.token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -1060,8 +1049,7 @@ class get_users_tenant_group_test(tenant_group_test):
                                                 self.user, self.auth_token)
         respG, contentG = get_user_tenant_group(self.tenant,
                                                 self.tenant_group,
-                                                str(self.disabled_token)
-                                                )
+                                                str(self.disabled_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -1082,8 +1070,7 @@ class get_users_tenant_group_test(tenant_group_test):
                                                 self.user, self.auth_token)
         respG, contentG = get_user_tenant_group_xml(self.tenant,
                                                     self.tenant_group,
-                                                    str(self.disabled_token)
-                                                )
+                                                    str(self.disabled_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
@@ -1102,8 +1089,7 @@ class get_users_tenant_group_test(tenant_group_test):
         respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
                                                 self.user, self.auth_token)
         respG, contentG = get_user_tenant_group(self.tenant, self.tenant_group,
-                                                str(self.exp_auth_token)
-                                                )
+                                                str(self.exp_auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -1124,14 +1110,14 @@ class get_users_tenant_group_test(tenant_group_test):
                                                 self.user, self.auth_token)
         respG, contentG = get_user_tenant_group_xml(self.tenant,
                                                     self.tenant_group,
-                                                    str(self.exp_auth_token)
-                                                )
+                                                    str(self.exp_auth_token))
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
             self.fail('Service Not Available')
         self.assertEqual(403, int(respG['status']))
 
+
 class delete_users_tenant_group_test(tenant_group_test):
 
     def test_delete_user_tenant_group(self):
@@ -1142,14 +1128,14 @@ class delete_users_tenant_group_test(tenant_group_test):
                                               str(self.auth_token))
         respG, contentG = create_user(self.tenant, self.user,
                                       str(self.auth_token))
-        respG, contentG = add_user_tenant_group(self.tenant, self.tenant_group,
-                                                self.user, str(self.auth_token)
-                                                )
+        respG, contentG = add_user_tenant_group(self.tenant,
+                                                self.tenant_group,
+                                                self.user,
+                                                str(self.auth_token))
         respG, contentG = delete_user_tenant_group(self.tenant,
                                                    self.tenant_group,
                                                    self.user,
-                                                   str(self.auth_token)
-                                                )
+                                                   str(self.auth_token))
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -1157,7 +1143,6 @@ class delete_users_tenant_group_test(tenant_group_test):
             self.fail('Service Not Available')
         self.assertEqual(204, int(respG['status']))
 
-
     def test_delete_user_tenant_group_xml(self):
         h = httplib2.Http(".cache")
         resp, content = create_tenant(self.tenant, str(self.auth_token))
@@ -1187,8 +1172,7 @@ class delete_users_tenant_group_test(tenant_group_test):
         respG, contentG = delete_user_tenant_group(self.tenant,
                                                    self.tenant_group,
                                                    'NonExistinguser',
-                                                   str(self.auth_token)
-                                                )
+                                                   str(self.auth_token))
 
         if int(respG['status']) == 500:
             self.fail('IDM fault')
@@ -1202,8 +1186,7 @@ class delete_users_tenant_group_test(tenant_group_test):
         respG, contentG = delete_user_tenant_group_xml(self.tenant,
                                                    self.tenant_group,
                                                    'NonExistinguser',
-                                                   str(self.auth_token)
-                                                )
+                                                   str(self.auth_token))
 
         if int(respG['status']) == 500:
             self.fail('IDM fault')
diff --git a/test/unit/test_tenants.py b/test/unit/test_tenants.py
index a4713c52..c2b41e25 100644
--- a/test/unit/test_tenants.py
+++ b/test/unit/test_tenants.py
@@ -12,6 +12,7 @@ import unittest
 from webtest import TestApp
 from test_common import *
 
+
 class tenant_test(unittest.TestCase):
 
     def setUp(self):
@@ -25,10 +26,10 @@ class tenant_test(unittest.TestCase):
 
     def tearDown(self):
         resp, content = delete_tenant(self.tenant, self.auth_token)
-        
+
 
 class create_tenant_test(tenant_test):
-     
+
     def test_tenant_create(self):
         resp, content = delete_tenant('test_tenant', str(self.auth_token))
         resp, content = create_tenant('test_tenant', str(self.auth_token))
@@ -231,8 +232,7 @@ class create_tenant_test(tenant_test):
                 :true  } }' % self.tenant
         resp, content = h.request(url, "POST", body=body,
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.disabled_token
-                                           })
+                                        "X-Auth-Token": self.disabled_token})
 
         if int(resp['status']) == 500:
             self.fail('IDM fault')
@@ -318,8 +318,7 @@ class get_tenants_test(tenant_test):
         #test for Content-Type = application/json
         resp, content = h.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.auth_token
-                                           })
+                                         "X-Auth-Token": self.auth_token})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
@@ -377,8 +376,7 @@ class get_tenants_test(tenant_test):
         #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
-                                           })
+                                        "X-Auth-Token": self.exp_auth_token})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
@@ -640,4 +638,4 @@ class delete_tenant_test(tenant_test):
         self.assertEqual(204, int(resp['status']))
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/test/unit/test_token.py b/test/unit/test_token.py
index c29061c2..622de6f0 100644
--- a/test/unit/test_token.py
+++ b/test/unit/test_token.py
@@ -61,8 +61,7 @@ class validate_token(unittest.TestCase):
                                            self.tenant)
         resp, content = h.request(url, "GET", body='',
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.exp_auth_token}
-                                  )
+                                         "X-Auth-Token": self.exp_auth_token})
         if int(resp['status']) == 500:
             self.fail('IDM fault')
         elif int(resp['status']) == 503:
diff --git a/test/unit/test_users.py b/test/unit/test_users.py
index 31afe408..05a3e2ee 100644
--- a/test/unit/test_users.py
+++ b/test/unit/test_users.py
@@ -12,6 +12,7 @@ import unittest
 from webtest import TestApp
 from test_common import *
 
+
 class user_test(unittest.TestCase):
 
     def setUp(self):
@@ -29,89 +30,89 @@ class user_test(unittest.TestCase):
 
     def tearDown(self):
 
-        resp, content = delete_user(self.tenant, self.user, 
+        resp, content = delete_user(self.tenant, self.user,
                                     str(self.auth_token))
 
 
 class create_user_test(user_test):
 
     def test_a_user_create_json(self):
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,content, resp_val, content_type(resp))
-        self.assertEqual(201,resp_val)
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(201, resp_val)
 
     def test_a_user_create_xml(self):
-        resp, content = delete_user_xml(self.tenant, self.user, 
+        resp, content = delete_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,content, resp_val, content_type(resp))
-        
-        self.assertEqual(201,resp_val)
+        handle_user_resp(self, content, resp_val, content_type(resp))
+
+        self.assertEqual(201, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_create_json_disabled_tenant(self):
-        resp, content = create_user('0000', self.user, 
+        resp, content = create_user('0000', self.user,
                                     str(self.auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,content, resp_val, content_type(resp))
-        self.assertEqual(403,resp_val)
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
 
     def test_a_user_create_json_disabled_tenant_xml(self):
-        resp, content = create_user_xml('0000', self.user, 
+        resp, content = create_user_xml('0000', self.user,
                                         str(self.auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,content, resp_val, content_type(resp))
-        self.assertEqual(403,resp_val)
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_again_json(self):
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,content, resp_val, content_type(resp))
-        resp, content = create_user(self.tenant, self.user, 
+        handle_user_resp(self, content, resp_val, content_type(resp))
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         self.assertEqual(409, int(resp['status']))
 
     def test_a_user_again_xml(self):
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         content = etree.fromstring(content)
         resp_val = int(resp['status'])
-        handle_user_resp(self,content, resp_val, content_type(resp))
+        handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(409, int(resp['status']))
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_create_expired_token(self):
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.exp_auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self, content,resp_val, content_type(resp))
+        handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(403, int(resp['status']))
 
     def test_a_user_create_expired_token_xml(self):
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.exp_auth_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self, content,resp_val, content_type(resp))
+        handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(403, int(resp['status']))
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_create_disabled_token(self):
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.disabled_token))
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(403, int(resp['status']))
 
     def test_a_user_create_disabled_token_xml(self):
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.disabled_token))
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
@@ -119,14 +120,14 @@ class create_user_test(user_test):
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_create_missing_token(self):
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.missing_token))
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(401, int(resp['status']))
 
     def test_a_user_create_missing_token_xml(self):
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.missing_token))
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
@@ -134,17 +135,17 @@ class create_user_test(user_test):
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_create_invalid_token(self):
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.invalid_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,  content,resp_val, content_type(resp))
+        handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(404, int(resp['status']))
 
     def test_a_user_create_invalid_token_xml(self):
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.invalid_token))
         resp_val = int(resp['status'])
-        handle_user_resp(self,  content,resp_val, content_type(resp))
+        handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(404, int(resp['status']))
         self.assertEqual('application/xml', content_type(resp))
 
@@ -153,12 +154,11 @@ class get_user_test(user_test):
 
     def test_a_user_get_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
-        #test for Content-Type = application/json
         resp, content = h.request(url, "GET", body='{}',
-                                  headers={"Content-Type": "application/json", 
+                                  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))
@@ -166,7 +166,7 @@ class get_user_test(user_test):
 
     def test_a_user_get_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                         str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         resp, content = h.request(url, "GET", body='{}',
@@ -180,21 +180,20 @@ class get_user_test(user_test):
 
     def test_a_user_get_expired_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
         resp, content = h.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.exp_auth_token
-                                           })
+                                        "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
 
     def test_a_user_get_expired_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -209,21 +208,20 @@ class get_user_test(user_test):
 
     def test_a_user_get_disabled_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
         resp, content = h.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.disabled_token}
-                                  )
+                                        "X-Auth-Token": self.disabled_token})
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
         self.assertEqual(403, resp_val)
 
     def test_a_user_get_disabled_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -251,7 +249,7 @@ class get_user_test(user_test):
 
     def test_a_user_get_missing_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -261,12 +259,12 @@ class get_user_test(user_test):
                                            "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(401, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_a_user_get_invalid_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -275,11 +273,11 @@ class get_user_test(user_test):
                                            "X-Auth-Token": self.invalid_token})
         resp_val = int(resp['status'])
         handle_user_resp(self, content, resp_val, content_type(resp))
-        self.assertEqual(404,resp_val)
+        self.assertEqual(404, resp_val)
 
     def test_a_user_get_invalid_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -294,7 +292,7 @@ class get_user_test(user_test):
 
     def test_a_user_get_disabled_user(self):
         h = httplib2.Http(".cache")
-        url = '%stenants/%s/users/%s' % (URL, self.tenant, 
+        url = '%stenants/%s/users/%s' % (URL, self.tenant,
                                          self.userdisabled)
         #test for Content-Type = application/json
         resp, content = h.request(url, "GET", body='{}',
@@ -308,7 +306,7 @@ class get_user_test(user_test):
     def test_a_user_get_disabled_user_xml(self):
         h = httplib2.Http(".cache")
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.userdisabled)
-        
+
         resp, content = h.request(url, "GET", body='',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
@@ -321,7 +319,7 @@ class get_user_test(user_test):
     def test_a_user_get_disabled_tenant(self):
         h = httplib2.Http(".cache")
         url = '%stenants/%s/users/%s' % (URL, '0000', self.userdisabled)
-        
+
         resp, content = h.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
@@ -347,7 +345,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -363,7 +361,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant, self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         resp, content = h.request(url, "DELETE", body='{}',
@@ -379,13 +377,13 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_expired_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
         resp, content = h.request(url, "DELETE", body='{}',
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.exp_auth_token})
+                                         "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         if resp_val == 500:
             self.fail('IDM fault')
@@ -395,7 +393,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_expired_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -413,7 +411,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_missing_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -429,7 +427,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_missing_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -447,7 +445,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_invalid_token(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -463,7 +461,7 @@ class delete_user_test(user_test):
 
     def test_a_user_delete_invalid_token_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.user, self.tenant, 
+        resp, content = create_user(self.user, self.tenant,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         #test for Content-Type = application/json
@@ -511,6 +509,7 @@ class delete_user_test(user_test):
         self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
+
 class get_users_test(user_test):
 
     def test_users_get_json(self):
@@ -546,8 +545,7 @@ class get_users_test(user_test):
         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}
-                                  )
+                                       "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         if resp_val == 500:
             self.fail('IDM fault')
@@ -575,8 +573,7 @@ class get_users_test(user_test):
         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}
-                                  )
+                                        "X-Auth-Token": self.disabled_token})
         resp_val = int(resp['status'])
         if resp_val == 500:
             self.fail('IDM fault')
@@ -642,7 +639,7 @@ class get_users_test(user_test):
 
     def test_users_get_invalid_token_xml(self):
         h = httplib2.Http(".cache")
-        url = '%stenants/%s/users' % (URL,self.tenant)
+        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,
@@ -657,7 +654,7 @@ class get_users_test(user_test):
 
     def test_users_get_disabled_tenant_json(self):
         h = httplib2.Http(".cache")
-        url = '%stenants/%s/users' % (URL,"0000")
+        url = '%stenants/%s/users' % (URL, "0000")
         resp, content = h.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
@@ -666,12 +663,12 @@ class get_users_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        
-        self.assertEqual(403,resp_val)
+
+        self.assertEqual(403, resp_val)
 
     def test_users_get_disabled_tenant_xml(self):
         h = httplib2.Http(".cache")
-        url = '%stenants/%s/users' % (URL,"0000")
+        url = '%stenants/%s/users' % (URL, "0000")
         resp, content = h.request(url, "GET", body='{}',
                                   headers={"Content-Type": "application/xml",
                                            "X-Auth-Token": self.auth_token,
@@ -681,9 +678,10 @@ class get_users_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
+
 class get_users_group_test(user_test):
 
     def test_users_group_get_json(self):
@@ -697,7 +695,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(200,resp_val)
+        self.assertEqual(200, resp_val)
 
     def test_users_group_get_xml(self):
         h = httplib2.Http(".cache")
@@ -711,7 +709,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(200,resp_val)
+        self.assertEqual(200, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_users_group_get_expired_token_json(self):
@@ -719,13 +717,13 @@ class get_users_group_test(user_test):
         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})
+                                         "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         if resp_val == 500:
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
 
     def test_users_group_get_expired_token_xml(self):
         h = httplib2.Http(".cache")
@@ -739,7 +737,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_users_group_get_disabled_token_json(self):
@@ -747,14 +745,13 @@ class get_users_group_test(user_test):
         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}
-                                  )
+                                       "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)
+        self.assertEqual(403, resp_val)
 
     def test_users_group_get_disabled_token_xml(self):
         h = httplib2.Http(".cache")
@@ -768,7 +765,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_users_group_get_missing_token_json(self):
@@ -782,7 +779,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401,resp_val)
+        self.assertEqual(401, resp_val)
 
     def test_users_group_get_missing_token_xml(self):
         h = httplib2.Http(".cache")
@@ -796,7 +793,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(401,resp_val)
+        self.assertEqual(401, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_users_group_get_invalid_token_json(self):
@@ -810,7 +807,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(404,resp_val)
+        self.assertEqual(404, resp_val)
 
     def test_users_group_get_invalid_token_xml(self):
         h = httplib2.Http(".cache")
@@ -824,7 +821,7 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(404,resp_val)
+        self.assertEqual(404, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_users_group_get_disabled_tenant_json(self):
@@ -838,8 +835,8 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        
-        self.assertEqual(403,resp_val)
+
+        self.assertEqual(403, resp_val)
 
     def test_users_group_get_disabled_tenant_xml(self):
         h = httplib2.Http(".cache")
@@ -853,38 +850,40 @@ class get_users_group_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
+
 class update_user_test(user_test):
 
     def test_user_update_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        
+
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
-        
+
         data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         resp_val = int(resp['status'])
-        
+
         content = json.loads(content)
         if resp_val == 500:
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
-        self.assertEqual(200,resp_val)
-        self.assertEqual('updatedjoeuser@rackspace.com',content['user']['email'])
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(200, resp_val)
+        self.assertEqual('updatedjoeuser@rackspace.com', \
+                        content['user']['email'])
 
     def test_user_update_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
-        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        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" />'
@@ -893,20 +892,20 @@ class update_user_test(user_test):
                                            "X-Auth-Token": self.auth_token,
                                            "ACCEPT": "application/xml"})
         resp_val = int(resp['status'])
-        
+
         content = etree.fromstring(content)
         if resp_val == 500:
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
-        self.assertEqual(200,resp_val)
-        self.assertEqual('updatedjoeuser@rackspace.com',content.get("email"))
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(200, resp_val)
+        self.assertEqual('updatedjoeuser@rackspace.com', content.get("email"))
         self.assertEqual('application/xml', content_type(resp))
 
     def test_user_update_user_disabled_json(self):
         h = httplib2.Http(".cache")
-        url = '%stenants/%s/users/%s' % (URL,self.tenant, self.userdisabled)
+        url = '%stenants/%s/users/%s' % (URL, self.tenant, self.userdisabled)
         data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
@@ -917,11 +916,11 @@ class update_user_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        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)
+        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" />'
@@ -935,17 +934,17 @@ class update_user_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        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, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         data = '{"user": { "email": "joe@rackspace.com"}}'
         resp, content = h.request(url, "PUT", body=data,
-                                headers={"Content-Type": "application/json", 
+                                headers={"Content-Type": "application/json",
                                          "X-Auth-Token": self.auth_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -957,7 +956,7 @@ class update_user_test(user_test):
 
     def test_user_update_email_conflict_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user, 
+        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"?> \
@@ -978,7 +977,7 @@ class update_user_test(user_test):
 
     def test_user_update_bad_request_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         data = '{"user_bad": { "bad": "updatedjoeuser@rackspace.com"}}'
@@ -991,14 +990,14 @@ class update_user_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
+        delete_user(self.tenant, self.user, str(self.auth_token))
         self.assertEqual(400, resp_val)
 
     def test_user_update_bad_request_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
-        url = '%stenants/%s/users/%s' % (URL,self.tenant,self.user)
+        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" />'
@@ -1012,19 +1011,17 @@ class update_user_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
-        self.assertEqual(400,resp_val)
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(400, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
-
     def test_user_update_expired_token_json(self):
         h = httplib2.Http(".cache")
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
         data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
-        resp, content = h.request(url, "PUT", body=data, 
+        resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.exp_auth_token
-                                           })
+                                        "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
@@ -1058,8 +1055,7 @@ class update_user_test(user_test):
         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
-                                           })
+                                        "X-Auth-Token": self.disabled_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
@@ -1090,13 +1086,13 @@ class update_user_test(user_test):
     def test_user_update_invalid_token_json(self):
         h = httplib2.Http(".cache")
         url = '%stenants/%s/users/%s' % (URL, self.tenant, self.user)
-        
+
         data = '{"user": { "email": "updatedjoeuser@rackspace.com"}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.invalid_token})
         resp_val = int(resp['status'])
-        
+
         content = json.loads(content)
         if resp_val == 500:
             self.fail('IDM fault')
@@ -1162,9 +1158,9 @@ class set_password_test(user_test):
 
     def test_user_password_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant,self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
         data = '{"user": { "password": "p@ssword"}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
@@ -1175,13 +1171,13 @@ class set_password_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
-        self.assertEqual(200,resp_val)
-        self.assertEqual('p@ssword',content['user']['password'])
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(200, resp_val)
+        self.assertEqual('p@ssword', content['user']['password'])
 
     def test_user_password_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user,
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
         data = '<?xml version="1.0" encoding="UTF-8"?> \
@@ -1198,23 +1194,25 @@ class set_password_test(user_test):
         elif resp_val == 503:
             self.fail('Service Not Available')
         delete_user(self.tenant, self.user, str(self.auth_token))
-        self.assertEqual(200,resp_val)
+        self.assertEqual(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)
+        url = '%stenants/%s/users/%s/password' \
+                       % (URL, self.tenant, self.userdisabled)
         data = '{"user": { "password": "p@ssword"}}'
         resp, content = h.request(url, "PUT", body=data,
-                                headers={"Content-Type": "application/json", "X-Auth-Token": self.auth_token})
+                                headers={"Content-Type": "application/json",
+                                    "X-Auth-Token": self.auth_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
 
     def test_user_password_user_disabled_xml(self):
         h = httplib2.Http(".cache")
@@ -1232,12 +1230,12 @@ class set_password_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(403,resp_val)
+        self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_user_password_bad_request_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant, self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
         data = '{"user_bad": { "password": "p@ssword"}}'
@@ -1250,14 +1248,14 @@ class set_password_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
-        self.assertEqual(400,resp_val)
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(400, resp_val)
 
     def test_user_password_bad_request_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user, 
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
-        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        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" />'
@@ -1271,18 +1269,17 @@ class set_password_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
-        self.assertEqual(400,resp_val)
+        delete_user(self.tenant, self.user, str(self.auth_token))
+        self.assertEqual(400, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
-
     def test_user_password_expired_token_json(self):
         h = httplib2.Http(".cache")
         url = '%stenants/%s/users/%s/password' % (URL, self.tenant, self.user)
         data = '{"user": { "password": "p@ssword"}}'
         resp, content = h.request(url, "PUT", body=data,
-                                  headers={"Content-Type": "application/json", 
-                                           "X-Auth-Token": self.exp_auth_token})
+                                  headers={"Content-Type": "application/json",
+                                         "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
@@ -1316,7 +1313,7 @@ class set_password_test(user_test):
         data = '{"user": { "password": "p@ssword"}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.disabled_token})
+                                          "X-Auth-Token": self.disabled_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
@@ -1357,7 +1354,7 @@ class set_password_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(404,resp_val)
+        self.assertEqual(404, resp_val)
 
     def test_user_password_invalid_token_xml(self):
         h = httplib2.Http(".cache")
@@ -1375,7 +1372,7 @@ class set_password_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        self.assertEqual(404,resp_val)
+        self.assertEqual(404, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
     def test_user_password_missing_token_json(self):
@@ -1417,15 +1414,15 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant,self.user, 
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
-        data = {"user": { "enabled": True}}
+        data = {"user": {"enabled": True}}
         resp, content = h.request(url, "PUT", body=json.dumps(data),
                                   headers={"Content-Type": "application/json",
                                            "X-Auth-Token": self.auth_token})
         resp_val = int(resp['status'])
-        
+
         content = json.loads(content)
         if resp_val == 500:
             self.fail('IDM fault')
@@ -1437,7 +1434,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user, str(self.auth_token))
+        resp, content = create_user_xml(self.tenant, self.user,
+                                        str(self.auth_token))
         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" \
@@ -1452,14 +1450,14 @@ class set_enabled_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
+        delete_user(self.tenant, self.user, str(self.auth_token))
         self.assertEqual(200, resp_val)
-        self.assertEqual('true',content.get("enabled"))
+        self.assertEqual('true', content.get("enabled"))
         self.assertEqual('application/xml', content_type(resp))
 
     def test_user_enabled_bad_request_json(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user(self.tenant,self.user,
+        resp, content = create_user(self.tenant, self.user,
                                     str(self.auth_token))
         url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
         data = '{"user_bad": { "enabled": true}}'
@@ -1472,12 +1470,12 @@ class set_enabled_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
+        delete_user(self.tenant, self.user, str(self.auth_token))
         self.assertEqual(400, resp_val)
 
     def test_user_enabled_bad_request_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = create_user_xml(self.tenant,self.user,
+        resp, content = create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
         data = '<?xml version="1.0" encoding="UTF-8"?> \
@@ -1493,18 +1491,17 @@ class set_enabled_test(user_test):
             self.fail('IDM fault')
         elif resp_val == 503:
             self.fail('Service Not Available')
-        delete_user(self.tenant,self.user, str(self.auth_token))
+        delete_user(self.tenant, self.user, str(self.auth_token))
         self.assertEqual(400, resp_val)
         self.assertEqual('application/xml', content_type(resp))
 
-
     def test_user_enabled_expired_token_json(self):
         h = httplib2.Http(".cache")
         url = '%stenants/%s/users/%s/enabled' % (URL, self.tenant, self.user)
         data = '{"user": { "enabled": true}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.exp_auth_token})
+                                         "X-Auth-Token": self.exp_auth_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
@@ -1538,7 +1535,7 @@ class set_enabled_test(user_test):
         data = '{"user": { "enabled": true}}'
         resp, content = h.request(url, "PUT", body=data,
                                   headers={"Content-Type": "application/json",
-                                           "X-Auth-Token": self.disabled_token})
+                                         "X-Auth-Token": self.disabled_token})
         resp_val = int(resp['status'])
         content = json.loads(content)
         if resp_val == 500:
@@ -1617,7 +1614,7 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_missing_token_xml(self):
         h = httplib2.Http(".cache")
-        url = '%stenants/%s/users/%s/password' % (URL,self.tenant,self.user)
+        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" />'
@@ -1635,4 +1632,4 @@ class set_enabled_test(user_test):
         self.assertEqual('application/xml', content_type(resp))
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/test/unit/test_version.py b/test/unit/test_version.py
index b5e536a5..bb35a741 100644
--- a/test/unit/test_version.py
+++ b/test/unit/test_version.py
@@ -12,6 +12,7 @@ import unittest
 from webtest import TestApp
 from test_common import *
 
+
 class version_test(unittest.TestCase):
 
     #Given _a_ to make inherited test cases in an order.
@@ -21,7 +22,7 @@ class version_test(unittest.TestCase):
         h = httplib2.Http(".cache")
         url = URL
         resp, content = h.request(url, "GET", body="",
-                                  headers={"Content-Type":"application/json"})
+                                  headers={"Content-Type": "application/json"})
         self.assertEqual(200, int(resp['status']))
         self.assertEqual('application/json', content_type(resp))
 
@@ -34,6 +35,6 @@ class version_test(unittest.TestCase):
 
         self.assertEqual(200, int(resp['status']))
         self.assertEqual('application/xml', content_type(resp))
-        
+
 if __name__ == '__main__':
     unittest.main()