diff --git a/tempest/services/compute/json/servers_client.py b/tempest/services/compute/json/servers_client.py
index ecff7be..e8d1153 100644
--- a/tempest/services/compute/json/servers_client.py
+++ b/tempest/services/compute/json/servers_client.py
@@ -195,108 +195,50 @@
         body = json.loads(body)
         return resp, body
 
-    def change_password(self, server_id, password):
-        """Changes the root password for the server."""
-        post_body = {
-            'changePassword': {
-                'adminPass': password,
-            }
-        }
+    def action(self, server_id, action_name, response_key, **kwargs):
+        post_body = json.dumps({action_name: kwargs})
+        resp, body = self.post('servers/%s/action' % str(server_id),
+                               post_body, self.headers)
+        if response_key is not None:
+            body = json.loads(body)[response_key]
+        return resp, body
 
-        post_body = json.dumps(post_body)
-        return self.post('servers/%s/action' % str(server_id),
-                         post_body, self.headers)
+    def change_password(self, server_id, adminPass):
+        """Changes the root password for the server."""
+        return self.action(server_id, 'changePassword', None,
+                           adminPass=adminPass)
 
     def reboot(self, server_id, reboot_type):
         """Reboots a server."""
-        post_body = {
-            'reboot': {
-                'type': reboot_type,
-            }
-        }
+        return self.action(server_id, 'reboot', None, type=reboot_type)
 
-        post_body = json.dumps(post_body)
-        return self.post('servers/%s/action' % str(server_id),
-                         post_body, self.headers)
-
-    def rebuild(self, server_id, image_ref, name=None, meta=None,
-                personality=None, adminPass=None, disk_config=None):
+    def rebuild(self, server_id, image_ref, **kwargs):
         """Rebuilds a server with a new image."""
-        post_body = {
-                'imageRef': image_ref,
-        }
+        kwargs['imageRef'] = image_ref
+        if 'disk_config' in kwargs:
+            kwargs['OS-DCF:diskConfig'] = kwargs['disk_config']
+            del kwargs['disk_config']
+        return self.action(server_id, 'rebuild', 'server', **kwargs)
 
-        if name is not None:
-            post_body['name'] = name
-
-        if adminPass is not None:
-            post_body['adminPass'] = adminPass
-
-        if meta is not None:
-            post_body['metadata'] = meta
-
-        if personality is not None:
-            post_body['personality'] = personality
-
-        if disk_config is not None:
-            post_body['OS-DCF:diskConfig'] = disk_config
-
-        post_body = json.dumps({'rebuild': post_body})
-        resp, body = self.post('servers/%s/action' % str(server_id),
-                               post_body, self.headers)
-        body = json.loads(body)
-        return resp, body['server']
-
-    def resize(self, server_id, flavor_ref, disk_config=None):
+    def resize(self, server_id, flavor_ref, **kwargs):
         """Changes the flavor of a server."""
-        post_body = {
-            'resize': {
-                'flavorRef': flavor_ref,
-            }
-        }
+        kwargs['flavorRef'] = flavor_ref
+        if 'disk_config' in kwargs:
+            kwargs['OS-DCF:diskConfig'] = kwargs['disk_config']
+            del kwargs['disk_config']
+        return self.action(server_id, 'resize', None, **kwargs)
 
-        if disk_config is not None:
-            post_body['resize']['OS-DCF:diskConfig'] = disk_config
-
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % str(server_id),
-                               post_body, self.headers)
-        return resp, body
-
-    def confirm_resize(self, server_id):
+    def confirm_resize(self, server_id, **kwargs):
         """Confirms the flavor change for a server."""
-        post_body = {
-            'confirmResize': None,
-        }
+        return self.action(server_id, 'confirmResize', None, **kwargs)
 
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % str(server_id),
-                               post_body, self.headers)
-        return resp, body
-
-    def revert_resize(self, server_id):
+    def revert_resize(self, server_id, **kwargs):
         """Reverts a server back to its original flavor."""
-        post_body = {
-            'revertResize': None,
-        }
+        return self.action(server_id, 'revertResize', None, **kwargs)
 
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % str(server_id),
-                               post_body, self.headers)
-        return resp, body
-
-    def create_image(self, server_id, image_name):
+    def create_image(self, server_id, name):
         """Creates an image of the given server."""
-        post_body = {
-            'createImage': {
-                'name': image_name,
-            }
-        }
-
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % str(server_id),
-                               post_body, self.headers)
-        return resp, body
+        return self.action(server_id, 'createImage', None, name=name)
 
     def list_server_metadata(self, server_id):
         resp, body = self.get("servers/%s/metadata" % str(server_id))
@@ -334,15 +276,11 @@
                                  (str(server_id), key))
         return resp, body
 
-    def stop(self, server_id):
-        post_body = json.dumps({'os-stop': None})
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+    def stop(self, server_id, **kwargs):
+        return self.action(server_id, 'os-stop', None, **kwargs)
 
-    def start(self, server_id):
-        post_body = json.dumps({'os-start': None})
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+    def start(self, server_id, **kwargs):
+        return self.action(server_id, 'os-start', None, **kwargs)
 
     def attach_volume(self, server_id, volume_id, device='/dev/vdz'):
         """Attaches a volume to a server instance."""
@@ -362,27 +300,13 @@
                                  (server_id, volume_id))
         return resp, body
 
-    def add_security_group(self, server_id, security_group_name):
+    def add_security_group(self, server_id, name):
         """Adds a security group to the server."""
-        post_body = {
-            'addSecurityGroup': {
-                'name': security_group_name
-            }
-        }
-        post_body = json.dumps(post_body)
-        return self.post('servers/%s/action' % server_id,
-                         post_body, self.headers)
+        return self.action(server_id, 'addSecurityGroup', None, name=name)
 
-    def remove_security_group(self, server_id, security_group_name):
+    def remove_security_group(self, server_id, name):
         """Removes a security group from the server."""
-        post_body = {
-            'removeSecurityGroup': {
-                'name': security_group_name
-            }
-        }
-        post_body = json.dumps(post_body)
-        return self.post('servers/%s/action' % server_id,
-                         post_body, self.headers)
+        return self.action(server_id, 'removeSecurityGroup', None, name=name)
 
     def live_migrate_server(self, server_id, dest_host, use_block_migration):
         """This should be called with administrator privileges ."""
@@ -408,96 +332,41 @@
         body = json.loads(body)
         return resp, body['servers']
 
-    def migrate_server(self, server_id):
+    def migrate_server(self, server_id, **kwargs):
         """Migrates a server to a new host."""
-        post_body = {'migrate': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
-        return resp, body
+        return self.action(server_id, 'migrate', None, **kwargs)
 
-    def confirm_migration(self, server_id):
-        """Confirms the migration of a server."""
-        post_body = {'confirmResize': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
-        return resp, body
-
-    def lock_server(self, server_id):
+    def lock_server(self, server_id, **kwargs):
         """Locks the given server."""
-        post_body = {'lock': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+        return self.action(server_id, 'lock', None, **kwargs)
 
-    def unlock_server(self, server_id):
+    def unlock_server(self, server_id, **kwargs):
         """UNlocks the given server."""
-        post_body = {'unlock': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+        return self.action(server_id, 'unlock', None, **kwargs)
 
-    def start_server(self, server_id):
-        """Starts the given server."""
-        post_body = {'os-start': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
-
-    def stop_server(self, server_id):
-        """Stops the given server."""
-        post_body = {'os-stop': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
-
-    def suspend_server(self, server_id):
+    def suspend_server(self, server_id, **kwargs):
         """Suspends the provded server."""
-        post_body = {'suspend': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+        return self.action(server_id, 'suspend', None, **kwargs)
 
-    def resume_server(self, server_id):
+    def resume_server(self, server_id, **kwargs):
         """Un-suspends the provded server."""
-        post_body = {'resume': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+        return self.action(server_id, 'resume', None, **kwargs)
 
-    def pause_server(self, server_id):
+    def pause_server(self, server_id, **kwargs):
         """Pauses the provded server."""
-        post_body = {'pause': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+        return self.action(server_id, 'pause', None, **kwargs)
 
-    def unpause_server(self, server_id):
+    def unpause_server(self, server_id, **kwargs):
         """Un-pauses the provded server."""
-        post_body = {'unpause': 'null'}
-        post_body = json.dumps(post_body)
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
+        return self.action(server_id, 'unpause', None, **kwargs)
 
-    def reset_state(self, server_id, new_state='error'):
+    def reset_state(self, server_id, state='error'):
         """Resets the state of a server to active/error."""
-        post_body = {
-            'os-resetState': {
-                'state': new_state
-            }
-        }
-        resp, body = self.post('servers/%s/action' % server_id,
-                               post_body, self.headers)
-        return resp, body
+        return self.action(server_id, 'os-resetState', None, state=state)
 
     def get_console_output(self, server_id, length):
-        post_body = {'os-getConsoleOutput': {'length': length}}
-        url = "/servers/%s/action" % server_id
-        post_body = json.dumps(post_body)
-        resp, body = self.post(url, post_body, self.headers)
-        body = json.loads(body)
-        return resp, body['output']
+        return self.action(server_id, 'os-getConsoleOutput', 'output',
+                           length=length)
 
     def list_virtual_interfaces(self, server_id):
         """
diff --git a/tempest/services/compute/xml/servers_client.py b/tempest/services/compute/xml/servers_client.py
index 3abf0c3..049d454 100644
--- a/tempest/services/compute/xml/servers_client.py
+++ b/tempest/services/compute/xml/servers_client.py
@@ -309,34 +309,38 @@
 
         return resp, network
 
+    def action(self, server_id, action_name, response_key, **kwargs):
+        if 'xmlns' not in kwargs:
+            kwargs['xmlns'] = XMLNS_11
+        doc = Document((Element(action_name, **kwargs)))
+        resp, body = self.post("servers/%s/action" % server_id,
+                               str(doc), self.headers)
+        if response_key is not None:
+            body = xml_to_json(etree.fromstring(body))
+        return resp, body
+
     def change_password(self, server_id, password):
-        cpw = Element("changePassword",
-                      xmlns=XMLNS_11,
-                      adminPass=password)
-        return self.post("servers/%s/action" % server_id,
-                         str(Document(cpw)), self.headers)
+        return self.action(server_id, "changePassword", None,
+                           adminPass=password)
 
     def reboot(self, server_id, reboot_type):
-        reboot = Element("reboot",
-                         xmlns=XMLNS_11,
-                         type=reboot_type)
-        return self.post("servers/%s/action" % server_id,
-                         str(Document(reboot)), self.headers)
+        return self.action(server_id, "reboot", None, type=reboot_type)
 
-    def rebuild(self, server_id, image_ref, name=None, meta=None,
-                personality=None, adminPass=None, disk_config=None):
+    def rebuild(self, server_id, image_ref, **kwargs):
+        kwargs['imageRef'] = image_ref
+        if 'xmlns' not in kwargs:
+            kwargs['xmlns'] = XMLNS_11
+
+        attrs = kwargs.copy()
+        if 'metadata' in attrs:
+            del attrs['metadata']
         rebuild = Element("rebuild",
-                          xmlns=XMLNS_11,
-                          imageRef=image_ref)
+                          **attrs)
 
-        if name:
-            rebuild.add_attr("name", name)
-        if adminPass:
-            rebuild.add_attr("adminPass", adminPass)
-        if meta:
+        if 'metadata' in kwargs:
             metadata = Element("metadata")
             rebuild.append(metadata)
-            for k, v in meta.items():
+            for k, v in kwargs['metadata'].items():
                 meta = Element("meta", key=k)
                 meta.append(Text(v))
                 metadata.append(meta)
@@ -346,53 +350,31 @@
         server = self._parse_server(etree.fromstring(body))
         return resp, server
 
-    def resize(self, server_id, flavor_ref, disk_config=None):
-        resize = Element("resize",
-                         xmlns=XMLNS_11,
-                         flavorRef=flavor_ref)
+    def resize(self, server_id, flavor_ref, **kwargs):
+        if 'disk_config' in kwargs:
+            raise NotImplementedError("Sorry, disk_config not "
+                                      "supported via XML yet")
+        kwargs['flavorRef'] = flavor_ref
+        return self.action(server_id, 'resize', None, **kwargs)
 
-        if disk_config is not None:
-            raise Exception("Sorry, disk_config not supported via XML yet")
+    def confirm_resize(self, server_id, **kwargs):
+        return self.action(server_id, 'confirmResize', None, **kwargs)
 
-        return self.post('servers/%s/action' % server_id,
-                         str(Document(resize)), self.headers)
+    def revert_resize(self, server_id, **kwargs):
+        return self.action(server_id, 'revertResize', None, **kwargs)
 
-    def confirm_resize(self, server_id):
-        conf = Element('confirmResize')
-        return self.post('servers/%s/action' % server_id,
-                         str(Document(conf)), self.headers)
+    def create_image(self, server_id, name):
+        return self.action(server_id, 'createImage', None, name=name)
 
-    def revert_resize(self, server_id):
-        revert = Element('revertResize')
-        return self.post('servers/%s/action' % server_id,
-                         str(Document(revert)), self.headers)
+    def add_security_group(self, server_id, name):
+        return self.action(server_id, 'addSecurityGroup', None, name=name)
 
-    def create_image(self, server_id, image_name):
-        metadata = Element('metadata')
-        image = Element('createImage',
-                        metadata,
-                        xmlns=XMLNS_11,
-                        name=image_name)
-        return self.post('servers/%s/action' % server_id,
-                         str(Document(image)), self.headers)
-
-    def add_security_group(self, server_id, security_group_name):
-        secgrp = Element('addSecurityGroup', name=security_group_name)
-        return self.post('servers/%s/action' % server_id,
-                         str(Document(secgrp)), self.headers)
-
-    def remove_security_group(self, server_id, security_group_name):
-        secgrp = Element('removeSecurityGroup', name=security_group_name)
-        return self.post('servers/%s/action' % server_id,
-                         str(Document(secgrp)), self.headers)
+    def remove_security_group(self, server_id, name):
+        return self.action(server_id, 'removeSecurityGroup', None, name=name)
 
     def get_console_output(self, server_id, length):
-        post_body = Element("os-getConsoleOutput", length=length)
-        resp, body = self.post("/servers/%s/action" % server_id,
-                               headers=self.headers,
-                               body=str(Document(post_body)))
-        body = xml_to_json(etree.fromstring(body))
-        return resp, body
+        return self.action(server_id, 'os-getConsoleOutput', 'output',
+                           length=length)
 
     def list_virtual_interfaces(self, server_id):
         """
diff --git a/tempest/services/identity/json/identity_client.py b/tempest/services/identity/json/identity_client.py
index 68e7d4b..5b6eaa0 100644
--- a/tempest/services/identity/json/identity_client.py
+++ b/tempest/services/identity/json/identity_client.py
@@ -44,7 +44,7 @@
         post_body = {
             'name': name,
             'description': kwargs.get('description', ''),
-            'enabled': kwargs.get('enabled', 'true'),
+            'enabled': kwargs.get('enabled', True),
         }
         post_body = json.dumps({'tenant': post_body})
         resp, body = self.post('tenants', post_body, self.headers)
diff --git a/tempest/tests/identity/admin/test_tenants.py b/tempest/tests/identity/admin/test_tenants.py
index 594afe8..6385cec 100644
--- a/tempest/tests/identity/admin/test_tenants.py
+++ b/tempest/tests/identity/admin/test_tenants.py
@@ -229,7 +229,7 @@
         t_desc2 = rand_name('desc2-')
         resp, body = self.client.update_tenant(t_id, description=t_desc2)
         st2 = resp['status']
-        resp2_desc = body['extra']['description']
+        resp2_desc = body['description']
         self.assertTrue(st2.startswith('2'))
         self.assertNotEqual(resp1_desc, resp2_desc)
 
@@ -257,7 +257,7 @@
         t_en2 = True
         resp, body = self.client.update_tenant(t_id, enabled=t_en2)
         st2 = resp['status']
-        resp2_en = body['extra']['enabled']
+        resp2_en = body['enabled']
         self.assertTrue(st2.startswith('2'))
         self.assertNotEqual(resp1_en, resp2_en)
 
diff --git a/tempest/tests/identity/admin/test_users.py b/tempest/tests/identity/admin/test_users.py
index 8396b91..67b2517 100644
--- a/tempest/tests/identity/admin/test_users.py
+++ b/tempest/tests/identity/admin/test_users.py
@@ -130,6 +130,7 @@
         resp, user = self.client.create_user('user_1234', self.alt_password,
                                              self.data.tenant['id'],
                                              self.alt_email)
+        self.assertEquals('200', resp['status'])
         resp, body = self.client.delete_user(user['id'])
         self.assertEquals('204', resp['status'])
 
@@ -255,16 +256,18 @@
         resp, user1 = self.client.create_user('tenant_user1', 'password1',
                                               self.data.tenant['id'],
                                               'user1@123')
+        self.assertEquals('200', resp['status'])
         user_ids.append(user1['id'])
         self.data.users.append(user1)
         resp, user2 = self.client.create_user('tenant_user2', 'password2',
                                               self.data.tenant['id'],
                                               'user2@123')
+        self.assertEquals('200', resp['status'])
         user_ids.append(user2['id'])
         self.data.users.append(user2)
         #List of users for the respective tenant ID
         resp, body = self.client.list_users_for_tenant(self.data.tenant['id'])
-        self.assertTrue(resp['status'].startswith('2'))
+        self.assertTrue(resp['status'] in ('200', '203'))
         for i in body:
             fetched_user_ids.append(i['id'])
         #verifying the user Id in the list
@@ -286,17 +289,22 @@
         user_ids = list()
         fetched_user_ids = list()
         user_ids.append(user['id'])
-        self.client.assign_user_role(tenant['id'], user['id'], role['id'])
+        resp, role = self.client.assign_user_role(tenant['id'], user['id'],
+                                                  role['id'])
+        self.assertEquals('200', resp['status'])
         resp, second_user = self.client.create_user('second_user', 'password1',
                                                     self.data.tenant['id'],
                                                     'user1@123')
+        self.assertEquals('200', resp['status'])
         user_ids.append(second_user['id'])
         self.data.users.append(second_user)
-        self.client.assign_user_role(tenant['id'], second_user['id'],
-                                     role['id'])
+        resp, role = self.client.assign_user_role(tenant['id'],
+                                                  second_user['id'],
+                                                  role['id'])
+        self.assertEquals('200', resp['status'])
         #List of users with roles for the respective tenant ID
         resp, body = self.client.list_users_for_tenant(self.data.tenant['id'])
-        self.assertTrue(resp['status'].startswith('2'))
+        self.assertEquals('200', resp['status'])
         for i in body:
             fetched_user_ids.append(i['id'])
         #verifying the user Id in the list