fixes

1 files changed, 186 insertions, 188 deletions

diff --git a/test/unit/test_users.py b/test/unit/test_users.py
index 0b84d3fb..2388ef82 100644
--- a/test/unit/test_users.py
+++ b/test/unit/test_users.py
@@ -4,12 +4,10 @@ import sys
 sys.path.append(os.path.abspath(os.path.join(os.path.abspath(__file__),
                                 '..', '..', '..', '..', 'keystone')))
 import unittest
-from webtest import TestApp
 import httplib2
 import json
 from lxml import etree
-import unittest
-from webtest import TestApp
+
 import test_common as utils
 from test_common import URL
 
@@ -37,19 +35,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 +56,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 +164,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 +316,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 +328,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 +340,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 +353,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 +365,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 +378,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 +390,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 +403,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 +415,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 +548,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 +559,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 +571,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 +582,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 +594,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 +605,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 +617,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 +628,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 +640,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 +651,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 +663,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 +674,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:
@@ -702,12 +700,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 +715,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 +734,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,8 +748,8 @@ 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, \
+        resp, content = utils.user_update_json(self.tenant,
+                                              self.user,
                                               self.auth_token,\
                                               "joe@rackspace.com")
         resp_val = int(resp['status'])
@@ -764,9 +762,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 +777,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 +795,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 +817,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 +830,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 +844,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 +857,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 +871,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 +884,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 +898,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 +911,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 +928,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 +943,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 +959,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 +972,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 +986,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 +1025,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 +1038,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 +1052,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 +1065,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 +1078,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 +1094,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 +1108,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 +1121,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 +1138,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 +1153,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 +1169,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 +1187,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 +1209,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 +1222,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 +1236,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 +1249,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 +1263,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 +1276,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 +1290,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 +1303,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)