diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py
index 85dcc6c..22cd7ce 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py
@@ -38,7 +38,7 @@ class DatabaseAddTestCase(BaseTestGenerator):
         """ This function will add database under 1st server of tree node. """
 
         server_connect_response, server_group, server_ids = \
-            utils.connect_server(self.tester)
+            utils.connect_server(self.tester, True)
 
         for server_connect, server_id in zip(server_connect_response,
                                              server_ids):
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py
index 4615d34..6740534 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py
@@ -70,5 +70,6 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
         :return: None
         """
 
+        utils.delete_database(self.tester)
         utils.delete_server(self.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py
new file mode 100644
index 0000000..4a11bf8
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py
@@ -0,0 +1,16 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class RoleGeneratorTestCase(BaseTestGenerator):
+
+    def runTest(self):
+        return
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py
new file mode 100644
index 0000000..27cae52
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py
@@ -0,0 +1,54 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class LoginRoleAddTestCase(BaseTestGenerator):
+    """This class has add role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    def setUp(self):
+        """This function used to add the sever"""
+
+        # Add the server
+        utils.add_server(self.tester)
+
+    def runTest(self):
+        """This function test the add role scenario"""
+
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, True)
+
+        for server_connect, server_id in zip(server_connect_response,
+                                             server_ids):
+            if server_connect['data']['connected']:
+                data = utils.get_role_data()
+                response = self.tester.post(self.url + str(server_group) + '/'
+                                            + server_id + '/',
+                                            data=json.dumps(data),
+                                            content_type='html/json')
+                self.assertTrue(response.status_code, 200)
+                response_data = json.loads(response.data.decode('utf-8'))
+                utils.write_role_id(response_data)
+
+    def tearDown(self):
+        """This function deletes the role,server and parent id file"""
+
+        utils.delete_role(self.tester)
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
+
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py
new file mode 100644
index 0000000..47769cb
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py
@@ -0,0 +1,63 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+
+import json
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from test_setup import config_data
+from regression.test_utils import get_ids
+
+
+class LoginRoleDeleteTestCase(BaseTestGenerator):
+    """This class has delete role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    def setUp(self):
+        """This function used to add the server"""
+
+        # Add the server
+        utils.add_server(self.tester)
+        # Connect to server
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, False)
+        # Add the role
+        utils.add_role(self.tester, server_connect_response, server_group,
+                       server_ids)
+
+    def runTest(self):
+        """This function tests the delete role scenario"""
+
+        srv_grp = config_data['test_server_group']
+        all_id = get_ids()
+        server_ids = all_id["sid"]
+        role_ids_dict = all_id["lrid"][0]
+
+        for server_id in server_ids:
+            role_id = role_ids_dict[int(server_id)]
+            role_response = utils.verify_role(self.tester, srv_grp, server_id,
+                                              role_id)
+            if len(role_response) == 0:
+                raise Exception("No roles(s) to delete!!!")
+            response = self.tester.delete(self.url + str(srv_grp) + '/' +
+                                          str(server_id) + '/' + str(role_id),
+                                          follow_redirects=True)
+            delete_response_data = json.loads(response.data.decode('utf-8'))
+            self.assertTrue(delete_response_data['success'], 1)
+
+    def tearDown(self):
+        """This function deletes the role,server and parent id file"""
+
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
+
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py
new file mode 100644
index 0000000..3c2ed9c
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py
@@ -0,0 +1,53 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from test_setup import config_data
+from pgadmin.utils.route import BaseTestGenerator
+from regression.test_utils import get_ids
+
+
+class LoginRoleGetTestCase(BaseTestGenerator):
+    """This class tests the get role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    def setUp(self):
+        # Add the server
+        utils.add_server(self.tester)
+        # Connect to server
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, False)
+        # Add the role
+        utils.add_role(self.tester, server_connect_response, server_group,
+                       server_ids)
+
+    def runTest(self):
+        """This function test the get role scenario"""
+        srv_grp = config_data['test_server_group']
+        all_id = get_ids()
+        server_ids = all_id["sid"]
+        role_ids_dict = all_id["lrid"][0]
+
+        for server_id in server_ids:
+            role_id = role_ids_dict[int(server_id)]
+            response = self.tester.get(self.url + str(srv_grp) + '/' +
+                                       str(server_id) + '/' + str(role_id),
+                                       follow_redirects=True)
+            self.assertEquals(response.status_code, 200)
+
+    def tearDown(self):
+        """This function deletes the role,server and parent id file"""
+
+        utils.delete_role(self.tester)
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py
new file mode 100644
index 0000000..b1f8ba2
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py
@@ -0,0 +1,68 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from test_setup import config_data, advanced_config_data
+from pgadmin.utils.route import BaseTestGenerator
+from regression.test_utils import get_ids
+
+
+class LoginRolePutTestCase(BaseTestGenerator):
+    """This class has update role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    def setUp(self):
+        # Add the server
+        utils.add_server(self.tester)
+        # Connect to server
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, False)
+        # Add the role
+        utils.add_role(self.tester, server_connect_response, server_group,
+                       server_ids)
+
+    def runTest(self):
+        """This function tests the update role data scenario"""
+
+        srv_grp = config_data['test_server_group']
+        all_id = get_ids()
+        server_ids = all_id["sid"]
+        role_ids_dict = all_id["lrid"][0]
+
+        for server_id in server_ids:
+            role_id = role_ids_dict[int(server_id)]
+            role_response = utils.verify_role(self.tester, srv_grp, server_id,
+                                              role_id)
+            if len(role_response) == 0:
+                raise Exception("No roles(s) to update!!!")
+
+            data = {
+                "description": advanced_config_data["test_lr_update_data"]
+                ["test_comment"],
+                "lrid": role_id
+            }
+            put_response = self.tester.put(self.url + str(srv_grp) + '/' +
+                                           str(server_id) + '/' + str(role_id),
+                                           data=json.dumps(data),
+                                           follow_redirects=True)
+
+            self.assertEquals(put_response.status_code, 200)
+
+    def tearDown(self):
+        """This function deletes the role,server and parent id file"""
+
+        utils.delete_role(self.tester)
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py
new file mode 100644
index 0000000..3302027
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py
@@ -0,0 +1,16 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class TblspaceGeneratorTestCase(BaseTestGenerator):
+
+    def runTest(self):
+        return
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py
new file mode 100644
index 0000000..48c7628
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py
@@ -0,0 +1,53 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+
+
+class TableSpaceAddTestCase(BaseTestGenerator):
+    """This class will add tablespace node under server"""
+
+    scenarios = [
+        # Fetching default URL for tablespace node.
+        ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+    ]
+
+    def setUp(self):
+        """This function used to add the sever"""
+
+        # Add the server
+        utils.add_server(self.tester)
+
+    def runTest(self):
+        """This function test the add tablespace scenario"""
+
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, True)
+
+        for server_connect, server_id in zip(server_connect_response,
+                                             server_ids):
+            if server_connect['data']['connected']:
+                data = utils.get_tablespace_data(server_connect)
+                response = self.tester.post(self.url + str(server_group) + '/'
+                                            + server_id + '/',
+                                            data=json.dumps(data),
+                                            content_type='html/json')
+                self.assertTrue(response.status_code, 200)
+                response_data = json.loads(response.data.decode('utf-8'))
+                utils.write_tablespace_id(response_data)
+
+    def tearDown(self):
+        """This function deletes the tablespace,server and parent id file"""
+
+        utils.delete_table_space(self.tester)
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py
new file mode 100644
index 0000000..298a8e8
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py
@@ -0,0 +1,65 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from test_setup import config_data
+from regression.test_utils import get_ids
+
+
+class TableSpaceDeleteTestCase(BaseTestGenerator):
+    """This class has delete table space scenario"""
+
+    scenarios = [
+        # Fetching default URL for tablespace node.
+        ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+    ]
+
+    def setUp(self):
+        """This function used to add the server"""
+
+        # Add the server
+        utils.add_server(self.tester)
+        # Connect to server
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, False)
+        # Add the table space
+        utils.add_table_space(self.tester, server_connect_response,
+                              server_group,
+                              server_ids)
+
+    def runTest(self):
+        """This function tests the delete table space scenario"""
+
+        srv_grp = config_data['test_server_group']
+        all_id = get_ids()
+        server_ids = all_id["sid"]
+        table_space_ids_dict = all_id["table_space_id"][0]
+
+        for server_id in server_ids:
+            table_space_id = table_space_ids_dict[int(server_id)]
+            table_space_response = utils.verify_table_space(self.tester,
+                                                            srv_grp, server_id,
+                                                            table_space_id)
+            if len(table_space_response) == 0:
+                raise Exception("No tablespace(s) to delete!!!")
+
+            response = self.tester.delete(self.url + str(srv_grp) + '/' +
+                                          str(server_id) + '/' + str(
+                table_space_id),
+                                          follow_redirects=True)
+            delete_response_data = json.loads(response.data.decode('utf-8'))
+            self.assertTrue(delete_response_data['success'], 1)
+
+    def tearDown(self):
+        """This function deletes the server and parent id file"""
+
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py
new file mode 100644
index 0000000..45e12c0
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py
@@ -0,0 +1,59 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from test_setup import config_data
+from pgadmin.utils.route import BaseTestGenerator
+from regression.test_utils import get_ids
+
+
+class TablespaceGetTestCase(BaseTestGenerator):
+    """This class tests the get table space scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+    ]
+
+    def setUp(self):
+        # Add the server
+        utils.add_server(self.tester)
+        # Connect to server
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, False)
+        # Add the table space
+        utils.add_table_space(self.tester, server_connect_response,
+                              server_group,
+                              server_ids)
+
+    def runTest(self):
+        """This function test the get table space scenario"""
+
+        srv_grp = config_data['test_server_group']
+        all_id = get_ids()
+        server_ids = all_id["sid"]
+        tablespace_ids_dict = all_id["table_space_id"][0]
+
+        for server_id in server_ids:
+            tablespace_id = tablespace_ids_dict[int(server_id)]
+            server_response = utils.verify_server(self.tester, srv_grp,
+                                                  server_id)
+            if server_response['data']['connected']:
+                response = self.tester.get(self.url + str(srv_grp) + '/' +
+                                           str(server_id) + '/' + str(
+                    tablespace_id),
+                                           follow_redirects=True)
+                self.assertEquals(response.status_code, 200)
+
+    def tearDown(self):
+        """This function deletes the role,server and parent id file"""
+
+        utils.delete_table_space(self.tester)
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py
new file mode 100644
index 0000000..927640f
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py
@@ -0,0 +1,72 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from test_setup import config_data, advanced_config_data
+from pgadmin.utils.route import BaseTestGenerator
+from regression.test_utils import get_ids
+
+
+class TableSpaceUpdateTestCase(BaseTestGenerator):
+    """This class has update tablespace scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+    ]
+
+    def setUp(self):
+        # Add the server
+        utils.add_server(self.tester)
+        # Connect to server
+        server_connect_response, server_group, server_ids = \
+            utils.connect_server(self.tester, False)
+        # Add the tablespace
+        utils.add_table_space(self.tester, server_connect_response,
+                              server_group,
+                              server_ids)
+
+    def runTest(self):
+        """This function tests the update tablespace data scenario"""
+
+        srv_grp = config_data['test_server_group']
+        all_id = get_ids()
+        server_ids = all_id["sid"]
+        tablespace_ids_dict = all_id["table_space_id"][0]
+
+        for server_id in server_ids:
+            tablespace_id = tablespace_ids_dict[int(server_id)]
+            tablespace_response = utils.verify_table_space(self.tester,
+                                                           srv_grp, server_id,
+                                                           tablespace_id)
+            if len(tablespace_response) == 0:
+                raise Exception("No tablespace(s) to update!!!")
+
+            data = {
+                "description": advanced_config_data["test_tbspc_update_data"]
+                ["test_comment"],
+                "table_space_id": tablespace_id
+            }
+
+            put_response = self.tester.put(self.url + str(srv_grp) + '/' +
+                                           str(server_id) + '/' + str(
+                tablespace_id),
+                                           data=json.dumps(data),
+                                           follow_redirects=True)
+
+            self.assertEquals(put_response.status_code, 200)
+
+    def tearDown(self):
+        """This function deletes the role,server and parent id file"""
+
+        utils.delete_table_space(self.tester)
+        utils.delete_server(self.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py
index 2b1eb45..37d6949 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py
@@ -32,10 +32,8 @@ class ServersAddTestCase(BaseTestGenerator):
             url = "{0}{1}/".format(self.url, server_group)
             response = self.tester.post(url, data=json.dumps(server_data),
                                         content_type='html/json')
-
             self.assertTrue(response.status_code, 200)
-
-            response_data = json.loads(response.data.decode())
+            response_data = json.loads(response.data.decode('utf-8'))
             utils.write_parent_id(response_data, pickle_id_dict)
 
     def tearDown(self):
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py
index 5e810ba..9973359 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py
@@ -68,5 +68,6 @@ class ServerUpdateTestCase(BaseTestGenerator):
         :return: None
         """
 
+        utils.delete_database(self.tester)
         utils.delete_server(self.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/tests/test_change_password.py b/web/pgadmin/browser/tests/test_change_password.py
index 2f714a7..3dbd386 100644
--- a/web/pgadmin/browser/tests/test_change_password.py
+++ b/web/pgadmin/browser/tests/test_change_password.py
@@ -11,6 +11,8 @@ import uuid
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression.test_setup import config_data
+from regression import test_utils as utils
+from utils import change_password
 
 
 class ChangePasswordTestCase(BaseTestGenerator):
@@ -56,51 +58,58 @@ class ChangePasswordTestCase(BaseTestGenerator):
                 ['test_new_password']),
             respdata='Invalid password')),
 
-        # This testcase checks for valid password
+        # This test case checks for valid password
         ('TestCase for Changing Valid_Password', dict(
-            password=(config_data['pgAdmin4_login_credentials']
+            valid_password='reassigning_password',
+            username=(config_data['pgAdmin4_test_user_credentials']
+                      ['test_login_username']),
+            password=(config_data['pgAdmin4_test_user_credentials']
                       ['test_login_password']),
-            new_password=(config_data['pgAdmin4_login_credentials']
+            new_password=(config_data['pgAdmin4_test_user_credentials']
                           ['test_new_password']),
             new_password_confirm=(
-                config_data['pgAdmin4_login_credentials']
+                config_data['pgAdmin4_test_user_credentials']
                 ['test_new_password']),
-            respdata='You successfully changed your password.')),
-        ('Reassigning_Password', dict(
-            test_case='reassigning_password',
-            password=(config_data['pgAdmin4_login_credentials']
-                      ['test_new_password']),
-            new_password=(config_data['pgAdmin4_login_credentials']
-                          ['test_login_password']),
-            new_password_confirm=(
-                config_data['pgAdmin4_login_credentials']
-                ['test_login_password']),
             respdata='You successfully changed your password.'))
-
     ]
 
+    def setUp(self):
+        pass
+
     def runTest(self):
         """This function will check change password functionality."""
 
-        # Check for 'test_case' exists in self For reassigning the password.
-        # Password gets change in change password test case.
-        if 'test_case' in dir(self):
-            email = \
-                config_data['pgAdmin4_login_credentials'][
-                    'test_login_username']
-            password = \
-                config_data['pgAdmin4_login_credentials'][
-                    'test_new_password']
+        # Check for 'valid_password' exists in self to test 'valid password'
+        # test case
+        if 'valid_password' in dir(self):
+            response = self.tester.post('/user_management/user/', data=dict(
+                email=self.username, newPassword=self.password,
+                confirmPassword=self.password, active=1, role="2"),
+                                        follow_redirects=True)
+            assert response.status_code == 200
+
+            # Logout the Administrator before login normal user
+            utils.logout_tester_account(self.tester)
+
             response = self.tester.post('/login', data=dict(
-                email=email, password=password), follow_redirects=True)
-
-        response = self.tester.get('/change', follow_redirects=True)
-        self.assertIn('pgAdmin 4 Password Change', response.data.decode(
-            'utf-8'))
-
-        response = self.tester.post('/change', data=dict(
-            password=self.password,
-            new_password=self.new_password,
-            new_password_confirm=self.new_password_confirm),
-                                    follow_redirects=True)
-        self.assertIn(self.respdata, response.data.decode('utf-8'))
+                email=self.username, password=self.password),
+                                        follow_redirects=True)
+            assert response.status_code == 200
+
+            # test the 'change password' test case
+            change_password(self)
+
+            # Delete the normal user after changing it's password
+            utils.logout_tester_account(self.tester)
+
+            # Login the Administrator before deleting normal user
+            utils.login_tester_account(self.tester)
+            response = self.tester.delete('/user_management/user/2',
+                                          follow_redirects=True)
+            assert response.status_code == 200
+        else:
+            change_password(self)
+
+    def tearDown(self):
+        utils.login_tester_account(self.tester)
+
diff --git a/web/pgadmin/browser/tests/utils.py b/web/pgadmin/browser/tests/utils.py
new file mode 100644
index 0000000..18548ce
--- /dev/null
+++ b/web/pgadmin/browser/tests/utils.py
@@ -0,0 +1,21 @@
+# ##########################################################################
+#
+# #pgAdmin 4 - PostgreSQL Tools
+#
+# #Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# #This software is released under the PostgreSQL Licence
+#
+# ##########################################################################
+
+
+def change_password(self):
+    response = self.tester.get('/change', follow_redirects=True)
+    self.assertIn('pgAdmin 4 Password Change', response.data.decode(
+        'utf-8'))
+
+    response = self.tester.post('/change', data=dict(
+        password=self.password,
+        new_password=self.new_password,
+        new_password_confirm=self.new_password_confirm),
+                                follow_redirects=True)
+    self.assertIn(self.respdata, response.data.decode('utf-8'))
\ No newline at end of file
diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in
index c0d278b..8b679ad 100644
--- a/web/regression/test_advanced_config.json.in
+++ b/web/regression/test_advanced_config.json.in
@@ -194,6 +194,50 @@
   {
       "test_comment": "This is db update comment"
   }
- ]
+ ],
+ "test_lr_credentials": {
+      "test_can_login": "true",
+      "test_conn_limit": -1,
+      "test_create_role": "true",
+      "test_role_inherit": "true",
+      "test_role_membership": [],
+      "test_lr_name":  "testlrg1",
+      "test_lr_password": "edb",
+      "test_lr_validity": "12/27/2016",
+      "test_sec_lable": [],
+      "test_variable":[
+                        {"name":"work_mem",
+                          "database":"postgres",
+                          "value":65
+                        }]
+    },
+  "test_lr_update_data": {
+      "test_comment": "This is db update comment"
+  },
+
+  "test_tablespc_credentials":[{
+    "test_tblspace_name": "test_tablespace",
+    "test_spc_seclable": [],
+    "test_spc_acl": [
+      {
+        "grantee":"postgres",
+        "grantor":"postgres",
+        "privileges":[
+          {
+            "privilege_type":"C",
+            "privilege":true,
+            "with_grant":false
+          }
+        ]
+      }
+    ],
+    "test_spc_location": "/Library/PostgreSQL/9.6/data",
+    "test_spc_opts": [],
+    "test_spc_user": "postgres"
+  }],
+
+    "test_tbspc_update_data": {
+    "test_comment": "This is tablespace update comment"
+  }
 
-}
\ No newline at end of file
+}
diff --git a/web/regression/test_config.json.in b/web/regression/test_config.json.in
index 028d1e7..9fcf197 100644
--- a/web/regression/test_config.json.in
+++ b/web/regression/test_config.json.in
@@ -4,6 +4,11 @@
     "test_login_password": "PASSWORD",
     "test_login_username": "USER@EXAMPLE.COM"
   },
+  "pgAdmin4_test_user_credentials": {
+    "test_new_password": "NEWPASSWORD",
+    "test_login_password": "PASSWORD",
+    "test_login_username": "USER@EXAMPLE.COM"
+  },
   "test_server_group": 1,
   "test_server_credentials": [
     {
diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py
index 6be2bb2..18c5981 100644
--- a/web/regression/test_utils.py
+++ b/web/regression/test_utils.py
@@ -19,6 +19,20 @@ SERVER_URL = '/browser/server/obj/'
 SERVER_CONNECT_URL = 'browser/server/connect/'
 DATABASE_URL = '/browser/database/obj/'
 DATABASE_CONNECT_URL = 'browser/database/connect/'
+ROLE_URL = '/browser/role/obj/'
+TABLE_SPACE_URL = '/browser/tablespace/obj/'
+
+
+def get_pickle_id_dict():
+    """This function returns the empty dict of server config data"""
+
+    pickle_id_dict = {
+        "sid": [],  # server
+        "did": [],  # database
+        "lrid": [],  # role
+        "table_space_id": []  # tablespace
+    }
+    return pickle_id_dict
 
 
 def get_ids(url=pickle_path):
@@ -34,10 +48,22 @@ def get_ids(url=pickle_path):
     output = open(url, 'rb')
     ids = pickle.load(output)
     output.close()
-
     return ids
 
 
+def verify_server(tester, server_group, server_id):
+    """This function verifies that server is connecting or not"""
+
+    response = tester.post(
+        '{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id),
+        data=dict(password=config_data
+        ['test_server_credentials'][0]
+        ['test_db_password']),
+        follow_redirects=True)
+    srv_connect = json.loads(response.data.decode('utf-8'))
+    return srv_connect
+
+
 def verify_database(tester, server_group, server_id, db_id):
     """
     This function verifies that database is exists and whether it connect
@@ -158,6 +184,7 @@ def logout_tester_account(tester):
     response = tester.get('/logout')
 
 
+# Config data for parent_id.pkl
 def get_config_data():
     """
     This function get the data related to server group and database
@@ -168,12 +195,7 @@ def get_config_data():
     """
 
     db_data = []
-
-    pickle_id_dict = {
-        "sid": [],  # server
-        "did": []  # database
-    }
-
+    pickle_id_dict = get_pickle_id_dict()
     server_group = config_data['test_server_group']
 
     for srv in config_data['test_server_credentials']:
@@ -205,7 +227,7 @@ def write_parent_id(response_data, pickle_id_dict):
         existed_server_id = open(pickle_path, 'rb')
         pickle_id_dict = pickle.load(existed_server_id)
 
-    pickle_id_dict["sid"].append(server_id)
+    pickle_id_dict["sid"].append(str(server_id))
     output = open(pickle_path, 'wb')
     pickle.dump(pickle_id_dict, output)
     output.close()
@@ -223,20 +245,22 @@ def write_db_parent_id(response_data):
 
     db_id = response_data['node']['_id']
     server_id = response_data['node']['_pid']
+    # TODO: modify logic to write in file / file exists or create new
+    pickle_id_dict = get_pickle_id_dict()
     if os.path.isfile(pickle_path):
         existing_server_id = open(pickle_path, 'rb')
         tol_server_id = pickle.load(existing_server_id)
         pickle_id_dict = tol_server_id
-        if 'did' in pickle_id_dict:
-            if pickle_id_dict['did']:
-                # Add the db_id as value in dict
-                pickle_id_dict["did"][0].update({server_id: db_id})
-            else:
-                # Create new dict with server_id and db_id
-                pickle_id_dict["did"].append({server_id: db_id})
-        db_output = open(pickle_path, 'wb')
-        pickle.dump(pickle_id_dict, db_output)
-        db_output.close()
+    if 'did' in pickle_id_dict:
+        if pickle_id_dict['did']:
+            # Add the db_id as value in dict
+            pickle_id_dict["did"][0].update({server_id: db_id})
+        else:
+            # Create new dict with server_id and db_id
+            pickle_id_dict["did"].append({server_id: db_id})
+    db_output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, db_output)
+    db_output.close()
 
 
 def delete_parent_id_file():
@@ -265,7 +289,7 @@ def add_server(tester):
     for db_detail in db_data:
         response = tester.post(url, data=json.dumps(db_detail),
                                content_type='html/json')
-        response_data = json.loads(response.data.decode())
+        response_data = json.loads(response.data.decode('utf-8'))
         write_parent_id(response_data, pickle_id_dict)
 
 
@@ -289,12 +313,14 @@ def get_server(tester):
         response_data = json.loads(response.data.decode())
 
 
-def connect_server(tester):
+def connect_server(tester, add_db_flag=False):
     """
     This function used to connect added server
 
     :param tester:test client object
     :type tester: flask test object
+    :param add_db_flag: flag for db add test case
+    :type add_db_flag: bool
     :return: server_connect, server_group, server_id
     :rtype: server_connect:dict, server_group:dict, server_id:str
     """
@@ -315,9 +341,10 @@ def connect_server(tester):
                                    ['test_server_credentials'][0]
                                    ['test_db_password']),
                                follow_redirects=True)
-        server_connect_detail = json.loads(response.data.decode())
-        connect_database(tester, server_connect_detail, server_id,
-                         server_group)
+        server_connect_detail = json.loads(response.data.decode('utf-8'))
+        if not add_db_flag:
+            connect_database(tester, server_connect_detail, server_id,
+                             server_group)
         server_connect.append(server_connect_detail)
         servers.append(server_id)
     return server_connect, server_group, servers
@@ -345,7 +372,7 @@ def connect_database(tester, server_connect, server_id, server_group):
             DATABASE_URL + str(server_group) + "/" + server_id + "/",
             data=json.dumps(db_data),
             content_type='html/json')
-        response_data = json.loads(db_response.data.decode())
+        response_data = json.loads(db_response.data.decode('utf-8'))
         write_db_parent_id(response_data)
 
 
@@ -366,7 +393,7 @@ def delete_server(tester):
     for server_id in server_ids:
         response = tester.delete(url + str(server_id))
         assert response.status_code == 200
-        response_data = json.loads(response.data.decode())
+        response_data = json.loads(response.data.decode('utf-8'))
         assert response_data['success'] == 1
 
 
@@ -395,3 +422,309 @@ def delete_database(tester):
         assert response.status_code == 200
         response_data = json.loads(response.data.decode('utf-8'))
         assert response_data['success'] == 1
+
+
+# Roles utility
+def verify_role(tester, server_group, server_id, role_id):
+    """
+    This function calls the GET API for role to verify
+
+    :param tester: test client
+    :type tester: flask test client object
+    :param server_group: server group id
+    :type server_group: int
+    :param server_id: server id
+    :type server_id: str
+    :param role_id: role id
+    :type role_id: int
+    :return: dict/None
+    """
+
+    response = tester.post(
+        '{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id),
+        data=dict(password=config_data
+        ['test_server_credentials'][0]
+        ['test_db_password']),
+        follow_redirects=True)
+    srv_connect = json.loads(response.data.decode('utf-8'))
+    if srv_connect['data']['connected']:
+        response = tester.get(
+            '{0}{1}/{2}/{3}'.format(ROLE_URL, server_group, server_id,
+                                    role_id),
+            content_type='html/json')
+        temp_response = json.loads(response.data.decode('utf-8'))
+        return temp_response
+    else:
+        return None
+
+
+def test_getrole(tester):
+    if not tester:
+        return None
+
+    all_id = get_ids()
+
+    server_ids = all_id["sid"]
+    role_ids_dict = all_id["lrid"][0]
+    server_group = config_data['test_server_group']
+
+    role_response_data = []
+    for server_id in server_ids:
+        role_id = role_ids_dict[int(server_id)]
+        role_response_data.append(
+            verify_role(tester, server_group, server_id, role_id))
+    return role_response_data
+
+
+def get_role_data():
+    """This function returns the role data from config file"""
+
+    data = {
+        "rolcanlogin": advanced_config_data['test_lr_credentials']
+        ['test_can_login'],
+        "rolconnlimit": advanced_config_data['test_lr_credentials']
+        ['test_conn_limit'],
+        "rolcreaterole": advanced_config_data['test_lr_credentials']
+        ['test_create_role'],
+        "rolinherit": advanced_config_data['test_lr_credentials']
+        ['test_role_inherit'],
+        "rolmembership": advanced_config_data['test_lr_credentials']
+        ['test_role_membership'],
+        "rolname": str(uuid.uuid4())[1:8],
+        "rolpassword": advanced_config_data['test_lr_credentials']
+        ['test_lr_password'],
+        "rolvaliduntil": advanced_config_data['test_lr_credentials']
+        ['test_lr_validity'],
+        "seclabels": advanced_config_data['test_lr_credentials']
+        ['test_sec_lable'],
+        "variables": advanced_config_data['test_lr_credentials']
+        ['test_variable']
+    }
+    return data
+
+
+def add_role(tester, server_connect_response, server_group, server_ids):
+    """
+    This function is used to add the roles to server
+
+    :param tester: flask test client
+    :type tester: flask test client object
+    :param server_connect_response: server connect API response
+    :type server_connect_response: dict
+    :param server_group: server group
+    :type server_group: int
+    :param server_ids: list of server id
+    :type server_ids: list
+    :return: None
+    """
+
+    for server_connect, server_id in zip(server_connect_response,
+                                         server_ids):
+        if server_connect['data']['connected']:
+            data = get_role_data()
+            response = tester.post(ROLE_URL + str(server_group) + '/'
+                                   + server_id + '/', data=json.dumps(data),
+                                   content_type='html/json')
+            assert response.status_code == 200
+            response_data = json.loads(response.data.decode('utf-8'))
+            write_role_id(response_data)
+
+
+def write_role_id(response_data):
+    """
+
+    :param response_data:
+    :return:
+    """
+
+    lr_id = response_data['node']['_id']
+    server_id = response_data['node']['_pid']
+    pickle_id_dict = get_pickle_id_dict()
+    # TODO: modify logic to write in file / file exists or create new check
+    # old file
+    if os.path.isfile(pickle_path):
+        existing_server_id = open(pickle_path, 'rb')
+        tol_server_id = pickle.load(existing_server_id)
+        pickle_id_dict = tol_server_id
+    if 'lrid' in pickle_id_dict:
+        if pickle_id_dict['lrid']:
+            # Add the db_id as value in dict
+            pickle_id_dict["lrid"][0].update({server_id: lr_id})
+        else:
+            # Create new dict with server_id and db_id
+            pickle_id_dict["lrid"].append({server_id: lr_id})
+    db_output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, db_output)
+    db_output.close()
+
+
+def delete_role(tester):
+    """
+    This function use to delete the existing roles in the servers
+
+    :param tester: flask test client
+    :type tester: flask test object
+    :return: None
+    """
+
+    srv_grp = config_data['test_server_group']
+    all_id = get_ids()
+    server_ids = all_id["sid"]
+    role_ids_dict = all_id["lrid"][0]
+
+    for server_id in server_ids:
+        role_id = role_ids_dict[int(server_id)]
+        role_response = verify_role(tester, srv_grp, server_id,
+                                    role_id)
+        if len(role_response) == 0:
+            raise Exception("No roles(s) to delete!!!")
+        response = tester.delete(ROLE_URL + str(srv_grp) + '/' +
+                                 str(server_id) + '/' + str(role_id),
+                                 follow_redirects=True)
+        assert response.status_code == 200
+        delete_response_data = json.loads(response.data.decode('utf-8'))
+        assert delete_response_data['success'] == 1
+
+
+# Tablespace utility
+def get_tablespace_data(server_connect):
+    """This function returns the tablespace data from config file"""
+
+    adv_config_data = None
+    data = None
+    db_user = server_connect['data']['user']['name']
+
+    # Get the config data of appropriate db user
+    for config_test_data in advanced_config_data['test_tablespc_credentials']:
+        if db_user == config_test_data['test_spc_user']:
+            adv_config_data = config_test_data
+
+    if adv_config_data is not None:
+        data = {
+            "name": str(uuid.uuid4())[1:8],
+            "seclabels": adv_config_data["test_spc_seclable"],
+            "spcacl": adv_config_data["test_spc_acl"],
+            "spclocation": adv_config_data["test_spc_location"],
+            "spcoptions": adv_config_data["test_spc_opts"],
+            "spcuser": adv_config_data["test_spc_user"]
+        }
+    return data
+
+
+def write_tablespace_id(response_data):
+    """
+    This function write the table space id to parent_id.pkl
+
+    :param response_data: create table space API response data
+    :type response_data: dict
+    :return: None
+    """
+
+    table_space_id = response_data['node']['_id']
+    server_id = response_data['node']['_pid']
+    pickle_id_dict = get_pickle_id_dict()
+    if os.path.isfile(pickle_path):
+        existing_server_id = open(pickle_path, 'rb')
+        tol_server_id = pickle.load(existing_server_id)
+        pickle_id_dict = tol_server_id
+    if 'table_space_id' in pickle_id_dict:
+        if pickle_id_dict['table_space_id']:
+            # Add the db_id as value in dict
+            pickle_id_dict["table_space_id"][0].update(
+                {server_id: table_space_id})
+        else:
+            # Create new dict with server_id and db_id
+            pickle_id_dict["table_space_id"].append(
+                {server_id: table_space_id})
+    db_output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, db_output)
+    db_output.close()
+
+
+def add_table_space(tester, server_connect_response, server_group, server_ids):
+    """
+    This function is used to add the roles to server
+
+    :param tester: flask test client
+    :type tester: flask test client object
+    :param server_connect_response: server connect API response
+    :type server_connect_response: dict
+    :param server_group: server group
+    :type server_group: int
+    :param server_ids: list of server id
+    :type server_ids: list
+    :return: None
+    """
+
+    for server_connect, server_id in zip(server_connect_response,
+                                         server_ids):
+        if server_connect['data']['connected']:
+            data = get_tablespace_data(server_connect)
+            response = tester.post(TABLE_SPACE_URL + str(server_group) + '/'
+                                   + server_id + '/',
+                                   data=json.dumps(data),
+                                   content_type='html/json')
+            assert response.status_code == 200
+            response_data = json.loads(response.data.decode('utf-8'))
+            write_tablespace_id(response_data)
+
+
+def verify_table_space(tester, server_group, server_id, tablespace_id):
+    """
+    This function calls the GET API for role to verify
+
+    :param tester: test client
+    :type tester: flask test client object
+    :param server_group: server group id
+    :type server_group: int
+    :param server_id: server id
+    :type server_id: str
+    :param tablespace_id: table space id
+    :type tablespace_id: int
+    :return: dict/None
+    """
+
+    response = tester.post(
+        '{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id),
+        data=dict(password=config_data
+        ['test_server_credentials'][0]
+        ['test_db_password']),
+        follow_redirects=True)
+    srv_connect = json.loads(response.data.decode('utf-8'))
+    if srv_connect['data']['connected']:
+        response = tester.get(
+            '{0}{1}/{2}/{3}'.format(TABLE_SPACE_URL, server_group, server_id,
+                                    tablespace_id),
+            content_type='html/json')
+        temp_response = json.loads(response.data.decode('utf-8'))
+        return temp_response
+    else:
+        return None
+
+
+def delete_table_space(tester):
+    """
+    This function use to delete the existing tablespace in the servers
+
+    :param tester: flask test client
+    :type tester: flask test object
+    :return: None
+    """
+
+    srv_grp = config_data['test_server_group']
+    all_id = get_ids()
+    server_ids = all_id["sid"]
+    tablespace_ids_dict = all_id["table_space_id"][0]
+
+    for server_id in server_ids:
+        tablespace_id = tablespace_ids_dict[int(server_id)]
+        role_response = verify_table_space(tester, srv_grp, server_id,
+                                           tablespace_id)
+        if len(role_response) == 0:
+            raise Exception("No tablespace(s) to delete!!!")
+        response = tester.delete(TABLE_SPACE_URL + str(srv_grp) + '/' +
+                                 str(server_id) + '/' + str(tablespace_id),
+                                 follow_redirects=True)
+        assert response.status_code == 200
+        delete_response_data = json.loads(response.data.decode('utf-8'))
+        assert delete_response_data['success'] == 1
