Pep8 test_users.py

1 files changed, 187 insertions, 187 deletions

diff --git a/test/unit/test_users.py b/test/unit/test_users.py
index 0b84d3fb..bd5200ac 100644
--- a/test/unit/test_users.py
+++ b/test/unit/test_users.py
@@ -37,19 +37,19 @@ class create_user_test(user_test):
 
     def test_a_user_create_json(self):
         utils.delete_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                            str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(201, resp_val)
 
     def test_a_user_create_xml(self):
         utils.delete_user_xml(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.create_user_xml(self.tenant, self.user,
                                            str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(201, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
@@ -58,105 +58,105 @@ class create_user_test(user_test):
         resp, content = utils.create_user('0000', self.user,
                                           str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, resp_val)
 
     def test_a_user_create_json_disabled_tenant_xml(self):
-        resp, content = utils.create_user_xml('0000', self.user, \
+        resp, content = utils.create_user_xml('0000', self.user,
                                               str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_again_json(self):
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
         self.assertEqual(409, int(resp['status']))
 
     def test_a_user_again_xml(self):
-        utils.create_user_xml(self.tenant, self.user, \
+        utils.create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.create_user_xml(self.tenant, self.user,
                                         str(self.auth_token))
         content = etree.fromstring(content)
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(409, int(resp['status']))
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_create_expired_token(self):
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                     str(self.exp_auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, int(resp['status']))
 
     def test_a_user_create_expired_token_xml(self):
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.create_user_xml(self.tenant, self.user,
                                               str(self.exp_auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content,  resp_val, \
+        utils.handle_user_resp(self, content,  resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, int(resp['status']))
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_create_disabled_token(self):
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                     str(self.disabled_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, int(resp['status']))
 
     def test_a_user_create_disabled_token_xml(self):
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.create_user_xml(self.tenant, self.user,
                                               str(self.disabled_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, int(resp['status']))
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_create_missing_token(self):
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                     str(self.missing_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(401, int(resp['status']))
 
     def test_a_user_create_missing_token_xml(self):
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.create_user_xml(self.tenant, self.user,
                                               str(self.missing_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(401, int(resp['status']))
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_create_invalid_token(self):
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.create_user(self.tenant, self.user,
                                     str(self.invalid_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self,  content, resp_val, \
+        utils.handle_user_resp(self,  content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(404, int(resp['status']))
 
     def test_a_user_create_invalid_token_xml(self):
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.create_user_xml(self.tenant, self.user,
                                         str(self.invalid_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self,  content, resp_val, \
+        utils.handle_user_resp(self,  content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(404, int(resp['status']))
         self.assertEqual('application/xml', utils.content_type(resp))
@@ -166,149 +166,149 @@ class get_user_test(user_test):
 
     def test_a_user_get(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json(self.tenant, self.user, \
+        resp, content = utils.user_get_json(self.tenant, self.user,
                                             str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(200, resp_val)
 
     def test_a_user_get_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml(self.tenant, self.user, \
+        resp, content = utils.user_get_xml(self.tenant, self.user,
                                            str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(200, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_get_expired_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json(self.tenant, self.user, \
+        resp, content = utils.user_get_json(self.tenant, self.user,
                                             str(self.exp_auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, resp_val)
 
     def test_a_user_get_expired_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml(self.tenant, self.user, \
+        resp, content = utils.user_get_xml(self.tenant, self.user,
                                             str(self.exp_auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_get_disabled_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json(self.tenant, \
-                                            self.user, \
+        resp, content = utils.user_get_json(self.tenant,
+                                            self.user,
                                             str(self.disabled_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, resp_val)
 
     def test_a_user_get_disabled_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml(self.tenant, \
-                                           self.user, \
+        resp, content = utils.user_get_xml(self.tenant,
+                                           self.user,
                                            str(self.disabled_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_get_missing_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json(self.tenant, \
-                                            self.user, \
+        resp, content = utils.user_get_json(self.tenant,
+                                            self.user,
                                             str(self.missing_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(401, resp_val)
 
     def test_a_user_get_missing_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml(self.tenant, self.user, \
+        resp, content = utils.user_get_xml(self.tenant, self.user,
                                            str(self.missing_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(401, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_get_invalid_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json(self.tenant, self.user, \
+        resp, content = utils.user_get_json(self.tenant, self.user,
                                             str(self.invalid_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(404, resp_val)
 
     def test_a_user_get_invalid_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml(self.tenant, self.user, \
+        resp, content = utils.user_get_xml(self.tenant, self.user,
                                            str(self.invalid_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(404, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_get_disabled_user(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json(self.tenant, \
-                                            self.userdisabled, \
+        resp, content = utils.user_get_json(self.tenant,
+                                            self.userdisabled,
                                             str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(403, resp_val)
 
     def test_a_user_get_disabled_user_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml(self.tenant, self.userdisabled, \
+        resp, content = utils.user_get_xml(self.tenant, self.userdisabled,
                                             str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(403, resp_val)
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_get_disabled_tenant(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_json('0000', self.user, \
+        resp, content = utils.user_get_json('0000', self.user,
                                              str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                 utils.content_type(resp))
         self.assertEqual(403, resp_val)
 
     def test_a_user_get_disabled_tenant_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_get_xml('0000', self.user, \
+        resp, content = utils.user_get_xml('0000', self.user,
                                            str(self.auth_token))
         resp_val = int(resp['status'])
-        utils.handle_user_resp(self, content, resp_val, \
+        utils.handle_user_resp(self, content, resp_val,
                                utils.content_type(resp))
         self.assertEqual(403, resp_val)
-        self.assertEqual('application/xml', \
+        self.assertEqual('application/xml',
                           utils.content_type(resp))
 
 
 class delete_user_test(user_test):
 
     def test_a_user_delete(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                           str(self.auth_token))
-        resp = utils.delete_user(self.tenant, self.user, \
+        resp = utils.delete_user(self.tenant, self.user,
                                str(self.auth_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -318,9 +318,9 @@ class delete_user_test(user_test):
         self.assertEqual(204, resp_val)
 
     def test_a_user_delete_xml(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                           str(self.auth_token))
-        resp = utils.delete_user_xml(self.tenant, self.user, \
+        resp = utils.delete_user_xml(self.tenant, self.user,
                                    str(self.auth_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -330,9 +330,9 @@ class delete_user_test(user_test):
         self.assertEqual(204, resp_val)
 
     def test_a_user_delete_expired_token(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                           str(self.auth_token))
-        resp = utils.delete_user(self.tenant, self.user, \
+        resp = utils.delete_user(self.tenant, self.user,
                                str(self.exp_auth_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -342,9 +342,9 @@ class delete_user_test(user_test):
         self.assertEqual(403, resp_val)
 
     def test_a_user_delete_expired_token_xml(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user_xml(self.tenant, self.user, \
+        resp = utils.delete_user_xml(self.tenant, self.user,
                                     str(self.exp_auth_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -355,9 +355,9 @@ class delete_user_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_delete_missing_token(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user(self.tenant, self.user, \
+        resp = utils.delete_user(self.tenant, self.user,
                                     str(self.missing_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -367,9 +367,9 @@ class delete_user_test(user_test):
         self.assertEqual(401, resp_val)
 
     def test_a_user_delete_missing_token_xml(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user_xml(self.tenant, self.user, \
+        resp = utils.delete_user_xml(self.tenant, self.user,
                                     str(self.missing_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -380,9 +380,9 @@ class delete_user_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_delete_invalid_token(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user(self.tenant, self.user, \
+        resp = utils.delete_user(self.tenant, self.user,
                                     str(self.invalid_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -392,9 +392,9 @@ class delete_user_test(user_test):
         self.assertEqual(404, resp_val)
 
     def test_a_user_delete_invalid_token_xml(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user_xml(self.tenant, self.user, \
+        resp = utils.delete_user_xml(self.tenant, self.user,
                                     str(self.invalid_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -405,9 +405,9 @@ class delete_user_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_a_user_delete_disabled_tenant(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user("0000", self.user, \
+        resp = utils.delete_user("0000", self.user,
                                     str(self.auth_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -417,9 +417,9 @@ class delete_user_test(user_test):
         self.assertEqual(403, resp_val)
 
     def test_a_user_delete_disabled_tenant_xml(self):
-        utils.create_user(self.tenant, self.user, \
+        utils.create_user(self.tenant, self.user,
                                     str(self.auth_token))
-        resp = utils.delete_user_xml("0000", self.user, \
+        resp = utils.delete_user_xml("0000", self.user,
                                     str(self.auth_token))
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -550,8 +550,8 @@ class get_users_test(user_test):
 class get_users_group_test(user_test):
 
     def test_users_group_get(self):
-        resp, content = utils.users_group_get_json(self.tenant, \
-                                                   self.user, \
+        resp, content = utils.users_group_get_json(self.tenant,
+                                                   self.user,
                                                    self.auth_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -561,8 +561,8 @@ class get_users_group_test(user_test):
         self.assertEqual(200, resp_val)
 
     def test_users_group_get_xml(self):
-        resp, content = utils.users_group_get_xml(self.tenant, \
-                                                  self.user, \
+        resp, content = utils.users_group_get_xml(self.tenant,
+                                                  self.user,
                                                   self.auth_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -573,8 +573,8 @@ class get_users_group_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_users_group_get_expired_token(self):
-        resp, content = utils.users_group_get_json(self.tenant, \
-                                                   self.user, \
+        resp, content = utils.users_group_get_json(self.tenant,
+                                                   self.user,
                                                    self.exp_auth_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -584,8 +584,8 @@ class get_users_group_test(user_test):
         self.assertEqual(403, resp_val)
 
     def test_users_group_get_expired_token_xml(self):
-        resp, content = utils.users_group_get_xml(self.tenant, \
-                                                  self.user, \
+        resp, content = utils.users_group_get_xml(self.tenant,
+                                                  self.user,
                                                   self.exp_auth_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -596,8 +596,8 @@ class get_users_group_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_users_group_get_disabled_token(self):
-        resp, content = utils.users_group_get_json(self.tenant, \
-                                                   self.user, \
+        resp, content = utils.users_group_get_json(self.tenant,
+                                                   self.user,
                                                    self.disabled_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -607,8 +607,8 @@ class get_users_group_test(user_test):
         self.assertEqual(403, resp_val)
 
     def test_users_group_get_disabled_token_xml(self):
-        resp, content = utils.users_group_get_xml(self.tenant, \
-                                                  self.user, \
+        resp, content = utils.users_group_get_xml(self.tenant,
+                                                  self.user,
                                                   self.disabled_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -619,8 +619,8 @@ class get_users_group_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_users_group_get_missing_token(self):
-        resp, content = utils.users_group_get_json(self.tenant, \
-                                                   self.user, \
+        resp, content = utils.users_group_get_json(self.tenant,
+                                                   self.user,
                                                    self.missing_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -630,8 +630,8 @@ class get_users_group_test(user_test):
         self.assertEqual(401, resp_val)
 
     def test_users_group_get_missing_token_xml(self):
-        resp, content = utils.users_group_get_xml(self.tenant, \
-                                                  self.user, \
+        resp, content = utils.users_group_get_xml(self.tenant,
+                                                  self.user,
                                                   self.missing_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -642,8 +642,8 @@ class get_users_group_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_users_group_get_invalid_token(self):
-        resp, content = utils.users_group_get_json(self.tenant, \
-                                                   self.user, \
+        resp, content = utils.users_group_get_json(self.tenant,
+                                                   self.user,
                                                    self.invalid_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -653,8 +653,8 @@ class get_users_group_test(user_test):
         self.assertEqual(404, resp_val)
 
     def test_users_group_get_invalid_token_xml(self):
-        resp, content = utils.users_group_get_xml(self.tenant, \
-                                                  self.user, \
+        resp, content = utils.users_group_get_xml(self.tenant,
+                                                  self.user,
                                                   self.invalid_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -665,8 +665,8 @@ class get_users_group_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_users_group_get_disabled_tenant(self):
-        resp, content = utils.users_group_get_json('0000', \
-                                                   self.user, \
+        resp, content = utils.users_group_get_json('0000',
+                                                   self.user,
                                                    self.auth_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -676,8 +676,8 @@ class get_users_group_test(user_test):
         self.assertEqual(403, resp_val)
 
     def test_users_group_get_disabled_tenant_xml(self):
-        resp, content = utils.users_group_get_xml('0000', \
-                                                  self.user, \
+        resp, content = utils.users_group_get_xml('0000',
+                                                  self.user,
                                                   self.auth_token)
         resp_val = int(resp['status'])
         if resp_val == 500:
@@ -692,7 +692,7 @@ class update_user_test(user_test):
 
     def test_user_update(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, self.user,\
+        resp, content = utils.user_update_json(self.tenant, self.user,
                                                self.auth_token)
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -702,12 +702,12 @@ class update_user_test(user_test):
             self.fail('Service Not Available')
         utils.delete_user(self.tenant, self.user, str(self.auth_token))
         self.assertEqual(200, resp_val)
-        self.assertEqual('updatedjoeuser@rackspace.com', \
+        self.assertEqual('updatedjoeuser@rackspace.com',
                          content['user']['email'])
 
     def test_user_update_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, self.user, \
+        resp, content = utils.user_update_xml(self.tenant, self.user,
                                               self.auth_token)
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -717,14 +717,14 @@ class update_user_test(user_test):
             self.fail('Service Not Available')
         utils.delete_user(self.tenant, self.user, str(self.auth_token))
         self.assertEqual(200, resp_val)
-        self.assertEqual('updatedjoeuser@rackspace.com', \
+        self.assertEqual('updatedjoeuser@rackspace.com',
                           content.get("email"))
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_user_update_user_disabled(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, \
-                                               self.userdisabled, \
+        resp, content = utils.user_update_json(self.tenant,
+                                               self.userdisabled,
                                                 self.auth_token)
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -736,8 +736,8 @@ class update_user_test(user_test):
 
     def test_user_update_user_disabled_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, \
-                                               self.userdisabled, \
+        resp, content = utils.user_update_xml(self.tenant,
+                                               self.userdisabled,
                                                self.auth_token)
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -750,9 +750,9 @@ class update_user_test(user_test):
 
     def test_user_update_email_conflict(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, \
-                                              self.user, \
-                                              self.auth_token,\
+        resp, content = utils.user_update_json(self.tenant,
+                                              self.user,
+                                              self.auth_token,
                                               "joe@rackspace.com")
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -764,9 +764,9 @@ class update_user_test(user_test):
 
     def test_user_update_email_conflict_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, \
-                                              self.user, \
-                                              self.auth_token, \
+        resp, content = utils.user_update_xml(self.tenant,
+                                              self.user,
+                                              self.auth_token,
                                               "joe@rackspace.com")
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -779,7 +779,7 @@ class update_user_test(user_test):
 
     def test_user_update_bad_request_json(self):
         h = httplib2.Http(".cache")
-        resp, content = utils.create_user(self.tenant, self.user, \
+        resp, content = utils.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"}}'
@@ -797,7 +797,7 @@ class update_user_test(user_test):
 
     def test_user_update_bad_request_xml(self):
         h = httplib2.Http(".cache")
-        resp, content = utils.create_user_xml(self.tenant, self.user, \
+        resp, content = utils.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"?> \
@@ -819,8 +819,8 @@ class update_user_test(user_test):
 
     def test_user_update_expired_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, \
-                                              self.user, \
+        resp, content = utils.user_update_json(self.tenant,
+                                              self.user,
                                               self.exp_auth_token)
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -832,8 +832,8 @@ class update_user_test(user_test):
 
     def test_user_update_expired_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, \
-                                             self.user, \
+        resp, content = utils.user_update_xml(self.tenant,
+                                             self.user,
                                              self.exp_auth_token)
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -846,8 +846,8 @@ class update_user_test(user_test):
 
     def test_user_update_disabled_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, \
-                                              self.user, \
+        resp, content = utils.user_update_json(self.tenant,
+                                              self.user,
                                               self.disabled_token)
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -859,8 +859,8 @@ class update_user_test(user_test):
 
     def test_user_update_disabled_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, \
-                                             self.user, \
+        resp, content = utils.user_update_xml(self.tenant,
+                                             self.user,
                                              self.disabled_token)
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -873,8 +873,8 @@ class update_user_test(user_test):
 
     def test_user_update_invalid_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_update_json(self.tenant,
+                                               self.user,
                                                self.invalid_token)
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -886,8 +886,8 @@ class update_user_test(user_test):
 
     def test_user_update_invalid_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, \
-                                             self.user, \
+        resp, content = utils.user_update_xml(self.tenant,
+                                             self.user,
                                              self.invalid_token)
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -900,8 +900,8 @@ class update_user_test(user_test):
 
     def test_user_update_missing_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_json(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_update_json(self.tenant,
+                                               self.user,
                                                self.missing_token)
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -913,8 +913,8 @@ class update_user_test(user_test):
 
     def test_user_update_missing_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_update_xml(self.tenant, \
-                                             self.user, \
+        resp, content = utils.user_update_xml(self.tenant,
+                                             self.user,
                                              self.missing_token)
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -930,8 +930,8 @@ class set_password_test(user_test):
 
     def test_user_password(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_json(self.tenant, \
-                                              self.user, \
+        resp, content = utils.user_password_json(self.tenant,
+                                              self.user,
                                               str(self.auth_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -945,8 +945,8 @@ class set_password_test(user_test):
 
     def test_user_password_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_xml(self.tenant, \
-                                              self.user, \
+        resp, content = utils.user_password_xml(self.tenant,
+                                              self.user,
                                               str(self.auth_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -961,8 +961,8 @@ class set_password_test(user_test):
 
     def test_user_password_user_disabled(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_json(self.tenant, \
-                                                self.userdisabled, \
+        resp, content = utils.user_password_json(self.tenant,
+                                                self.userdisabled,
                                                 str(self.auth_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -974,8 +974,8 @@ class set_password_test(user_test):
 
     def test_user_password_user_disabled_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_xml(self.tenant, \
-                                               self.userdisabled, \
+        resp, content = utils.user_password_xml(self.tenant,
+                                               self.userdisabled,
                                                str(self.auth_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -988,7 +988,7 @@ class set_password_test(user_test):
 
     def test_user_password_bad_request_json(self):
         h = httplib2.Http(".cache")
-        utils.create_user(self.tenant, self.user, \
+        utils.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"}}'
@@ -1027,8 +1027,8 @@ class set_password_test(user_test):
 
     def test_user_password_expired_token(self):
         utils.create_user(self.tenant, self.user,  str(self.auth_token))
-        resp, content = utils.user_password_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_password_json(self.tenant,
+                                                self.user,
                                                 str(self.exp_auth_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1040,8 +1040,8 @@ class set_password_test(user_test):
 
     def test_user_password_expired_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_xml(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_password_xml(self.tenant,
+                                               self.user,
                                                str(self.exp_auth_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1054,8 +1054,8 @@ class set_password_test(user_test):
 
     def test_user_password_disabled_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_password_json(self.tenant,
+                                                self.user,
                                                 str(self.disabled_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1067,8 +1067,8 @@ class set_password_test(user_test):
 
     def test_user_password_disabled_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_xml(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_password_xml(self.tenant,
+                                                self.user,
                                                 str(self.disabled_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1080,11 +1080,11 @@ class set_password_test(user_test):
         self.assertEqual('application/xml', utils.content_type(resp))
 
     def test_user_password_invalid_token(self):
-        utils.create_user(self.tenant, \
-                          self.user, \
+        utils.create_user(self.tenant,
+                          self.user,
                           str(self.auth_token))
-        resp, content = utils.user_password_json(self.tenant, \
-                                                 self.user, \
+        resp, content = utils.user_password_json(self.tenant,
+                                                 self.user,
                                                  str(self.invalid_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1096,8 +1096,8 @@ class set_password_test(user_test):
 
     def test_user_password_invalid_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_xml(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_password_xml(self.tenant,
+                                               self.user,
                                                str(self.invalid_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1110,8 +1110,8 @@ class set_password_test(user_test):
 
     def test_user_password_missing_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_password_json(self.tenant,
+                                                self.user,
                                                 str(self.missing_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1123,8 +1123,8 @@ class set_password_test(user_test):
 
     def test_user_password_missing_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_password_xml(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_password_xml(self.tenant,
+                                                self.user,
                                                 str(self.missing_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1140,8 +1140,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_enabled_json(self.tenant,
+                                                self.user,
                                                 str(self.auth_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1155,8 +1155,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_xml(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_enabled_xml(self.tenant,
+                                               self.user,
                                                str(self.auth_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1171,7 +1171,7 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_bad_request_json(self):
         h = httplib2.Http(".cache")
-        utils.create_user(self.tenant, self.user, \
+        utils.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}}'
@@ -1189,7 +1189,7 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_bad_request_xml(self):
         h = httplib2.Http(".cache")
-        utils.create_user_xml(self.tenant, self.user, \
+        utils.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"?> \
@@ -1211,8 +1211,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_expired_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_enabled_json(self.tenant,
+                                                self.user,
                                                 str(self.exp_auth_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1224,8 +1224,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_expired_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_xml(self.tenant, \
-                                              self.user, \
+        resp, content = utils.user_enabled_xml(self.tenant,
+                                              self.user,
                                               str(self.exp_auth_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1238,8 +1238,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_disabled_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_json(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_enabled_json(self.tenant,
+                                               self.user,
                                                str(self.disabled_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1251,8 +1251,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_disabled_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_xml(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_enabled_xml(self.tenant,
+                                               self.user,
                                                str(self.disabled_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1265,8 +1265,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_invalid_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_enabled_json(self.tenant,
+                                                self.user,
                                                 str(self.invalid_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1278,8 +1278,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_invalid_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_xml(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_enabled_xml(self.tenant,
+                                               self.user,
                                                str(self.invalid_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)
@@ -1292,8 +1292,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_missing_token(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_json(self.tenant, \
-                                                self.user, \
+        resp, content = utils.user_enabled_json(self.tenant,
+                                                self.user,
                                                 str(self.missing_token))
         resp_val = int(resp['status'])
         content = json.loads(content)
@@ -1305,8 +1305,8 @@ class set_enabled_test(user_test):
 
     def test_user_enabled_missing_token_xml(self):
         utils.create_user(self.tenant, self.user, str(self.auth_token))
-        resp, content = utils.user_enabled_xml(self.tenant, \
-                                               self.user, \
+        resp, content = utils.user_enabled_xml(self.tenant,
+                                               self.user,
                                                str(self.missing_token))
         resp_val = int(resp['status'])
         content = etree.fromstring(content)