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..490e7d9 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
@@ -7,10 +7,11 @@
 #
 # ##################################################################
 
-import json
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
 
 
 class DatabaseAddTestCase(BaseTestGenerator):
@@ -24,7 +25,8 @@ class DatabaseAddTestCase(BaseTestGenerator):
         ('Check Databases Node URL', dict(url='/browser/database/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function used to add the sever
 
@@ -32,27 +34,23 @@ class DatabaseAddTestCase(BaseTestGenerator):
         """
 
         # Add the server
-        utils.add_server(self.tester)
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
 
     def runTest(self):
         """ This function will add database under 1st server of tree node. """
 
-        server_connect_response, server_group, server_ids = \
-            utils.connect_server(self.tester)
-
-        for server_connect, server_id in zip(server_connect_response,
-                                             server_ids):
-            if server_connect['data']['connected']:
-                data = utils.get_db_data(server_connect)
-                db_response = self.tester.post(self.url + str(server_group) +
-                                               "/" + server_id + "/",
-                                               data=json.dumps(data),
-                                               content_type='html/json')
-                self.assertTrue(db_response.status_code, 200)
-                response_data = json.loads(db_response.data.decode('utf-8'))
-                utils.write_db_parent_id(response_data)
+        database_utils.add_database(self.tester, self.server_connect_response,
+                                    self.server_ids)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the added database, added server and the
         'parent_id.pkl' file which is created in setup()
@@ -60,6 +58,6 @@ class DatabaseAddTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_database(self.tester)
-        utils.delete_server(self.tester)
+        database_utils.delete_database(cls.tester)
+        server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py
index 6830b5a..756a689 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_delete.py
@@ -7,12 +7,10 @@
 #
 # ##################################################################
 
-import json
-
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from regression.test_setup import config_data
-from regression.test_utils import get_ids
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
 
 
 class DatabaseDeleteTestCase(BaseTestGenerator):
@@ -23,43 +21,38 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
         ('Check Databases Node URL', dict(url='/browser/database/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function perform the three tasks
          1. Add the test server
          2. Connect to server
+         3. Add the databases
 
         :return: None
         """
 
         # Firstly, add the server
-        utils.add_server(self.tester)
-        # Secondly, connect to server/database
-        utils.connect_server(self.tester)
+        server_utils.add_server(cls.tester)
 
-    def runTest(self):
-        """ This function will delete the database."""
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
 
-        srv_grp = config_data['test_server_group']
-        all_id = get_ids()
-        server_ids = all_id["sid"]
-        db_ids_dict = all_id["did"][0]
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
 
-        for server_id in server_ids:
-            db_id = db_ids_dict[int(server_id)]
-            db_con = utils.verify_database(self.tester, srv_grp, server_id,
-                                           db_id)
-            if len(db_con) == 0:
-                raise Exception("No database(s) to delete for server id %s"
-                                % server_id)
-            response = self.tester.delete(self.url + str(srv_grp) + '/' +
-                                          str(server_id) + '/' + str(db_id),
-                                          follow_redirects=True)
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+
+    def runTest(self):
+        """ This function will delete the database."""
 
-            response_data = json.loads(response.data.decode('utf-8'))
-            self.assertTrue(response_data['success'], 1)
+        database_utils.delete_database(self.tester)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the added server and the 'parent_id.pkl' file
         which is created in setup() function.
@@ -67,5 +60,5 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_server(self.tester)
+        server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py
index 7350f72..739dff8 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_get.py
@@ -11,6 +11,8 @@ from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
 from regression.test_setup import config_data
 from regression.test_utils import get_ids
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
 
 
 class DatabasesGetTestCase(BaseTestGenerator):
@@ -20,22 +22,33 @@ class DatabasesGetTestCase(BaseTestGenerator):
 
     scenarios = [
         # Fetching default URL for database node.
-        ('Check Databases Node URL', dict(url='/browser/database/obj/'))
+        ('Check Dat abases Node URL', dict(url='/browser/database/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function perform the three tasks
          1. Add the test server
          2. Connect to server
+         3. Add the databases
 
         :return: None
         """
 
         # Firstly, add the server
-        utils.add_server(self.tester)
-        # Secondly, connect to server/database
-        utils.connect_server(self.tester)
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
 
     def runTest(self):
         """ This function will fetch added database. """
@@ -44,19 +57,21 @@ class DatabasesGetTestCase(BaseTestGenerator):
         server_ids = all_id["sid"]
 
         db_ids_dict = all_id["did"][0]
-        srv_grp = config_data['test_server_group']
+        srv_grp = config_data['server_group']
 
         for server_id in server_ids:
             db_id = db_ids_dict[int(server_id)]
-            db_con = utils.verify_database(self.tester, srv_grp, server_id,
-                                           db_id)
+            db_con = database_utils.verify_database(self.tester, srv_grp,
+                                                    server_id,
+                                                    db_id)
             if db_con["info"] == "Database connected.":
                 response = self.tester.get(
                     self.url + str(srv_grp) + '/' + str(server_id) + '/' +
                     str(db_id), follow_redirects=True)
                 self.assertEquals(response.status_code, 200)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the added database, added server
         and the 'parent_id.pkl' file which is created in setup() function.
@@ -64,6 +79,6 @@ class DatabasesGetTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_database(self.tester)
-        utils.delete_server(self.tester)
+        database_utils.delete_database(cls.tester)
+        server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
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..c32e3ca 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
@@ -11,8 +11,10 @@ import json
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from regression.test_setup import config_data, advanced_config_data
+from regression.test_setup import advanced_config_data
 from regression.test_utils import get_ids
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as database_utils
 
 
 class DatabasesUpdateTestCase(BaseTestGenerator):
@@ -25,44 +27,58 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
         ('Check Databases Node', dict(url='/browser/database/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function perform the three tasks
          1. Add the test server
          2. Connect to server
+         3. Add the databases
 
         :return: None
         """
 
         # Firstly, add the server
-        utils.add_server(self.tester)
-        # Secondly, connect to server/database
-        utils.connect_server(self.tester)
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the database!!!")
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
 
     def runTest(self):
         """ This function will update the comments field of database."""
 
-        srv_grp = config_data['test_server_group']
         all_id = get_ids()
         server_ids = all_id["sid"]
         db_ids_dict = all_id["did"][0]
 
         for server_id in server_ids:
             db_id = db_ids_dict[int(server_id)]
-            db_con = utils.verify_database(self.tester, srv_grp, server_id,
-                                           db_id)
+            db_con = database_utils.verify_database(self.tester,
+                                                    utils.SERVER_GROUP,
+                                                    server_id,
+                                                    db_id)
             if db_con["info"] == "Database connected.":
                 data = {
-                    "comments": advanced_config_data["test_db_update_data"][0]
-                    ["test_comment"],
+                    "comments": advanced_config_data["db_update_data"][0]
+                    ["comment"],
                     "id": db_id
                 }
                 put_response = self.tester.put(
-                    self.url + str(srv_grp) + '/' + str(server_id) + '/' +
+                    self.url + str(utils.SERVER_GROUP) + '/' + str(
+                        server_id) + '/' +
                     str(db_id), data=json.dumps(data), follow_redirects=True)
                 self.assertEquals(put_response.status_code, 200)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(self):
         """
         This function deletes the added server and 'parent_id.pkl' file
         which is created in setup() function.
@@ -70,5 +86,6 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_server(self.tester)
+        database_utils.delete_database(self.tester)
+        server_utils.delete_server(self.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
new file mode 100644
index 0000000..fcffaf4
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
@@ -0,0 +1,176 @@
+# ##########################################################################
+#
+# #pgAdmin 4 - PostgreSQL Tools
+#
+# #Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# #This software is released under the PostgreSQL Licence
+#
+# ##########################################################################
+
+import json
+import os
+import pickle
+import uuid
+
+from regression.test_setup import pickle_path, config_data, advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+
+DATABASE_URL = '/browser/database/obj/'
+DATABASE_CONNECT_URL = 'browser/database/connect/'
+
+
+def get_db_data(server_connect_data):
+    """
+    This function is used to get advance config test data for appropriate
+    server
+
+    :param server_connect_data: list of server details
+    :return data: database details
+    :rtype: dict
+    """
+
+    adv_config_data = None
+    data = None
+    db_user = server_connect_data['data']['user']['name']
+
+    # Get the config data of appropriate db user
+    for config_test_data in advanced_config_data['add_database_data']:
+        if db_user == config_test_data['owner']:
+            adv_config_data = config_test_data
+
+    if adv_config_data is not None:
+        data = {
+            "datacl": adv_config_data['privileges_acl'],
+            "datconnlimit": adv_config_data['conn_limit'],
+            "datowner": adv_config_data['owner'],
+            "deffuncacl": adv_config_data['fun_acl'],
+            "defseqacl": adv_config_data['seq_acl'],
+            "deftblacl": adv_config_data['tbl_acl'],
+            "deftypeacl": adv_config_data['type_acl'],
+            "encoding": adv_config_data['encoding'],
+            "name": str(uuid.uuid4())[1:8],
+            "privileges": adv_config_data['privileges'],
+            "securities": adv_config_data['securities'],
+            "variables": adv_config_data['variables']
+        }
+    return data
+
+
+def write_db_id(response_data):
+    """
+    This function writes the server and database related data like server
+    name, server id , database name, database id etc.
+
+    :param response_data: server and databases details
+    :type response_data: dict
+    :return: None
+    """
+
+    db_id = response_data['node']['_id']
+    server_id = response_data['node']['_pid']
+    pickle_id_dict = utils.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()
+
+
+def add_database(tester, server_connect_response, server_ids):
+    """
+    This function add the database into servers
+
+    :param tester: flask test client
+    :type tester: flask test object
+    :param server_connect_response: server response
+    :type server_connect_response: dict
+    :param server_ids: server ids
+    :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_db_data(server_connect)
+            db_response = tester.post(DATABASE_URL + str(utils.SERVER_GROUP) +
+                                           "/" + server_id + "/",
+                                           data=json.dumps(data),
+                                           content_type='html/json')
+            assert db_response.status_code == 200
+            response_data = json.loads(db_response.data.decode('utf-8'))
+            write_db_id(response_data)
+
+
+def verify_database(tester, server_group, server_id, db_id):
+    """
+    This function verifies that database is exists and whether it connect
+    successfully or not
+
+    :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 db_id: database id
+    :type db_id: str
+    :return: temp_db_con
+    :rtype: list
+    """
+
+    # Verify servers
+    server_utils.verify_server(tester,server_group,server_id)
+
+    # Connect to database
+    con_response = tester.post('{0}{1}/{2}/{3}'.format(
+        DATABASE_CONNECT_URL, server_group, server_id, db_id),
+        follow_redirects=True)
+    temp_db_con = json.loads(con_response.data.decode('utf-8'))
+
+    return temp_db_con
+
+
+def delete_database(tester):
+    """
+    This function used to delete the added databases
+
+    :param tester: test client object
+    :return: None
+    """
+
+    server_ids = None
+    db_ids_dict = None
+
+    all_id = utils.get_ids()
+    if "sid" and "did" in all_id.keys():
+        server_ids = all_id["sid"]
+        if all_id['did']:
+            db_ids_dict = all_id['did'][0]
+    else:
+        raise Exception("Keys are not found in pickle dict: {}".format(["sid", "did"]))
+
+    if server_ids and db_ids_dict is not None:
+        for server_id in server_ids:
+            server_response = server_utils.verify_server(tester, utils.SERVER_GROUP, server_id)
+            if server_response["data"]["connected"]:
+                db_id = db_ids_dict[int(server_id)]
+                response = tester.delete(DATABASE_URL + str(utils.SERVER_GROUP) + '/' +
+                                         str(server_id) + '/' + str(db_id),
+                                         follow_redirects=True)
+                assert response.status_code == 200
+                response_data = json.loads(response.data.decode('utf-8'))
+                assert response_data['success'] == 1
+    else:
+        raise Exception("No servers/databases found.")
+
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..9d8f949
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py
@@ -0,0 +1,55 @@
+# #################################################################
+#
+# 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
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as roles_utils
+
+
+class LoginRoleAddTestCase(BaseTestGenerator):
+    """This class has add role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the roles!!!")
+
+    def runTest(self):
+        """This function test the add role scenario"""
+
+        roles_utils.add_role(self.tester, self.server_connect_response,
+                             self.server_group, self.server_ids)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the role,server and parent id file"""
+
+        roles_utils.delete_role(cls.tester)
+        server_utils.delete_server(cls.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..f3204cd
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py
@@ -0,0 +1,58 @@
+# #################################################################
+#
+# 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
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as roles_utils
+
+
+class LoginRoleDeleteTestCase(BaseTestGenerator):
+    """This class has delete role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever and roles
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the roles!!!")
+
+        # Add the role
+        roles_utils.add_role(cls.tester, cls.server_connect_response,
+                             cls.server_group, cls.server_ids)
+
+    def runTest(self):
+        """This function tests the delete role scenario"""
+
+        roles_utils.delete_role(self.tester)
+
+    @classmethod
+    def tearDownClass(self):
+        """This function deletes the role,server and parent id file"""
+
+        server_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..4187fca
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py
@@ -0,0 +1,67 @@
+# #################################################################
+#
+# 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
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as roles_utils
+
+
+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/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever and roles
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to get the roles!!!")
+
+        # Add the role
+        roles_utils.add_role(cls.tester, cls.server_connect_response,
+                             cls.server_group, cls.server_ids)
+
+    def runTest(self):
+        """This function test the get role scenario"""
+
+        all_id = utils.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(utils.SERVER_GROUP) + '/' +
+                str(server_id) + '/' + str(role_id),
+                follow_redirects=True)
+            self.assertEquals(response.status_code, 200)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the role,server and parent id file"""
+
+        roles_utils.delete_role(cls.tester)
+        server_utils.delete_server(cls.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..f8c353e
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py
@@ -0,0 +1,84 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression.test_setup import advanced_config_data
+from . import utils as roles_utils
+
+
+class LoginRolePutTestCase(BaseTestGenerator):
+    """This class has update role scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Role Node', dict(url='/browser/role/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever and roles
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to get the roles!!!")
+
+        # Add the role
+        roles_utils.add_role(cls.tester, cls.server_connect_response,
+                             cls.server_group, cls.server_ids)
+
+    def runTest(self):
+        """This function tests the update role data scenario"""
+
+        all_id = utils.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 = roles_utils.verify_role(self.tester,
+                                                    utils.SERVER_GROUP,
+                                                    server_id,
+                                                    role_id)
+            if len(role_response) == 0:
+                raise Exception("No roles(s) to update!!!")
+
+            data = {
+                "description": advanced_config_data["lr_update_data"]
+                ["comment"],
+                "lrid": role_id
+            }
+            put_response = self.tester.put(
+                self.url + str(utils.SERVER_GROUP) + '/' +
+                str(server_id) + '/' + str(role_id),
+                data=json.dumps(data),
+                follow_redirects=True)
+
+            self.assertEquals(put_response.status_code, 200)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the role,server and parent id file"""
+
+        roles_utils.delete_role(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/utils.py b/web/pgadmin/browser/server_groups/servers/roles/tests/utils.py
new file mode 100644
index 0000000..85e0990
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/roles/tests/utils.py
@@ -0,0 +1,187 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+import os
+import pickle
+import uuid
+
+from regression.test_setup import pickle_path, config_data, advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+
+ROLE_URL = '/browser/role/obj/'
+
+
+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
+    """
+
+    srv_connect = server_utils.verify_server(tester, server_group, server_id)
+    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 = utils.get_ids()
+
+    server_ids = all_id["sid"]
+    role_ids_dict = all_id["lrid"][0]
+    server_group = config_data['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['lr_credentials']
+        ['can_login'],
+        "rolconnlimit": advanced_config_data['lr_credentials']
+        ['conn_limit'],
+        "rolcreaterole": advanced_config_data['lr_credentials']
+        ['create_role'],
+        "rolinherit": advanced_config_data['lr_credentials']
+        ['role_inherit'],
+        "rolmembership": advanced_config_data['lr_credentials']
+        ['role_membership'],
+        "rolname": str(uuid.uuid4())[1:8],
+        "rolpassword": advanced_config_data['lr_credentials']
+        ['lr_password'],
+        "rolvaliduntil": advanced_config_data['lr_credentials']
+        ['lr_validity'],
+        "seclabels": advanced_config_data['lr_credentials']
+        ['sec_lable'],
+        "variables": advanced_config_data['lr_credentials']
+        ['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 = utils.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
+    """
+
+    server_ids = None
+    role_ids_dict = None
+
+    all_id = utils.get_ids()
+    if "sid" and "lrid" in all_id.keys():
+        server_ids = all_id["sid"]
+        if all_id['lrid']:
+            role_ids_dict = all_id['lrid'][0]
+    else:
+        raise Exception("Keys are not found: {}".format(["sid", "lrid"]))
+
+    if server_ids and role_ids_dict is not None:
+        for server_id in server_ids:
+            server_response = server_utils.verify_server(tester,
+                                                         utils.SERVER_GROUP,
+                                                         server_id)
+            if server_response["data"]["connected"]:
+                role_id = role_ids_dict[int(server_id)]
+                response = tester.delete(
+                    ROLE_URL + str(utils.SERVER_GROUP) + '/' +
+                    str(server_id) + '/' + str(role_id),
+                    follow_redirects=True)
+                assert response.status_code == 200
+                response_data = json.loads(response.data.decode('utf-8'))
+                assert response_data['success'] == 1
+    else:
+        raise Exception("No servers/roles found.")
+
+
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..caa6966
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py
@@ -0,0 +1,55 @@
+# #################################################################
+#
+# 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
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as tablespace_utils
+
+
+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/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the roles!!!")
+
+    def runTest(self):
+        """This function test the add tablespace scenario"""
+
+        tablespace_status = tablespace_utils.add_table_space(
+            self.tester, self.server_connect_response, self.server_group,
+            self.server_ids)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the tablespaces,server and parent_id file"""
+
+        tablespace_utils.delete_table_space(cls.tester)
+        server_utils.delete_server(cls.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..f280ee6
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py
@@ -0,0 +1,58 @@
+# #################################################################
+#
+# 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
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as tablespace_utils
+
+
+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/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the roles!!!")
+
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+    def runTest(self):
+        """This function tests the delete table space scenario"""
+
+        tablespace_utils.delete_table_space(self.tester)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the server and parent id file"""
+
+        server_utils.delete_server(cls.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..b26d71d
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py
@@ -0,0 +1,78 @@
+# #################################################################
+#
+# 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
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from . import utils as tablespace_utils
+
+
+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/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the roles!!!")
+
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+    def runTest(self):
+        """This function test the get table space scenario"""
+
+        tablespace_ids_dict = None
+        all_id = utils.get_ids()
+        server_ids = all_id["sid"]
+        if "tsid" in all_id and all_id["tsid"]:
+            tablespace_ids_dict = all_id["tsid"][0]
+
+        if tablespace_ids_dict:
+            for server_id in server_ids:
+                tablespace_id = tablespace_ids_dict[int(server_id)]
+                server_response = server_utils.verify_server(self.tester,
+                                                             utils.SERVER_GROUP,
+                                                             server_id)
+                if server_response['data']['connected']:
+                    tablespace_utils.verify_table_space(
+                        self.tester, utils.SERVER_GROUP, server_id, tablespace_id)
+                    response = self.tester.get(
+                        self.url + str(utils.SERVER_GROUP) + '/' +
+                        str(server_id) + '/' + str(
+                            tablespace_id),
+                        follow_redirects=True)
+                    self.assertEquals(response.status_code, 200)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the tablespaces,server and parent id file"""
+
+        tablespace_utils.delete_table_space(cls.tester)
+        server_utils.delete_server(cls.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..22257f9
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py
@@ -0,0 +1,90 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils as utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from test_setup import advanced_config_data
+from . import utils as tablespace_utils
+
+
+class TableSpaceUpdateTestCase(BaseTestGenerator):
+    """This class has update tablespace scenario"""
+
+    scenarios = [
+        # Fetching default URL for roles node.
+        ('Check Tablespace Node', dict(url='/browser/tablespace/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function used to add the sever
+
+        :return: None
+        """
+
+        # Add the server
+        server_utils.add_server(cls.tester)
+
+        # Connect to server
+        cls.server_connect_response, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect_response) == 0:
+            raise Exception("No Server(s) connected to add the roles!!!")
+
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+    def runTest(self):
+        """This function tests the update tablespace data scenario"""
+
+        tablespace_ids_dict = None
+        all_id = utils.get_ids()
+        server_ids = all_id["sid"]
+        if "tsid" in all_id and all_id["tsid"]:
+            tablespace_ids_dict = all_id["tsid"][0]
+
+        if tablespace_ids_dict:
+            for server_id in server_ids:
+                tablespace_id = tablespace_ids_dict[int(server_id)]
+                tablespace_response = tablespace_utils.verify_table_space(
+                    self.tester,
+                    utils.SERVER_GROUP, server_id,
+                    tablespace_id)
+                if len(tablespace_response) == 0:
+                    raise Exception("No tablespace(s) to update!!!")
+
+                data = {
+                    "description": advanced_config_data["tbspc_update_data"]
+                    ["comment"],
+                    "table_space_id": tablespace_id
+                }
+
+                put_response = self.tester.put(
+                    self.url + str(utils.SERVER_GROUP) + '/' +
+                    str(server_id) + '/' + str(
+                        tablespace_id),
+                    data=json.dumps(data),
+                    follow_redirects=True)
+
+                self.assertEquals(put_response.status_code, 200)
+
+    @classmethod
+    def tearDownClass(cls):
+        """This function deletes the tablespaces,server and parent id file"""
+
+        tablespace_utils.delete_table_space(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
new file mode 100644
index 0000000..e871e60
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
@@ -0,0 +1,195 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from __future__ import print_function
+
+import json
+import os
+import pickle
+import uuid
+import sys
+
+from regression.test_setup import pickle_path, config_data, \
+    advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+TABLE_SPACE_URL = '/browser/tablespace/obj/'
+
+
+# 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']
+    server_config_data = config_data['server_credentials']
+
+    # Get the config data of appropriate db user
+    for config_test_data in advanced_config_data['tablespc_credentials']:
+        if db_user == config_test_data['spc_user']:
+            # Add the tablespace path from server config
+            server_config = (item for item in server_config_data if
+                             item["db_username"] == db_user).next()
+            if "tablespace_path" in server_config:
+                config_test_data['spc_location'] = server_config['tablespace_path']
+                adv_config_data = config_test_data
+            else:
+                config_test_data['spc_location'] = None
+
+    if adv_config_data is not None:
+        data = {
+            "name": str(uuid.uuid4())[1:8],
+            "seclabels": adv_config_data["spc_seclable"],
+            "spcacl": adv_config_data["spc_acl"],
+            "spclocation": adv_config_data["spc_location"],
+            "spcoptions": adv_config_data["spc_opts"],
+            "spcuser": adv_config_data["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 = utils.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 'tsid' in pickle_id_dict:
+        if pickle_id_dict['tsid']:
+            # Add the db_id as value in dict
+            pickle_id_dict["tsid"][0].update(
+                {server_id: table_space_id})
+        else:
+            # Create new dict with server_id and db_id
+            pickle_id_dict["tsid"].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
+    """
+
+    total_servers_count = len(server_ids)
+    servers_without_tablespace_path = []
+
+    for server_connect, server_id in zip(server_connect_response,
+                                         server_ids):
+        tablespace_path = server_connect['tablespace_path']
+        # Skip the test case if tablespace_path does not exist
+        if not tablespace_path or tablespace_path is None:
+            file_name = os.path.basename(
+                sys._getframe().f_back.f_code.co_filename)
+            servers_without_tablespace_path.append(server_id)
+            if total_servers_count == len(servers_without_tablespace_path):
+                print("Skipping tablespaces test cases for the  file <{0}>, "
+                      "Tablespace path not found for any of the server : "
+                      "{1}".format(file_name, server_ids), file=sys.stderr)
+                return
+            else:
+                print("Skipping tablespaces test case for the file <{0}>: "
+                      "Tablespace path not found for server : {1}".format(
+                        file_name, server_id), file=sys.stderr)
+                continue
+
+        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
+    """
+
+    srv_connect = server_utils.verify_server(tester, server_group, server_id)
+    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')
+        assert response.status_code == 200
+        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
+    """
+
+    all_id = utils.get_ids()
+    server_ids = all_id["sid"]
+    if "tsid" in all_id and all_id["tsid"]:
+        tablespace_ids_dict = all_id["tsid"][0]
+    else:
+        tablespace_ids_dict = None
+
+    if tablespace_ids_dict is not None:
+        for server_id in server_ids:
+            tablespace_id = tablespace_ids_dict[int(server_id)]
+            role_response = verify_table_space(tester, utils.SERVER_GROUP,
+                                               server_id,
+                                               tablespace_id)
+            if len(role_response) == 0:
+                raise Exception("No tablespace(s) to delete!!!")
+            response = tester.delete(
+                TABLE_SPACE_URL + str(utils.SERVER_GROUP) + '/' +
+                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
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..7348a47 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
@@ -7,10 +7,9 @@
 #
 # ##########################################################################
 
-import json
-
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
+from . import utils as server_utils
 
 
 class ServersAddTestCase(BaseTestGenerator):
@@ -21,24 +20,17 @@ class ServersAddTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         pass
 
     def runTest(self):
         """ This function will add the server under default server group."""
 
-        server_group, config_data, pickle_id_dict = utils.get_config_data()
-        for server_data in config_data:
-            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())
-            utils.write_parent_id(response_data, pickle_id_dict)
+        server_utils.add_server(self.tester)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the added server and the 'parent_id.pkl' file
         which is created in setup() function.
@@ -46,5 +38,5 @@ class ServersAddTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_server(self.tester)
+        server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py
index 4fd207b..6431bec 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py
@@ -7,12 +7,11 @@
 #
 # ##################################################################
 
-import json
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from regression.test_setup import config_data
-from regression.test_utils import get_ids
+
+from . import utils as server_utils
 
 
 class ServerDeleteTestCase(BaseTestGenerator):
@@ -23,7 +22,8 @@ class ServerDeleteTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function is used to add the server
 
@@ -31,28 +31,16 @@ class ServerDeleteTestCase(BaseTestGenerator):
         """
 
         # Firstly, add the server
-        utils.add_server(self.tester)
+        server_utils.add_server(cls.tester)
 
     def runTest(self):
         """ This function will get all available servers under object browser
         and delete the last server using server id."""
 
-        srv_grp = config_data['test_server_group']
-        all_id = get_ids()
-        server_ids = all_id["sid"]
-
-        url = self.url + str(srv_grp) + "/"
-        if len(server_ids) == 0:
-            raise Exception("No server(s) to delete!!!")
-
-        # Call api to delete the servers
-        for server_id in server_ids:
-            response = self.tester.delete(url + str(server_id))
-            self.assertTrue(response.status_code, 200)
-            response_data = json.loads(response.data.decode())
-            self.assertTrue(response_data['success'], 1)
+        server_utils.delete_server(self.tester)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the 'parent_id.pkl' file which is created in
         setup() function.
diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py
index ea3c63f..e541247 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_get.py
@@ -9,8 +9,7 @@
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from regression.test_setup import config_data
-from regression.test_utils import get_ids
+from . import utils as server_utils
 
 
 class ServersGetTestCase(BaseTestGenerator):
@@ -24,28 +23,23 @@ class ServersGetTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function is used to add the server
 
         :return: None
         """
 
-        utils.add_server(self.tester)
+        server_utils.add_server(cls.tester)
 
     def runTest(self):
         """ This function will fetch the added servers to object browser. """
 
-        all_id = get_ids()
-        server_ids = all_id["sid"]
-        srv_grp = config_data['test_server_group']
+        server_utils.get_server(self.tester)
 
-        for server_id in server_ids:
-            url = "{0}{1}/{2}".format(self.url, srv_grp, server_id)
-            response = self.tester.get(url, content_type='html/json')
-            self.assertEquals(response.status_code, 200)
-
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the added server and the 'parent_id.pkl' file
         which is created in setup() function.
@@ -53,5 +47,5 @@ class ServersGetTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_server(self.tester)
+        server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
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..9ac6468 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
@@ -8,10 +8,9 @@
 # ##########################################################################
 
 import json
-
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from regression.test_setup import config_data
+from . import utils as server_utils
 
 
 class ServerUpdateTestCase(BaseTestGenerator):
@@ -22,7 +21,8 @@ class ServerUpdateTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         This function perform the four tasks
          1. Add the test server
@@ -33,13 +33,16 @@ class ServerUpdateTestCase(BaseTestGenerator):
         """
 
         # Firstly, add the server
-        utils.add_server(self.tester)
+        server_utils.add_server(cls.tester)
+
         # Get the server
-        utils.get_server(self.tester)
+        server_utils.get_server(cls.tester)
+
         # Connect to server
-        self.server_connect, self.server_group, self.server_ids = \
-            utils.connect_server(self.tester)
-        if len(self.server_connect) == 0:
+        cls.server_connect, cls.server_group, cls.server_ids = \
+            server_utils.connect_server(cls.tester)
+
+        if len(cls.server_connect) == 0:
             raise Exception("No Server(s) connected to update!!!")
 
     def runTest(self):
@@ -48,7 +51,8 @@ class ServerUpdateTestCase(BaseTestGenerator):
         for server_id in self.server_ids:
             data = {
                 "comment":
-                    config_data['test_server_update_data'][0]['test_comment'],
+                    server_utils.config_data['server_update_data'][0][
+                        'comment'],
                 "id": server_id
             }
             put_response = self.tester.put(
@@ -60,7 +64,8 @@ class ServerUpdateTestCase(BaseTestGenerator):
             response_data = json.loads(put_response.data.decode())
             self.assertTrue(response_data['success'], 1)
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         This function deletes the added server and the 'parent_id.pkl' file
         which is created in setup() function.
@@ -68,5 +73,5 @@ class ServerUpdateTestCase(BaseTestGenerator):
         :return: None
         """
 
-        utils.delete_server(self.tester)
+        server_utils.delete_server(cls.tester)
         utils.delete_parent_id_file()
diff --git a/web/pgadmin/browser/server_groups/servers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tests/utils.py
new file mode 100644
index 0000000..6e3f166
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/tests/utils.py
@@ -0,0 +1,160 @@
+# ##########################################################################
+#
+# #pgAdmin 4 - PostgreSQL Tools
+#
+# #Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# #This software is released under the PostgreSQL Licence
+#
+# ##########################################################################
+
+import json
+import os
+import pickle
+
+from regression import test_utils as utils
+from regression.test_setup import pickle_path, config_data
+
+SERVER_URL = '/browser/server/obj/'
+SERVER_CONNECT_URL = 'browser/server/connect/'
+
+
+def write_server_id(response_data, pickle_id_dict):
+    """
+    This function writes the server's details to file parent_id.pkl
+
+    :param response_data: server's data
+    :type response_data: list of dictionary
+    :param pickle_id_dict: contains ids of server,database,tables etc.
+    :type pickle_id_dict: dict
+    :return: None
+    """
+
+    server_id = response_data['node']['_id']
+    if os.path.isfile(pickle_path):
+        existed_server_id = open(pickle_path, 'rb')
+        pickle_id_dict = pickle.load(existed_server_id)
+
+    pickle_id_dict["sid"].append(str(server_id))
+    output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, output)
+    output.close()
+
+
+def add_server(tester):
+    """
+    This function add the server in the existing server group
+
+    :param tester: test object
+    :type tester: flask test object
+    :return:None
+    """
+
+    server_group, db_data, pickle_id_dict = utils.get_config_data()
+    url = "{0}{1}/".format(SERVER_URL, server_group)
+    for db_detail in db_data:
+        response = tester.post(url, data=json.dumps(db_detail),
+                               content_type='html/json')
+        assert response.status_code == 200
+        response_data = json.loads(response.data.decode('utf-8'))
+        write_server_id(response_data, pickle_id_dict)
+
+
+def get_server(tester):
+    """
+    This function gets the added serer details
+
+    :param tester: test client object
+    :type tester: flask test object
+    :return: response_data
+    :rtype: list
+    """
+
+    all_id = utils.get_ids()
+    server_ids = all_id["sid"]
+    for server_id in server_ids:
+        response = tester.get(SERVER_URL + str(utils.SERVER_GROUP) + '/' +
+                              str(server_id),
+                              follow_redirects=True)
+        assert response.status_code == 200
+
+
+def connect_server(tester):
+    """
+    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
+    """
+
+    server_connect = []
+    servers = []
+    server_config = None
+
+    srv_id = utils.get_ids()
+    server_ids = srv_id["sid"]
+
+    # Connect to all servers
+    for server_id in server_ids:
+        response = tester.post(SERVER_CONNECT_URL + str(utils.SERVER_GROUP) +
+                               '/' + server_id,
+                               data=dict(
+                                   password=config_data
+                                   ['server_credentials'][0]
+                                   ['db_password']),
+                               follow_redirects=True)
+        server_connect_detail = json.loads(response.data.decode('utf-8'))
+        db_user = server_connect_detail['data']['user']['name']
+        server_connect_detail['tablespace_path'] = None
+
+        # Get the server config of appropriate db user
+        for config in config_data['server_credentials']:
+            if db_user == config['db_username']:
+                server_config = config
+
+        if "tablespace_path" in server_config:
+            server_connect_detail['tablespace_path'] = \
+                server_config['tablespace_path']
+
+        server_connect.append(server_connect_detail)
+        servers.append(server_id)
+    return server_connect, utils.SERVER_GROUP, servers
+
+
+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
+        ['server_credentials'][0]
+        ['db_password']),
+        follow_redirects=True)
+    srv_connect = json.loads(response.data.decode('utf-8'))
+    return srv_connect
+
+
+def delete_server(tester):
+    """
+    This function used to delete the added servers
+
+    :param tester: test client object
+    :return: None
+    """
+
+    all_id = utils.get_ids()
+    server_ids = all_id["sid"]
+    url = SERVER_URL + str(utils.SERVER_GROUP) + "/"
+
+    if len(server_ids) == 0:
+        raise Exception("No server(s) to delete!!!")
+
+    # Call api to delete the servers
+    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('utf-8'))
+        assert response_data['success'] == 1
\ No newline at end of file
diff --git a/web/pgadmin/browser/server_groups/tests/test_sg_get.py b/web/pgadmin/browser/server_groups/tests/test_sg_get.py
index 6c164be..5df67c9 100644
--- a/web/pgadmin/browser/server_groups/tests/test_sg_get.py
+++ b/web/pgadmin/browser/server_groups/tests/test_sg_get.py
@@ -26,7 +26,7 @@ class SgNodeTestCase(BaseTestGenerator):
     def runTest(self):
         """This function will check available server groups."""
 
-        server_group_id = config_data['test_server_group']
+        server_group_id = config_data['server_group']
         response = self.tester.get(self.url + str(server_group_id),
                                    content_type='html/json')
         self.assertTrue(response.status_code, 200)
diff --git a/web/pgadmin/browser/tests/test_change_password.py b/web/pgadmin/browser/tests/test_change_password.py
index 2f714a7..5b7c918 100644
--- a/web/pgadmin/browser/tests/test_change_password.py
+++ b/web/pgadmin/browser/tests/test_change_password.py
@@ -8,9 +8,12 @@
 # ##########################################################################
 
 import uuid
+import json
 
 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):
@@ -24,9 +27,9 @@ class ChangePasswordTestCase(BaseTestGenerator):
         # This testcase validates invalid confirmation password
         ('TestCase for Validating Incorrect_New_Password', dict(
             password=(config_data['pgAdmin4_login_credentials']
-                      ['test_login_password']),
+                      ['login_password']),
             new_password=(config_data['pgAdmin4_login_credentials']
-                          ['test_new_password']),
+                          ['new_password']),
             new_password_confirm=str(uuid.uuid4())[4:8],
             respdata='Passwords do not match')),
 
@@ -34,7 +37,7 @@ class ChangePasswordTestCase(BaseTestGenerator):
         # minimum length
         ('TestCase for Validating New_Password_Less_Than_Min_Length',
          dict(password=(config_data['pgAdmin4_login_credentials']
-                        ['test_login_password']),
+                        ['login_password']),
               new_password=str(uuid.uuid4())[4:8],
               new_password_confirm=str(uuid.uuid4())[4:8],
               respdata='Password must be at least 6 characters')),
@@ -42,7 +45,7 @@ class ChangePasswordTestCase(BaseTestGenerator):
         # This testcase validates if both password fields are left blank
         ('TestCase for Validating Empty_New_Password', dict(
             password=(config_data['pgAdmin4_login_credentials']
-                      ['test_login_password']),
+                      ['login_password']),
             new_password='', new_password_confirm='',
             respdata='Password not provided')),
 
@@ -50,57 +53,66 @@ class ChangePasswordTestCase(BaseTestGenerator):
         ('TestCase for Validating Incorrect_Current_Password', dict(
             password=str(uuid.uuid4())[4:8],
             new_password=(config_data['pgAdmin4_login_credentials']
-                          ['test_new_password']),
+                          ['new_password']),
             new_password_confirm=(
                 config_data['pgAdmin4_login_credentials']
-                ['test_new_password']),
+                ['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']
-                      ['test_login_password']),
-            new_password=(config_data['pgAdmin4_login_credentials']
-                          ['test_new_password']),
-            new_password_confirm=(
-                config_data['pgAdmin4_login_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']),
+            valid_password='reassigning_password',
+            username=(config_data['pgAdmin4_test_user_credentials']
+                      ['login_username']),
+            password=(config_data['pgAdmin4_test_user_credentials']
+                      ['login_password']),
+            new_password=(config_data['pgAdmin4_test_user_credentials']
+                          ['new_password']),
             new_password_confirm=(
-                config_data['pgAdmin4_login_credentials']
-                ['test_login_password']),
+                config_data['pgAdmin4_test_user_credentials']
+                ['new_password']),
             respdata='You successfully changed your password.'))
-
     ]
 
+    @classmethod
+    def setUpClass(cls):
+        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)
+            user_id = json.loads(response.data.decode('utf-8'))['id']
+
+            # 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/' + str(user_id),
+                follow_redirects=True)
+            assert response.status_code == 200
+        else:
+            change_password(self)
+
+    @classmethod
+    def tearDownClass(cls):
+        utils.login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/test_login.py b/web/pgadmin/browser/tests/test_login.py
index b0ea361..f6bc6b5 100644
--- a/web/pgadmin/browser/tests/test_login.py
+++ b/web/pgadmin/browser/tests/test_login.py
@@ -24,20 +24,20 @@ class LoginTestCase(BaseTestGenerator):
         # This test case validates the invalid/incorrect password
         ('TestCase for Checking Invalid_Password', dict(
             email=(config_data['pgAdmin4_login_credentials']
-                   ['test_login_username']),
+                   ['login_username']),
             password=str(uuid.uuid4())[4:8],
             respdata='Invalid password')),
 
         # This test case validates the empty password field
         ('Empty_Password', dict(
             email=(config_data['pgAdmin4_login_credentials']
-                   ['test_login_username']), password='',
+                   ['login_username']), password='',
             respdata='Password not provided')),
 
         # This test case validates blank email field
         ('Empty_Email', dict(
             email='', password=(config_data['pgAdmin4_login_credentials']
-                                ['test_login_password']),
+                                ['login_password']),
             respdata='Email not provided')),
 
         # This test case validates empty email and password
@@ -49,7 +49,7 @@ class LoginTestCase(BaseTestGenerator):
         ('Invalid_Email', dict(
             email=str(uuid.uuid4())[1:6] + '@xyz.com',
             password=(config_data['pgAdmin4_login_credentials']
-                      ['test_login_password']),
+                      ['login_password']),
             respdata='Specified user does not exist')),
 
         # This test case validates invalid email and password
@@ -62,21 +62,22 @@ class LoginTestCase(BaseTestGenerator):
         # to login pgAdmin 4
         ('Valid_Credentials', dict(
             email=(config_data['pgAdmin4_login_credentials']
-                   ['test_login_username']),
+                   ['login_username']),
             password=(config_data['pgAdmin4_login_credentials']
-                      ['test_login_password']),
+                      ['login_password']),
             respdata='Gravatar image for %s' %
                      config_data['pgAdmin4_login_credentials']
-                     ['test_login_username']))
+                     ['login_username']))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         """
         We need to logout the test client as we are testing scenarios of
         logging in the client like invalid password, invalid emails,
         empty credentials etc.
         """
-        utils.logout_tester_account(self.tester)
+        utils.logout_tester_account(cls.tester)
 
     def runTest(self):
         """This function checks login functionality."""
@@ -86,9 +87,10 @@ class LoginTestCase(BaseTestGenerator):
                                     follow_redirects=True)
         self.assertIn(self.respdata, response.data.decode('utf8'))
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         We need to again login the test client as soon as test scenarios
         finishes.
         """
-        utils.login_tester_account(self.tester)
+        utils.login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/test_logout.py b/web/pgadmin/browser/tests/test_logout.py
index 729f7b1..5697de6 100644
--- a/web/pgadmin/browser/tests/test_logout.py
+++ b/web/pgadmin/browser/tests/test_logout.py
@@ -24,7 +24,8 @@ class LogoutTest(BaseTestGenerator):
         ('Logging Out', dict(respdata='Redirecting...'))
     ]
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         pass
 
     def runTest(self):
@@ -33,9 +34,10 @@ class LogoutTest(BaseTestGenerator):
         response = self.tester.get('/logout')
         self.assertIn(self.respdata, response.data.decode('utf8'))
 
-    def tearDown(self):
+    @classmethod
+    def tearDownClass(cls):
         """
         We need to again login the test client as soon as test scenarios
         finishes.
         """
-        utils.login_tester_account(self.tester)
+        utils.login_tester_account(cls.tester)
diff --git a/web/pgadmin/browser/tests/test_reset_password.py b/web/pgadmin/browser/tests/test_reset_password.py
index 9420c72..0dcf0bd 100644
--- a/web/pgadmin/browser/tests/test_reset_password.py
+++ b/web/pgadmin/browser/tests/test_reset_password.py
@@ -34,11 +34,12 @@ class ResetPasswordTestCase(BaseTestGenerator):
         # This test case validates the valid email id
         ('TestCase for Validating Valid_Email', dict(
             email=config_data['pgAdmin4_login_credentials']
-            ['test_login_username'], respdata='pgAdmin 4'))
+            ['login_username'], respdata='pgAdmin 4'))
     ]
 
-    def setUp(self):
-        logout_tester_account(self.tester)
+    @classmethod
+    def setUpClass(cls):
+        logout_tester_account(cls.tester)
 
     def runTest(self):
         """This function checks reset password functionality."""
@@ -51,5 +52,6 @@ class ResetPasswordTestCase(BaseTestGenerator):
             follow_redirects=True)
         self.assertIn(self.respdata, response.data.decode('utf-8'))
 
-    def tearDown(self):
-        login_tester_account(self.tester)
+    @classmethod
+    def tearDownClass(cls):
+        login_tester_account(cls.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/pgadmin/utils/route.py b/web/pgadmin/utils/route.py
index c7ef1f8..0226e8d 100644
--- a/web/pgadmin/utils/route.py
+++ b/web/pgadmin/utils/route.py
@@ -84,5 +84,6 @@ class BaseTestGenerator(unittest.TestCase):
         self.app = app
 
     # Initializing test_client.
-    def setTestClient(self, test_client):
-        self.tester = test_client
+    @classmethod
+    def setTestClient(cls, test_client):
+        cls.tester = test_client
diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in
index c0d278b..fc8d98f 100644
--- a/web/regression/test_advanced_config.json.in
+++ b/web/regression/test_advanced_config.json.in
@@ -1,7 +1,7 @@
 {
-  "test_add_database_data": [
+  "add_database_data": [
    {
-    "test_privileges_acl": [
+    "privileges_acl": [
       {
         "grantee": "postgres",
         "grantor": "postgres",
@@ -19,9 +19,9 @@
         ]
       }
     ],
-    "test_conn_limit": -1,
-    "test_owner": "postgres",
-    "test_fun_acl": [
+    "conn_limit": -1,
+    "owner": "postgres",
+    "fun_acl": [
       {
         "grantee": "postgres",
         "grantor": "postgres",
@@ -34,7 +34,7 @@
         ]
       }
     ],
-    "test_seq_acl": [
+    "seq_acl": [
       {
         "grantee": "postgres",
         "grantor": "postgres",
@@ -57,7 +57,7 @@
         ]
       }
     ],
-    "test_tbl_acl": [
+    "tbl_acl": [
       {
         "grantee": "postgres",
         "grantor": "postgres",
@@ -75,7 +75,7 @@
         ]
       }
     ],
-    "test_type_acl": [
+    "type_acl": [
       {
         "grantee": "postgres",
         "grantor": "postgres",
@@ -88,112 +88,60 @@
         ]
       }
     ],
-    "test_encoding": "UTF8",
-    "test_name": "test_db_automation",
-    "test_privileges": [],
-    "test_securities": [],
-    "test_variables": []
-  },
-       {
-         "test_privileges_acl": [
-           {
-             "grantee": "enterprisedb",
-             "grantor": "enterprisedb",
-             "privileges": [
-               {
-                 "privilege_type": "C",
-                 "privilege": true,
-                 "with_grant": true
-               },
-               {
-                 "privilege_type": "T",
-                 "privilege": true,
-                 "with_grant": false
-               }
-             ]
-           }
-         ],
-         "test_conn_limit": -1,
-         "test_owner": "enterprisedb",
-         "test_fun_acl": [
-           {
-             "grantee": "enterprisedb",
-             "grantor": "enterprisedb",
-             "privileges": [
-               {
-                 "privilege_type": "X",
-                 "privilege": true,
-                 "with_grant": false
-               }
-             ]
-           }
-         ],
-         "test_seq_acl": [
-           {
-             "grantee": "enterprisedb",
-             "grantor": "enterprisedb",
-             "privileges": [
-               {
-                 "privilege_type": "r",
-                 "privilege": true,
-                 "with_grant": false
-               },
-               {
-                 "privilege_type": "w",
-                 "privilege": true,
-                 "with_grant": false
-               },
-               {
-                 "privilege_type": "U",
-                 "privilege": true,
-                 "with_grant": false
-               }
-             ]
-           }
-         ],
-         "test_tbl_acl": [
-           {
-             "grantee": "enterprisedb",
-             "grantor": "enterprisedb",
-             "privileges": [
-               {
-                 "privilege_type": "a",
-                 "privilege": true,
-                 "with_grant": true
-               },
-               {
-                 "privilege_type": "r",
-                 "privilege": true,
-                 "with_grant": false
-               }
-             ]
-           }
-         ],
-         "test_type_acl": [
-           {
-             "grantee": "enterprisedb",
-             "grantor": "enterprisedb",
-             "privileges": [
-               {
-                 "privilege_type": "U",
-                 "privilege": true,
-                 "with_grant": false
-               }
-             ]
-           }
-         ],
-         "test_encoding": "UTF8",
-         "test_name": "test_db_automation",
-         "test_privileges": [],
-         "test_securities": [],
-         "test_variables": []
-       }
+    "encoding": "UTF8",
+    "name": "test_db_automation",
+    "privileges": [],
+    "securities": [],
+    "variables": []
+  }
  ],
-
-  "test_db_update_data": [
+  "db_update_data": [
   {
-      "test_comment": "This is db update comment"
+      "comment": "This is db update comment"
   }
- ]
+ ],
+
+  "lr_credentials": {
+      "can_login": "true",
+      "conn_limit": -1,
+      "create_role": "true",
+      "role_inherit": "true",
+      "role_membership": [],
+      "lr_name":  "testlrg1",
+      "lr_password": "edb",
+      "lr_validity": "12/27/2016",
+      "sec_lable": [],
+      "variable":[
+                        {"name":"work_mem",
+                          "database":"postgres",
+                          "value":65
+                        }]
+    },
+  "lr_update_data": {
+      "comment": "This is db update comment"
+  },
+
+  "tablespc_credentials":[{
+    "tblspace_name": "test_tablespace",
+    "spc_seclable": [],
+    "spc_acl": [
+      {
+        "grantee":"postgres",
+        "grantor":"postgres",
+        "privileges":[
+          {
+            "privilege_type":"C",
+            "privilege":true,
+            "with_grant":false
+          }
+        ]
+      }
+    ],
+    "spc_opts": [],
+    "spc_user": "postgres"
+  }],
 
+    "tbspc_update_data": {
+    "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..1328b6b 100644
--- a/web/regression/test_config.json.in
+++ b/web/regression/test_config.json.in
@@ -1,35 +1,31 @@
 {
   "pgAdmin4_login_credentials": {
-    "test_new_password": "NEWPASSWORD",
-    "test_login_password": "PASSWORD",
-    "test_login_username": "USER@EXAMPLE.COM"
+    "new_password": "NEWPASSWORD",
+    "login_password": "PASSWORD",
+    "login_username": "USER@EXAMPLE.COM"
   },
-  "test_server_group": 1,
-  "test_server_credentials": [
+  "pgAdmin4_test_user_credentials": {
+    "new_password": "NEWPASSWORD",
+    "login_password": "PASSWORD",
+    "login_username": "USER@EXAMPLE.COM"
+  },
+  "server_group": 1,
+  "server_credentials": [
     {
-      "test_name": "PostgreSQL 9.4",
-      "test_comment": "PostgreSQL 9.4 Server (EDB Installer)",
-      "test_db_username": "postgres",
-      "test_host": "localhost",
-      "test_db_password": "PASSWORD",
-      "test_db_port": 5432,
-      "test_maintenance_db": "postgres",
-      "test_sslmode": "prefer"
-    },
-     {
-       "test_name": "Postgres Plus Advanced Server 9.4",
-       "test_comment": "Postgres Plus Advanced 9.4 Server (EDB Installer)",
-       "test_db_username": "enterprisedb",
-       "test_host": "localhost",
-       "test_db_password": "edb",
-       "test_db_port": 5444,
-       "test_maintenance_db": "edb",
-       "test_sslmode": "prefer"
-     }
+      "name": "PostgreSQL 9.4",
+      "comment": "PostgreSQL 9.4 Server (EDB Installer)",
+      "db_username": "postgres",
+      "host": "localhost",
+      "db_password": "PASSWORD",
+      "db_port": 5432,
+      "maintenance_db": "postgres",
+      "sslmode": "prefer",
+      "tablespace_path": ""
+    }
   ],
-  "test_server_update_data": [
+  "server_update_data": [
     {
-      "test_comment": "This is test update comment"
+      "comment": "This is test update comment"
     }
   ]
 }
\ No newline at end of file
diff --git a/web/regression/test_setup.py b/web/regression/test_setup.py
index f7765bc..c805b1e 100644
--- a/web/regression/test_setup.py
+++ b/web/regression/test_setup.py
@@ -12,10 +12,24 @@ import os
 
 CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
 
-with open(CURRENT_PATH + '/test_config.json') as data_file:
-    config_data = json.load(data_file)
+# with open(CURRENT_PATH + '/test_config.json') as data_file:
+#     config_data = json.load(data_file)
+#
+# with open(CURRENT_PATH + '/test_advanced_config.json') as data_file:
+#     advanced_config_data = json.load(data_file)
+
+try:
+    with open(CURRENT_PATH + '/test_config.json') as data_file:
+        config_data = json.load(data_file)
+except:
+    with open(CURRENT_PATH + '/test_config.json.in') as data_file:
+        config_data = json.load(data_file)
 
-with open(CURRENT_PATH + '/test_advanced_config.json') as data_file:
-    advanced_config_data = json.load(data_file)
+try:
+    with open(CURRENT_PATH + '/test_advanced_config.json') as data_file:
+        advanced_config_data = json.load(data_file)
+except:
+    with open(CURRENT_PATH + '/test_advanced_config.json.in') as data_file:
+        advanced_config_data = json.load(data_file)
 
 pickle_path = os.path.join(CURRENT_PATH, 'parent_id.pkl')
diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py
index 6be2bb2..16c2d46 100644
--- a/web/regression/test_utils.py
+++ b/web/regression/test_utils.py
@@ -9,16 +9,24 @@
 
 import os
 import pickle
-import json
-import uuid
 
-from test_setup import config_data, advanced_config_data, \
-    pickle_path
+from test_setup import config_data, pickle_path
 
-SERVER_URL = '/browser/server/obj/'
-SERVER_CONNECT_URL = 'browser/server/connect/'
-DATABASE_URL = '/browser/database/obj/'
-DATABASE_CONNECT_URL = 'browser/database/connect/'
+
+SERVER_GROUP = config_data['server_group']
+
+
+def get_pickle_id_dict():
+    """This function returns the empty dict of server config data"""
+
+    pickle_id_dict = {
+        "sid": [],  # server
+        "did": [],  # database
+        "lrid": [],  # role
+        "tsid": [],  # tablespace
+        "scid": []  # schema
+    }
+    return pickle_id_dict
 
 
 def get_ids(url=pickle_path):
@@ -34,43 +42,9 @@ def get_ids(url=pickle_path):
     output = open(url, 'rb')
     ids = pickle.load(output)
     output.close()
-
     return ids
 
 
-def verify_database(tester, server_group, server_id, db_id):
-    """
-    This function verifies that database is exists and whether it connect
-    successfully or not
-
-    :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 db_id: database id
-    :type db_id: str
-    :return: temp_db_con
-    :rtype: list
-    """
-
-    # Connect to server
-    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)
-
-    # Connect to database
-    con_response = tester.post('{0}{1}/{2}/{3}'.format(
-        DATABASE_CONNECT_URL, server_group, server_id, db_id),
-        follow_redirects=True)
-    temp_db_con = json.loads(con_response.data.decode('utf-8'))
-
-    return temp_db_con
-
-
 def test_getnodes(tester=None):
     # Connect to server and database.
 
@@ -81,53 +55,14 @@ def test_getnodes(tester=None):
 
     server_ids = all_id["sid"]
     db_ids_dict = all_id["did"][0]
-    srv_grp = config_data['test_server_group']
 
     db_con = []
     for server_id in server_ids:
         db_id = db_ids_dict[int(server_id)]
-        db_con.append(verify_database(tester, srv_grp, server_id, db_id))
+        db_con.append(verify_database(tester, SERVER_GROUP, server_id, db_id))
     return db_con
 
 
-def get_db_data(server_connect_data):
-    """
-    This function is used to get advance config test data for appropriate
-    server
-
-    :param server_connect_data: list of server details
-    :return data: database details
-    :rtype: dict
-    """
-
-    adv_config_data = None
-    data = None
-    db_user = server_connect_data['data']['user']['name']
-
-    # Get the config data of appropriate db user
-    for config_test_data in advanced_config_data['test_add_database_data']:
-        if db_user == config_test_data['test_owner']:
-            adv_config_data = config_test_data
-
-    if adv_config_data is not None:
-        data = {
-            "datacl": adv_config_data['test_privileges_acl'],
-            "datconnlimit": adv_config_data['test_conn_limit'],
-            "datowner": adv_config_data['test_owner'],
-            "deffuncacl": adv_config_data['test_fun_acl'],
-            "defseqacl": adv_config_data['test_seq_acl'],
-            "deftblacl": adv_config_data['test_tbl_acl'],
-            "deftypeacl": adv_config_data['test_type_acl'],
-            "encoding": adv_config_data['test_encoding'],
-            "name": str(uuid.uuid4())[1:8],
-            "privileges": adv_config_data['test_privileges'],
-            "securities": adv_config_data['test_securities'],
-            "variables": adv_config_data['test_variables']
-        }
-
-    return data
-
-
 def login_tester_account(tester):
     """
     This function login the test account using credentials mentioned in
@@ -139,9 +74,9 @@ def login_tester_account(tester):
     """
 
     email = \
-        config_data['pgAdmin4_login_credentials']['test_login_username']
+        config_data['pgAdmin4_login_credentials']['login_username']
     password = \
-        config_data['pgAdmin4_login_credentials']['test_login_password']
+        config_data['pgAdmin4_login_credentials']['login_password']
     response = tester.post('/login', data=dict(
         email=email, password=password), follow_redirects=True)
 
@@ -158,6 +93,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,23 +104,18 @@ def get_config_data():
     """
 
     db_data = []
+    pickle_id_dict = get_pickle_id_dict()
+    server_group = config_data['server_group']
 
-    pickle_id_dict = {
-        "sid": [],  # server
-        "did": []  # database
-    }
-
-    server_group = config_data['test_server_group']
-
-    for srv in config_data['test_server_credentials']:
-        data = {"name": srv['test_name'],
+    for srv in config_data['server_credentials']:
+        data = {"name": srv['name'],
                 "comment": "",
-                "host": srv['test_host'],
-                "port": srv['test_db_port'],
-                "db": srv['test_maintenance_db'],
-                "username": srv['test_db_username'],
+                "host": srv['host'],
+                "port": srv['db_port'],
+                "db": srv['maintenance_db'],
+                "username": srv['db_username'],
                 "role": "",
-                "sslmode": srv['test_sslmode']}
+                "sslmode": srv['sslmode']}
         db_data.append(data)
     return server_group, db_data, pickle_id_dict
 
@@ -205,40 +136,12 @@ 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()
 
 
-def write_db_parent_id(response_data):
-    """
-    This function writes the server and database related data like server
-    name, server id , database name, database id etc.
-
-    :param response_data: server and databases details
-    :type response_data: dict
-    :return: None
-    """
-
-    db_id = response_data['node']['_id']
-    server_id = response_data['node']['_pid']
-    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()
-
-
 def delete_parent_id_file():
     """
     This function deletes the file parent_id.pkl which contains server and
@@ -250,148 +153,3 @@ def delete_parent_id_file():
     if os.path.isfile(pickle_path):
         os.remove(pickle_path)
 
-
-def add_server(tester):
-    """
-    This function add the server in the existing server group
-
-    :param tester: test object
-    :type tester: flask test object
-    :return:None
-    """
-
-    server_group, db_data, pickle_id_dict = get_config_data()
-    url = "{0}{1}/".format(SERVER_URL, server_group)
-    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())
-        write_parent_id(response_data, pickle_id_dict)
-
-
-def get_server(tester):
-    """
-    This function gets the added serer details
-
-    :param tester: test client object
-    :type tester: flask test object
-    :return: response_data
-    :rtype: list
-    """
-
-    all_id = get_ids()
-    server_ids = all_id["sid"]
-    server_group = config_data['test_server_group']
-    for server_id in server_ids:
-        response = tester.get(SERVER_URL + str(server_group) + '/' +
-                              str(server_id),
-                              follow_redirects=True)
-        response_data = json.loads(response.data.decode())
-
-
-def connect_server(tester):
-    """
-    This function used to connect added server
-
-    :param tester:test client object
-    :type tester: flask test object
-    :return: server_connect, server_group, server_id
-    :rtype: server_connect:dict, server_group:dict, server_id:str
-    """
-
-    server_connect = []
-    servers = []
-
-    srv_id = get_ids()
-    server_ids = srv_id["sid"]
-    server_group = config_data['test_server_group']
-
-    # Connect to all servers
-    for server_id in server_ids:
-        response = tester.post(SERVER_CONNECT_URL + str(server_group) +
-                               '/' + server_id,
-                               data=dict(
-                                   password=config_data
-                                   ['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.append(server_connect_detail)
-        servers.append(server_id)
-    return server_connect, server_group, servers
-
-
-def connect_database(tester, server_connect, server_id, server_group):
-    """
-    This function is used to connect database and writes it's details to
-    file 'parent_id.pkl'
-
-    :param tester: test client object
-    :type tester: flask test client object
-    :param server_connect: server's data
-    :type server_connect: dict
-    :param server_id: server id
-    :type server_id: str
-    :param server_group: server group name
-    :type server_group: str
-    :return: None
-    """
-
-    if server_connect['data']['connected']:
-        db_data = get_db_data(server_connect)
-        db_response = tester.post(
-            DATABASE_URL + str(server_group) + "/" + server_id + "/",
-            data=json.dumps(db_data),
-            content_type='html/json')
-        response_data = json.loads(db_response.data.decode())
-        write_db_parent_id(response_data)
-
-
-def delete_server(tester):
-    """
-    This function used to delete the added servers
-
-    :param tester: test client object
-    :return: None
-    """
-
-    srv_grp = config_data['test_server_group']
-    all_id = get_ids()
-    server_ids = all_id["sid"]
-    url = SERVER_URL + str(srv_grp) + "/"
-
-    # Call api to delete the servers
-    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())
-        assert response_data['success'] == 1
-
-
-def delete_database(tester):
-    """
-    This function used to delete the added databases
-
-    :param tester: test client object
-    :return: None
-    """
-
-    srv_grp = config_data['test_server_group']
-    all_id = get_ids()
-    server_ids = all_id["sid"]
-    db_ids_dict = all_id['did'][0]
-
-    db_con = test_getnodes(tester)
-    if len(db_con) == 0:
-        raise Exception("No database(s) to delete.")
-
-    for server_id in server_ids:
-        db_id = db_ids_dict[int(server_id)]
-        response = tester.delete(DATABASE_URL + str(srv_grp) + '/' +
-                                 str(server_id) + '/' + str(db_id),
-                                 follow_redirects=True)
-        assert response.status_code == 200
-        response_data = json.loads(response.data.decode('utf-8'))
-        assert response_data['success'] == 1
