diff --git a/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_put.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_put.py
index 7a11ed5..5d615d0 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_put.py
@@ -63,7 +63,6 @@ class ExtensionsPutTestCase(BaseTestGenerator):
         server_ids = all_id["sid"]
         db_ids_dict = all_id["did"][0]
         extension_ids_dict = all_id["eid"][0]
-        schema_info_dict = all_id["scid"][0]
 
         for server_id in server_ids:
             db_id = db_ids_dict[int(server_id)]
@@ -75,22 +74,20 @@ class ExtensionsPutTestCase(BaseTestGenerator):
                                                          extension_id)
 
             if response.status_code == 200:
-                schema_name = schema_info_dict[int(server_id)][1]
-
-                data = \
-                    {
+                data = {
                         "id": extension_id,
-                        "schema": schema_name
+                        "schema": "public"
                     }
-
                 put_response = self.tester.put(
                     self.url + str(utils.SERVER_GROUP) + '/' +
                     str(server_id) + '/' + str(db_id) +
                     '/' + str(extension_id),
                     data=json.dumps(data),
                     follow_redirects=True)
-
                 self.assertEquals(put_response.status_code, 200)
+            else:
+                raise Exception("Error in verifying extension with id: %s" %
+                                extension_id)
 
     @classmethod
     def tearDownClass(cls):
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/__init__.py
new file mode 100644
index 0000000..56cc7f2
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/__init__.py
@@ -0,0 +1,8 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_add.py
new file mode 100644
index 0000000..061c645
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_add.py
@@ -0,0 +1,69 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as domain_utils
+
+
+class DomainAddTestCase(BaseTestGenerator):
+    """ This class will add new domain under schema node. """
+
+    scenarios = [
+        # Fetching default URL for domain node.
+        ('Fetch domain Node URL', dict(url='/browser/domain/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+
+    def runTest(self):
+        """ This function will add domain under schema node. """
+
+        domain_utils.add_domain(self.tester, self.server_connect_response)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added database, server and the
+        'parent_id.pkl' file which is created in setup() function.
+
+        :return: None
+        """
+
+        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/schemas/domains/tests/test_domain_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_delete.py
new file mode 100644
index 0000000..da01500
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_delete.py
@@ -0,0 +1,130 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as domain_utils
+
+
+class DomainDeleteTestCase(BaseTestGenerator):
+    """ This class will delete new domain under schema node. """
+
+    scenarios = [
+        # Fetching default URL for domain node.
+        ('Fetch domain Node URL', dict(url='/browser/domain/delete/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+         5. Add the domain
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+        # Add the domain
+        domain_utils.add_domain(cls.tester, cls.server_connect_response)
+
+    def runTest(self):
+        """ This function will delete domain under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids_dict = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        domain_ids_dict = all_id["doid"][0]
+
+        for server_id in server_ids_dict:
+            # Verify server
+            server_response = server_utils.verify_server(
+                self.tester, str(utils.SERVER_GROUP), server_id)
+            if server_response['data']["connected"]:
+                db_id = db_ids_dict[int(server_id)]
+                # Verify database
+                db_con = database_utils.verify_database(self.tester,
+                                                        utils.SERVER_GROUP,
+                                                        server_id, db_id)
+                if db_con['data']["connected"]:
+                    schema_id = schema_ids_dict[int(server_id)][0]
+                    # Verify schema
+                    schema_response = schema_utils.verify_schemas(self.tester,
+                                                                  server_id,
+                                                                  db_id,
+                                                                  schema_id)
+                    if schema_response.status_code == 200:
+                        domain_id = domain_ids_dict[int(server_id)]
+                        # Call GET API to verify the domain
+                        response = domain_utils.verify_domain(self.tester,
+                                                              server_id, db_id,
+                                                              schema_id,
+                                                              domain_id)
+
+                        if response.status_code == 200:
+                            delete_response = self.tester.delete(
+                                self.url + str(utils.SERVER_GROUP) + '/' +
+                                str(server_id) + '/' +
+                                str(db_id) + '/' +
+                                str(schema_id) + '/' +
+                                str(domain_id),
+                                follow_redirects=True)
+                            del_resp_data = json.loads(
+                                delete_response.data.decode('utf-8'))
+                            self.assertTrue(del_resp_data['success'], 1)
+                        else:
+                            raise Exception(
+                                "Error in verifying domain with id: %s" %
+                                domain_id)
+
+                    else:
+                        raise Exception("Error in verifying schema with id: %s"
+                                        % str(schema_id))
+                else:
+                    raise Exception("Error in verifying database with id: %s"
+                                    % db_id)
+
+            else:
+                raise Exception("Error in connecting server with id: %s"
+                                % server_id)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added database, server and the
+        'parent_id.pkl' file which is created in setup() function.
+
+        :return: None
+        """
+
+        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/schemas/domains/tests/test_domain_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_get.py
new file mode 100644
index 0000000..36b5ae0
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_get.py
@@ -0,0 +1,113 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as domain_utils
+
+
+class DomainGetTestCase(BaseTestGenerator):
+    """ This class will fetch new collation under schema node. """
+
+    scenarios = [
+        # Fetching default URL for domain node.
+        ('Fetch domain Node URL', dict(url='/browser/domain/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+         5. Add the domain
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+        # Add the domain
+        domain_utils.add_domain(cls.tester, cls.server_connect_response)
+
+    def runTest(self):
+        """ This function will add domain under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids_dict = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        domain_ids_dict = all_id["doid"][0]
+
+        for server_id in server_ids_dict:
+            # Verify server
+            server_response = server_utils.verify_server(
+                self.tester, str(utils.SERVER_GROUP), server_id)
+            if server_response['data']["connected"]:
+                db_id = db_ids_dict[int(server_id)]
+                # Verify database
+                db_con = database_utils.verify_database(self.tester,
+                                                        utils.SERVER_GROUP,
+                                                        server_id, db_id)
+                if db_con['data']["connected"]:
+                    schema_id = schema_ids_dict[int(server_id)][0]
+                    # Verify schema
+                    schema_response = schema_utils.verify_schemas(self.tester,
+                                                                  server_id,
+                                                                  db_id,
+                                                                  schema_id)
+                    if schema_response.status_code == 200:
+                        domain_id = domain_ids_dict[int(server_id)]
+                        # Call GET API to verify the domain
+                        response = domain_utils.verify_domain(self.tester,
+                                                              server_id, db_id,
+                                                              schema_id,
+                                                              domain_id)
+
+                        self.assertEquals(response.status_code, 200)
+                    else:
+                        raise Exception("Error in verifying schema with id: %s"
+                                        % str(schema_id))
+                else:
+                    raise Exception("Error in verifying database with id: %s"
+                                    % db_id)
+
+            else:
+                raise Exception("Error in connecting server with id: %s"
+                                % server_id)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added database, server and the
+        'parent_id.pkl' file which is created in setup() function.
+
+        :return: None
+        """
+
+        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/schemas/domains/tests/test_domain_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_put.py
new file mode 100644
index 0000000..aa1ccc9
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_put.py
@@ -0,0 +1,136 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression.test_setup import advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from . import utils as domain_utils
+
+
+class DomainPutTestCase(BaseTestGenerator):
+    """ This class will fetch new collation under schema node. """
+
+    scenarios = [
+        # Fetching default URL for domain node.
+        ('Fetch domain Node URL', dict(url='/browser/domain/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+         5. Add the domain
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+        # Add the domain
+        domain_utils.add_domain(cls.tester, cls.server_connect_response)
+
+    def runTest(self):
+        """ This function will update domain under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids_dict = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        domain_ids_dict = all_id["doid"][0]
+
+        for server_id in server_ids_dict:
+            # Verify server
+            server_response = server_utils.verify_server(
+                self.tester, str(utils.SERVER_GROUP), server_id)
+            if server_response['data']["connected"]:
+                db_id = db_ids_dict[int(server_id)]
+                # Verify database
+                db_con = database_utils.verify_database(self.tester,
+                                                        utils.SERVER_GROUP,
+                                                        server_id, db_id)
+                if db_con['data']["connected"]:
+                    schema_id = schema_ids_dict[int(server_id)][0]
+                    # Verify schema
+                    schema_response = schema_utils.verify_schemas(self.tester,
+                                                                  server_id,
+                                                                  db_id,
+                                                                  schema_id)
+                    if schema_response.status_code == 200:
+                        domain_id = domain_ids_dict[int(server_id)]
+                        # Call GET API to verify the domain
+                        response = domain_utils.verify_domain(self.tester,
+                                                              server_id, db_id,
+                                                              schema_id,
+                                                              domain_id)
+
+                        if response.status_code == 200:
+                            data = {"description": advanced_config_data[
+                                'domain_update_data']['comment'],
+                                    "id": domain_id,
+                                    }
+
+                            put_response = self.tester.put(
+                                self.url + str(utils.SERVER_GROUP) + '/' +
+                                str(server_id) + '/' +
+                                str(db_id) + '/' +
+                                str(schema_id) + '/' +
+                                str(domain_id),
+                                data=json.dumps(data),
+                                follow_redirects=True)
+
+                            self.assertEquals(put_response.status_code, 200)
+                        else:
+                            raise Exception(
+                                "Error in verifying domain with id: %s" %
+                                domain_id)
+
+                    else:
+                        raise Exception("Error in verifying schema with id: %s"
+                                        % str(schema_id))
+                else:
+                    raise Exception("Error in verifying database with id: %s"
+                                    % db_id)
+
+            else:
+                raise Exception("Error in connecting server with id: %s"
+                                % server_id)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added database, server and the
+        'parent_id.pkl' file which is created in setup() function.
+
+        :return: None
+        """
+
+        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/schemas/domains/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/utils.py
new file mode 100644
index 0000000..9bab464
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/utils.py
@@ -0,0 +1,173 @@
+# ##########################################################################
+#
+# #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, advanced_config_data
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+DOMAIN_URL = '/browser/domain/obj/'
+
+
+def get_domain_config_data(server_connect_data, schema_name):
+    """
+    This function returns the config data for domain node
+    :param server_connect_data: server connect response
+    :type server_connect_data: dict
+    :param schema_name: schema name under which domain will create
+    :type schema_name: str
+    :return data: config data
+    :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['domain_data']:
+        if db_user == config_test_data['owner']:
+            adv_config_data = config_test_data
+
+    if adv_config_data is not None:
+        data = {
+            "basensp": schema_name,
+            "basetype": adv_config_data['basetype'],
+            "collname": adv_config_data['collation'],
+            "constraints": adv_config_data['constraints'],
+            "is_tlength": adv_config_data['lenght'],
+            "max_val": adv_config_data['max_value'],
+            "min_val": adv_config_data['min_value'],
+            "name": "test_{}".format(str(uuid.uuid4())[1:8]),
+            "owner": adv_config_data['owner'],
+            "seclabels": adv_config_data['security'],
+            "typdefault": adv_config_data['defalt_type'],
+            "typlen": adv_config_data['type_len']
+        }
+    return data
+
+
+def write_domain_id(response_data, server_id):
+    """
+    This function writes the server and collation id
+
+    :param response_data: domain response data
+    :type response_data: dict
+    :param server_id: server id
+    :type server_id: int
+    :return: None
+    """
+    domain_id = response_data['node']['_id']
+    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 'doid' in pickle_id_dict:
+        if pickle_id_dict['doid']:
+            # Add the db_id as value in dict
+            pickle_id_dict["doid"][0].update(
+                {int(server_id): domain_id})
+        else:
+            # Create new dict with server_id and db_id
+            pickle_id_dict["doid"].append(
+                {int(server_id): domain_id})
+    db_output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, db_output)
+    db_output.close()
+
+
+def verify_domain(tester, server_id, db_id, schema_id, domain_id):
+    """
+    This function verifies the existing domain using GET method
+    :param tester: test client
+    :type tester: flask test client
+    :param server_id: server id
+    :type server_id: int
+    :param db_id: database id
+    :type db_id: int
+    :param schema_id: schemna id
+    :type schema_id: int
+    :param domain_id: domain id
+    :type domain_id: int
+    :return get_response: HTTP GET response
+    :rtype: dict
+    """
+    get_response = tester.get(DOMAIN_URL + str(utils.SERVER_GROUP) + '/' +
+                                                   str(server_id) + '/' +
+                                                   str(db_id) + '/' +
+                                                   str(schema_id) + '/' +
+                                                   str(domain_id),
+                                                   content_type='html/json')
+    return get_response
+
+
+def add_domain(tester, server_connect_response):
+    """
+    This function is used to add the domain to existing schema
+    :param tester: test client
+    :type tester: flask test client object
+    :param server_connect_response: server connect GET response
+    :type server_connect_response: dict
+    :return: None
+    """
+    all_id = utils.get_ids()
+    server_ids_dict = all_id["sid"]
+    db_ids_dict = all_id["did"][0]
+    schema_ids_dict = all_id["scid"][0]
+
+    for server_connect_response, server_id in zip(server_connect_response,
+                                                  server_ids_dict):
+        # Verify server
+        server_response = server_utils.verify_server(tester,
+                                                     str(utils.SERVER_GROUP),
+                                                     server_id)
+        if server_response['data']["connected"]:
+            db_id = db_ids_dict[int(server_id)]
+            # Verify database
+            db_con = database_utils.verify_database(tester, utils.SERVER_GROUP,
+                                                    server_id, db_id)
+            if db_con['data']["connected"]:
+                schema_id = schema_ids_dict[int(server_id)][0]
+                schema_name = schema_ids_dict[int(server_id)][1]
+                # Verify schema
+                schema_response = schema_utils.verify_schemas(tester,
+                                                              server_id, db_id,
+                                                              schema_id)
+                if schema_response.status_code == 200:
+                    data = get_domain_config_data(server_connect_response, schema_name)
+                    # Call POST API to add domain
+                    response = tester.post(
+                        DOMAIN_URL + str(utils.SERVER_GROUP) + '/' +
+                        str(server_id) + '/' + str(db_id) +
+                        '/' + str(schema_id) + '/',
+                        data=json.dumps(data),
+                        content_type='html/json')
+
+                    assert response.status_code == 200
+                    response_data = json.loads(response.data.decode('utf-8'))
+                    write_domain_id(response_data, server_id)
+                else:
+                    raise Exception("Error in verifying schema with id: %s"
+                                    % str(schema_id))
+            else:
+                raise Exception("Error in verifying database with id: %s"
+                                % db_id)
+
+        else:
+            raise Exception("Error in connecting server with id: %s"
+                            % server_id)
+
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/__init__.py
new file mode 100644
index 0000000..56cc7f2
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/__init__.py
@@ -0,0 +1,8 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_add.py
new file mode 100644
index 0000000..6ff24c9
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_add.py
@@ -0,0 +1,79 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \
+    tablespace_utils
+from . import utils as tables_utils
+
+
+class TableAddTestCase(BaseTestGenerator):
+    """ This class will add new collation under schema node. """
+
+    scenarios = [
+        # Fetching default URL for table node.
+        ('Fetch table Node URL', dict(url='/browser/table/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+
+    def runTest(self):
+        """ This function will add table under schema node. """
+
+        tables_utils.add_tables(self.tester, self.server_connect_response)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added tables, schemas, database,
+        server and the 'parent_id.pkl' file which is created in setup()
+        function.
+
+        :return: None
+        """
+
+        database_utils.delete_database(cls.tester)
+        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/databases/schemas/tables/tests/test_table_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_delete.py
new file mode 100644
index 0000000..3002836
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_delete.py
@@ -0,0 +1,82 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \
+    tablespace_utils
+from . import utils as tables_utils
+
+
+class TableDeleteTestCase(BaseTestGenerator):
+    """ This class will delete new table under schema node. """
+
+    scenarios = [
+        # Fetching default URL for table node.
+        ('Fetch table Node URL', dict(url='/browser/table/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+         5. Add the tables
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+        # Add tables
+        tables_utils.add_tables(cls.tester, cls.server_connect_response)
+
+    def runTest(self):
+        """ This function will delete added table under schema node. """
+
+        tables_utils.delete_tables(self.tester)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added tables, schemas, database,
+        server and the 'parent_id.pkl' file which is created in setup()
+        function.
+
+        :return: None
+        """
+
+        database_utils.delete_database(cls.tester)
+        tablespace_utils.delete_table_space(cls.tester)
+        server_utils.delete_server(cls.tester)
+        utils.delete_parent_id_file()
\ No newline at end of file
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_get.py
new file mode 100644
index 0000000..683701b
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_get.py
@@ -0,0 +1,121 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \
+    tablespace_utils
+from . import utils as tables_utils
+
+
+class TableGetTestCase(BaseTestGenerator):
+    """ This class will add new collation under schema node. """
+
+    scenarios = [
+        # Fetching default URL for table node.
+        ('Fetch table Node URL', dict(url='/browser/table/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+         5. Add the tables
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+        # Add tables
+        tables_utils.add_tables(cls.tester, cls.server_connect_response)
+
+    def runTest(self):
+        """ This function will fetch added table under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        table_ids_dict = all_id["tid"][0]
+
+        for server_id in server_ids:
+            server_response = server_utils.verify_server(self.tester, str(
+                utils.SERVER_GROUP), server_id)
+            if server_response['data']['connected']:
+                db_id = db_ids_dict[int(server_id)]
+                db_con = database_utils.verify_database(self.tester,
+                                                        utils.SERVER_GROUP,
+                                                        server_id, db_id)
+                if db_con['data']['connected']:
+                    schema_id = schema_ids_dict[int(server_id)][0]
+                    schema_response = schema_utils.verify_schemas(
+                        self.tester, server_id, db_id, schema_id)
+                    schema_response = json.loads(
+                        schema_response.data.decode('utf-8'))
+                    if len(schema_response) != 0:
+                        table_id = table_ids_dict[int(server_id)]
+                        get_response = tables_utils.verify_table(self.tester,
+                                                                 server_id,
+                                                                 db_id,
+                                                                 schema_id,
+                                                                 table_id)
+                        self.assertEquals(get_response.status_code, 200)
+                    else:
+                        raise Exception(
+                            "Error while verifying schema with id: %s"
+                            % schema_id)
+                else:
+                    raise Exception(
+                        "Error while connecting database with id: %s"
+                        % db_id)
+            else:
+                raise Exception("Error while connecting server with id: %s"
+                                % server_id)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added tables, schemas, database,
+        server and the 'parent_id.pkl' file which is created in setup()
+        function.
+
+        :return: None
+        """
+
+        database_utils.delete_database(cls.tester)
+        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/databases/schemas/tables/tests/test_table_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_put.py
new file mode 100644
index 0000000..2a7391b
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_put.py
@@ -0,0 +1,142 @@
+# #################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+# ##################################################################
+
+import json
+
+from regression import test_utils as utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression.test_setup import advanced_config_data
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from pgadmin.browser.server_groups.servers.databases.tests import utils as \
+    database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \
+    tablespace_utils
+from . import utils as tables_utils
+
+
+class TableUpdateTestCase(BaseTestGenerator):
+    """ This class will add new collation under schema node. """
+
+    scenarios = [
+        # Fetching default URL for table node.
+        ('Fetch table Node URL', dict(url='/browser/table/obj/'))
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        """
+        This function perform the three tasks
+         1. Add the test server
+         2. Connect to server
+         3. Add the databases
+         4. Add the schemas
+         5. Add the tables
+
+        :return: None
+        """
+
+        # Firstly, 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 database!!!")
+        # Add tablespace
+        tablespace_utils.add_table_space(cls.tester,
+                                         cls.server_connect_response,
+                                         cls.server_group, cls.server_ids)
+
+        # Add database
+        database_utils.add_database(cls.tester, cls.server_connect_response,
+                                    cls.server_ids)
+        # Add schemas
+        schema_utils.add_schemas(cls.tester)
+        # Add tables
+        tables_utils.add_tables(cls.tester, cls.server_connect_response)
+
+    def runTest(self):
+        """ This function will fetch added table under schema node. """
+
+        all_id = utils.get_ids()
+        server_ids_dict = all_id["sid"]
+        db_ids_dict = all_id["did"][0]
+        schema_ids_dict = all_id["scid"][0]
+        table_ids_dict = all_id["tid"][0]
+
+        for server_id in server_ids_dict:
+            # Verify server
+            server_response = server_utils.verify_server(
+                self.tester, str(utils.SERVER_GROUP), server_id)
+            if server_response['data']['connected']:
+                db_id = db_ids_dict[int(server_id)]
+                # Verify database
+                db_con = database_utils.verify_database(self.tester,
+                                                        utils.SERVER_GROUP,
+                                                        server_id, db_id)
+                if db_con['data']['connected']:
+                    schema_id = schema_ids_dict[int(server_id)][0]
+                    # Verify schema
+                    schema_response = schema_utils.verify_schemas(self.tester,
+                                                                  server_id,
+                                                                  db_id,
+                                                                  schema_id)
+                    if schema_response.status_code == 200:
+                        table_id = table_ids_dict[int(server_id)]
+                        # Verify table
+                        table_response = tables_utils.verify_table(self.tester,
+                                                                   server_id,
+                                                                   db_id,
+                                                                   schema_id,
+                                                                   table_id)
+                        if table_response.status_code == 200:
+                            data = {
+                                "description":
+                                    advanced_config_data['table_update_data']['comment'],
+                                "id": table_id
+                            }
+
+                            put_response = self.tester.put(
+                                self.url + str(utils.SERVER_GROUP) + '/' +
+                                str(server_id) + '/' + str(db_id) + '/' +
+                                str(schema_id) + '/' + str(table_id),
+                                data=json.dumps(data), follow_redirects=True)
+
+                            self.assertEquals(put_response.status_code, 200)
+                        else:
+                            raise Exception("Error while verifying table with "
+                                            "id: %s" % table_id)
+                    else:
+                        raise Exception(
+                            "Error while verifying schema with id: %s"
+                            % schema_id)
+                else:
+                    raise Exception(
+                        "Error while connecting database with id: %s"
+                        % db_id)
+            else:
+                raise Exception("Error while connecting server with id: %s"
+                                % server_id)
+
+    @classmethod
+    def tearDownClass(cls):
+        """
+        This function deletes the added tables, schemas, database,
+        server and the 'parent_id.pkl' file which is created in setup()
+        function.
+
+        :return: None
+        """
+
+        database_utils.delete_database(cls.tester)
+        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/databases/schemas/tables/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/utils.py
new file mode 100644
index 0000000..7458b31
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/utils.py
@@ -0,0 +1,207 @@
+# ##########################################################################
+#
+# #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, advanced_config_data
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.tests import utils as server_utils
+from regression import test_utils as utils
+
+TABLES_URL = '/browser/table/obj/'
+
+
+def get_tables_config_data(server_connect_data, schema_name, tablespace_name):
+    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['table_credentials']:
+        if db_user == config_test_data['owner']:
+            adv_config_data = config_test_data
+
+    if adv_config_data is not None:
+        data = {
+            "check_constraint": adv_config_data['constraint'],
+            "coll_inherits": adv_config_data['col_inherit'],
+            "columns": adv_config_data['columns'],
+            "exclude_constraint": adv_config_data['has_constraint'],
+            "fillfactor": adv_config_data['fillfactor'],
+            "foreign_key": adv_config_data['has_FK'],
+            "hastoasttable": adv_config_data['has_toast_tbl'],
+            "like_constraints": adv_config_data['like_constraint'],
+            "like_default_value": adv_config_data['like_default_value'],
+            "like_relation": adv_config_data['like_relation'],
+            "name": "table_{}".format(str(uuid.uuid4())[1:4]),
+            "primary_key": adv_config_data['PK'],
+            "relacl": adv_config_data['acl'],
+            "relhasoids": adv_config_data['has_oid'],
+            "relowner": adv_config_data['owner'],
+            "schema": schema_name,
+            "seclabels": adv_config_data['sec_acl'],
+            "spcname": tablespace_name,
+            "unique_constraint": adv_config_data['unique_constraint'],
+            "vacuum_table": adv_config_data['vacuum_tbl'],
+            "vacuum_toast": adv_config_data['vacuum_toast']
+        }
+    return data
+
+
+def write_tables_id(response_data, server_id):
+    """
+    This function writes the server and collation id
+
+    :param response_data: table response data
+    :type response_data: dict
+    :param server_id: server id
+    :type server_id: int
+    :return: None
+    """
+
+    table_id = response_data['node']['_id']
+    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 'tid' in pickle_id_dict:
+        if pickle_id_dict['tid']:
+            # Add the db_id as value in dict
+            pickle_id_dict["tid"][0].update(
+                {int(server_id): table_id})
+        else:
+            # Create new dict with server_id and db_id
+            pickle_id_dict["tid"].append(
+                {int(server_id): table_id})
+    db_output = open(pickle_path, 'wb')
+    pickle.dump(pickle_id_dict, db_output)
+    db_output.close()
+
+
+def add_tables(tester, server_connect_response):
+    all_id = utils.get_ids()
+    server_ids_dict = all_id["sid"]
+    db_ids_dict = all_id["did"][0]
+    schema_ids_dict = all_id["scid"][0]
+    tablespace_ids_dict = None
+    if "tsid" in all_id and all_id["tsid"]:
+        tablespace_ids_dict = all_id["tsid"][0]
+
+    for server_connect_response, server_id in zip(server_connect_response,
+                                                  server_ids_dict):
+        # Verify server
+        server_response = server_utils.verify_server(tester,
+                                                     str(utils.SERVER_GROUP),
+                                                     server_id)
+        if server_response['data']["connected"]:
+            db_id = db_ids_dict[int(server_id)]
+            # Verify database
+            db_con = database_utils.verify_database(tester, utils.SERVER_GROUP,
+                                                    server_id, db_id)
+            if db_con['data']["connected"]:
+                schema_id = schema_ids_dict[int(server_id)][0]
+                schema_name = schema_ids_dict[int(server_id)][1]
+                # Verify schema
+                schema_response = schema_utils.verify_schemas(tester,
+                                                              server_id, db_id,
+                                                              schema_id)
+                if schema_response.status_code == 200:
+                    tablespace_name = tablespace_ids_dict[int(server_id)][1]
+                    data = get_tables_config_data(server_connect_response,
+                                                  schema_name, tablespace_name)
+                    # Add table
+                    response = tester.post(
+                        TABLES_URL + str(utils.SERVER_GROUP) + '/' +
+                        str(server_id) + '/' + str(db_id) +
+                        '/' + str(schema_id) + '/',
+                        data=json.dumps(data),
+                        content_type='html/json')
+                    assert response.status_code == 200
+                    response_data = json.loads(response.data.decode('utf-8'))
+                    write_tables_id(response_data, server_id)
+                else:
+                    raise Exception("Error while verifying schema with id: %s"
+                                    % schema_id)
+            else:
+                raise Exception("Error while connecting database with id: %s"
+                                % db_id)
+        else:
+            raise Exception("Error while connecting server with id: %s"
+                            % server_id)
+
+
+def verify_table(tester, server_id, db_id, schema_id, table_id):
+    get_response = tester.get(TABLES_URL + str(utils.SERVER_GROUP) + '/' +
+                              str(server_id) + '/' +
+                              str(db_id) + '/' +
+                              str(schema_id) + '/' +
+                              str(table_id),
+                              content_type='html/json')
+    return get_response
+
+
+def delete_tables(tester):
+    all_id = utils.get_ids()
+    server_ids_dict = all_id["sid"]
+    db_ids_dict = all_id["did"][0]
+    schema_ids_dict = all_id["scid"][0]
+    table_ids_dict = all_id["tid"][0]
+
+    for server_id in server_ids_dict:
+        # Verify server
+        server_response = server_utils.verify_server(tester,
+                                                     str(utils.SERVER_GROUP),
+                                                     server_id)
+        if server_response['data']['connected']:
+            db_id = db_ids_dict[int(server_id)]
+            # Verify database
+            db_con = database_utils.verify_database(tester, utils.SERVER_GROUP,
+                                                    server_id, db_id)
+            if db_con['data']['connected']:
+                schema_id = schema_ids_dict[int(server_id)][0]
+                # Verify schema
+                schema_response = schema_utils.verify_schemas(tester,
+                                                              server_id, db_id,
+                                                              schema_id)
+                if schema_response.status_code == 200:
+                    table_id = table_ids_dict[int(server_id)]
+                    # Verify table
+                    table_response = verify_table(tester, server_id, db_id,
+                                                  schema_id, table_id)
+                    if table_response.status_code == 200:
+                        # Delete table
+                        del_response = tester.delete(
+                            '/browser/table/delete/' + str(utils.SERVER_GROUP) +
+                            '/' + str(server_id) + '/' +
+                            str(db_id) + '/' +
+                            str(schema_id) + '/' +
+                            str(table_id),
+                            follow_redirects=True)
+
+                        del_respdata = json.loads(
+                            del_response.data.decode('utf-8'))
+                        assert del_respdata['success'] == 1
+                    else:
+                        raise Exception("Error while verifying table")
+                else:
+                    raise Exception("Error while verifying schema with id: %s"
+                                    % schema_id)
+            else:
+                raise Exception("Error while connecting database with id: %s"
+                                % db_id)
+        else:
+            raise Exception("Error while connecting server with id: %s"
+                            % server_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py
index d3d4bfd..967b614 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py
@@ -94,8 +94,6 @@ class SchemaPutTestCase(BaseTestGenerator):
                     data=json.dumps(data), follow_redirects=True)
 
                 self.assertEquals(put_response.status_code, 200)
-                response_data = json.loads(put_response.data.decode('utf-8'))
-                self.assertTrue(response_data['success'], 1)
 
     @classmethod
     def tearDownClass(cls):
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 490e7d9..30972e5 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
@@ -41,7 +41,7 @@ class DatabaseAddTestCase(BaseTestGenerator):
             server_utils.connect_server(cls.tester)
 
         if len(cls.server_connect_response) == 0:
-            raise Exception("No Server(s) connected to add the database!!!")
+            raise Exception("No Server(s) connected to add the database.")
 
     def runTest(self):
         """ This function will add database under 1st server of tree node. """
diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
index 37a95ba..c82af99 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py
@@ -16,7 +16,6 @@ from regression.test_setup import pickle_path, 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/'
 
@@ -104,12 +103,14 @@ def add_database(tester, 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')
+                                      "/" + 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)
+        else:
+            raise Exception("Error in connecting server..")
 
 
 def verify_database(tester, server_group, server_id, db_id):
@@ -158,19 +159,24 @@ def delete_database(tester):
         if all_id['did']:
             db_ids_dict = all_id['did'][0]
     else:
-        raise Exception("Keys are not found in pickle dict: {}".format(["sid", "did"]))
+        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)
+            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)
+
+                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/tablespaces/tests/test_tbspc_get.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py
index b26d71d..3b8a70f 100644
--- 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
@@ -55,7 +55,7 @@ class TablespaceGetTestCase(BaseTestGenerator):
 
         if tablespace_ids_dict:
             for server_id in server_ids:
-                tablespace_id = tablespace_ids_dict[int(server_id)]
+                tablespace_id = tablespace_ids_dict[int(server_id)][0]
                 server_response = server_utils.verify_server(self.tester,
                                                              utils.SERVER_GROUP,
                                                              server_id)
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
index 22257f9..a742ee2 100644
--- 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
@@ -58,7 +58,7 @@ class TableSpaceUpdateTestCase(BaseTestGenerator):
 
         if tablespace_ids_dict:
             for server_id in server_ids:
-                tablespace_id = tablespace_ids_dict[int(server_id)]
+                tablespace_id = tablespace_ids_dict[int(server_id)][0]
                 tablespace_response = tablespace_utils.verify_table_space(
                     self.tester,
                     utils.SERVER_GROUP, server_id,
diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
index 4fd21bd..6cac7ee 100644
--- a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py
@@ -46,7 +46,7 @@ def get_tablespace_data(server_connect):
 
     if adv_config_data is not None:
         data = {
-            "name": str(uuid.uuid4())[1:8],
+            "name": "test_{}".format(str(uuid.uuid4())[1:8]),
             "seclabels": adv_config_data["spc_seclable"],
             "spcacl": adv_config_data["spc_acl"],
             "spclocation": adv_config_data["spc_location"],
@@ -56,12 +56,14 @@ def get_tablespace_data(server_connect):
     return data
 
 
-def write_tablespace_id(response_data):
+def write_tablespace_info(response_data, tablespace_name):
     """
     This function write the table space id to parent_id.pkl
 
     :param response_data: create table space API response data
     :type response_data: dict
+    :param tablespace_name: tablespace name
+    :type tablespace_name: str
     :return: None
     """
 
@@ -76,11 +78,11 @@ def write_tablespace_id(response_data):
         if pickle_id_dict['tsid']:
             # Add the db_id as value in dict
             pickle_id_dict["tsid"][0].update(
-                {server_id: table_space_id})
+                {server_id: [table_space_id, tablespace_name]})
         else:
             # Create new dict with server_id and db_id
             pickle_id_dict["tsid"].append(
-                {server_id: table_space_id})
+                {server_id: [table_space_id, tablespace_name]})
     db_output = open(pickle_path, 'wb')
     pickle.dump(pickle_id_dict, db_output)
     db_output.close()
@@ -125,13 +127,19 @@ def add_table_space(tester, server_connect_response, server_group, server_ids):
 
         if server_connect['data']['connected']:
             data = get_tablespace_data(server_connect)
+            tablespace_name = ''
+            if 'name' in data:
+                tablespace_name = data['name']
             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)
+            write_tablespace_info(response_data, tablespace_name)
+        else:
+            raise Exception("Error while connecting server with id: %s"
+                            % server_id)
 
 
 def verify_table_space(tester, server_group, server_id, tablespace_id):
@@ -173,14 +181,12 @@ def delete_table_space(tester):
 
     all_id = utils.get_ids()
     server_ids = all_id["sid"]
+    tablespace_ids_dict = None
     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)]
+            tablespace_id = tablespace_ids_dict[int(server_id)][0]
             role_response = verify_table_space(tester, utils.SERVER_GROUP,
                                                server_id,
                                                tablespace_id)
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 9ac6468..fe91299 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
@@ -61,9 +61,6 @@ class ServerUpdateTestCase(BaseTestGenerator):
                 content_type='html/json')
             self.assertEquals(put_response.status_code, 200)
 
-            response_data = json.loads(put_response.data.decode())
-            self.assertTrue(response_data['success'], 1)
-
     @classmethod
     def tearDownClass(cls):
         """
diff --git a/web/pgadmin/browser/server_groups/servers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tests/utils.py
index 6e3f166..6dc7a9f 100644
--- a/web/pgadmin/browser/server_groups/servers/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/tests/utils.py
@@ -84,8 +84,6 @@ def connect_server(tester):
 
     :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
     """
diff --git a/web/pgadmin/browser/tests/test_change_password.py b/web/pgadmin/browser/tests/test_change_password.py
index 5b7c918..2ed7bc8 100644
--- a/web/pgadmin/browser/tests/test_change_password.py
+++ b/web/pgadmin/browser/tests/test_change_password.py
@@ -88,6 +88,7 @@ class ChangePasswordTestCase(BaseTestGenerator):
                 email=self.username, newPassword=self.password,
                 confirmPassword=self.password, active=1, role="2"),
                                         follow_redirects=True)
+            assert response.status_code == 200
             user_id = json.loads(response.data.decode('utf-8'))['id']
 
             # Logout the Administrator before login normal user
diff --git a/web/pgadmin/utils/route.py b/web/pgadmin/utils/route.py
index 0226e8d..35b9d97 100644
--- a/web/pgadmin/utils/route.py
+++ b/web/pgadmin/utils/route.py
@@ -56,7 +56,8 @@ class TestsGeneratorRegistry(ABCMeta):
         if config.SERVER_MODE:
             for module_name in find_modules(pkg, False, True):
                 try:
-                    module = import_module(module_name)
+                    if "tests." in str(module_name):
+                        module = import_module(module_name)
                 except ImportError:
                     pass
         else:
diff --git a/web/regression/runtests.py b/web/regression/runtests.py
index d11a794..7c2c89a 100644
--- a/web/regression/runtests.py
+++ b/web/regression/runtests.py
@@ -32,7 +32,8 @@ import config
 # Get the config database schema version. We store this in pgadmin.model
 # as it turns out that putting it in the config files isn't a great idea
 from pgadmin.model import SCHEMA_VERSION
-from test_utils import login_tester_account, logout_tester_account
+from test_utils import login_tester_account, logout_tester_account, \
+    drop_objects
 
 config.SETTINGS_SCHEMA_VERSION = SCHEMA_VERSION
 
@@ -148,6 +149,9 @@ if __name__ == '__main__':
     tests = unittest.TextTestRunner(stream=sys.stderr, descriptions=True,
                                     verbosity=2).run(suite)
 
+    # Drop all objects which are created for testing
+    drop_objects(test_client)
+
     # Logout the test client
     logout_tester_account(test_client)
 
diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in
index b339c92..e737610 100644
--- a/web/regression/test_advanced_config.json.in
+++ b/web/regression/test_advanced_config.json.in
@@ -140,10 +140,10 @@
     "spc_opts": [],
     "spc_user": "postgres"
   }],
-
-    "tbspc_update_data": {
+  "tbspc_update_data": {
     "comment": "This is tablespace update comment"
   },
+
   "schema_credentials":[
   {
     "func_acl": [],
@@ -296,13 +296,11 @@
     "owner": "postgres",
     "schema": ""
   }],
-
-   "collation_update_data": {
+  "collation_update_data": {
     "comment": "This is collation update comment"
   },
 
-  "casts_credentials":
-  [{
+  "casts_credentials": [{
     "cast_context": "IMPLICIT",
     "encoding": "UTF8",
     "name": "money->bigint",
@@ -310,9 +308,7 @@
     "target_type": "bigint",
     "owner": "postgres"
   }],
-
-  "cast_update_data":
-  {
+  "cast_update_data": {
     "comment": "This is cast update comment"
   },
 
@@ -324,13 +320,11 @@
     "version": "1.0",
     "owner": "postgres"
   }],
-
-   "extension_update_data":
-  {
+  "extension_update_data": {
     "schema": "schema"
   },
 
-    "fdw_credentials":[
+  "fdw_credentials":[
   {
     "acl":
     [
@@ -353,13 +347,11 @@
     "validator": "postgres_fdw_validator",
     "name": "fdw"
   }],
-
-    "fdw_update_data":
-  {
+  "fdw_update_data": {
     "comment": "This is FDW update comment"
   },
 
-   "fsrv_credentials":[
+  "fsrv_credentials":[
   {
     "fsrv_acl":
     [
@@ -394,9 +386,7 @@
     "owner": "postgres",
     "name": "foreign_server1"
   }],
-
-  "FSRV_update_data":
-  {
+  "FSRV_update_data": {
     "comment": "This is foreign server update comment"
   },
 
@@ -417,9 +407,7 @@
       }
     ]
   }],
-
-  "user_mapping_update_data":
-  {
+  "user_mapping_update_data": {
     "options":
     {
       "changed":
@@ -431,8 +419,7 @@
     }
   },
 
-     "event_trigger_credentials":
-  [{
+  "event_trigger_credentials": [{
     "enable": "O",
     "event_func": "test_schema.test_abort_any_command",
     "event_name":  "DDL_COMMAND_END",
@@ -440,57 +427,198 @@
     "name": "test_event_trg",
     "provider": []
   }],
-
-   "event_trigger_update_data":
-  {
+  "event_trigger_update_data":{
     "comment": "This is event trigger update comment"
   },
-  
-    "sequence_credentials":
-  [{
-    "cache": "1",
-    "cycled": true,
-    "increment":  "1",
-    "max_value": "100000",
-    "min_value": "1",
-    "name": "test_empno",
-    "acl":
+
+  "sequence_credentials": [{
+  "cache": "1",
+  "cycled": true,
+  "increment":  "1",
+  "max_value": "100000",
+  "min_value": "1",
+  "name": "test_empno",
+  "acl":
+  [
+    {
+      "grantee":"postgres",
+      "grantor":"postgres",
+      "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
+        }
+      ]
+    }
+  ],
+  "schema_name": "test_schema",
+  "security":  [],
+  "owner":  "postgres",
+  "start_val": "100"
+}],
+  "sequnce_update_data": {
+    "comment": "This is sequence update comment"
+  },
+
+  "domain_data":[
+  {
+    "schema": "test_schema",
+    "basetype": "character",
+    "collation": "pg_catalog.\"POSIX\"",
+    "constraints":
     [
       {
+        "conname":"num",
+        "convalidated":true
+      }
+    ],
+    "lenght": true,
+    "max_value":  2147483647,
+    "min_value": 1,
+    "name": "test_domain",
+    "owner": "postgres",
+    "security": [],
+    "defalt_type": "1",
+    "type_len": "10"
+  }],
+  "domain_update_data": {
+    "comment": "This is domain update comment"
+  },
+
+  "table_credentials":[
+  {
+    "constraint": [],
+    "col_inherit": "[]",
+    "columns": [
+      {
+        "name":"empno",
+        "cltype":"numeric",
+        "attacl":[],
+        "is_primary_key":false,
+        "attoptions":[],
+        "seclabels":[]
+      },
+      {
+        "name":"empname",
+        "cltype":"character[]",
+        "attacl":[],
+        "is_primary_key":false,
+        "attoptions":[],
+        "seclabels":[]
+      },
+      {"name":"DOJ",
+        "cltype":"date[]",
+        "attacl":[],
+        "is_primary_key":false,
+        "attoptions":[],
+        "seclabels":[]
+      }
+    ],
+    "has_constraint": [],
+    "fillfactor": "11",
+    "has_FK": [],
+    "has_toast_tbl": true,
+    "like_constraint":  true,
+    "like_default_value": true,
+    "like_relation": "pg_catalog.pg_tables",
+    "name": "emp",
+    "PK": [],
+    "acl": [
+      {
         "grantee":"postgres",
         "grantor":"postgres",
         "privileges":
         [
           {
-            "privilege_type":"r",
+            "privilege_type":"a",
             "privilege":true,
-            "with_grant":false
+            "with_grant":true
           },
           {
-            "privilege_type":"w",
+            "privilege_type":"r",
             "privilege":true,
             "with_grant":false
           },
           {
-            "privilege_type":"U",
+            "privilege_type":"w",
             "privilege":true,
             "with_grant":false
           }
         ]
       }
     ],
-    "schema_name": "test_schema",
-    "security":  [],
+    "has_oid": true,
     "owner":  "postgres",
-    "start_val": "100"
+    "schema": "test_schema",
+    "sec_acl":  [],
+    "tbscp": "pg_default",
+    "unique_constraint": [],
+    "vacuum_tbl": [
+      {
+        "name":"autovacuum_analyze_scale_factor"
+      },
+      {
+        "name":"autovacuum_analyze_threshold"
+      },
+      {
+        "name":"autovacuum_freeze_max_age"
+      },
+      {
+        "name":"autovacuum_vacuum_cost_delay"
+      },
+      {
+        "name":"autovacuum_vacuum_cost_limit"
+      },
+      {
+        "name":"autovacuum_vacuum_scale_factor"
+      },
+      {
+        "name":"autovacuum_vacuum_threshold"
+      },
+      {
+        "name":"autovacuum_freeze_min_age"
+      },
+      {
+        "name":"autovacuum_freeze_table_age"
+      }
+    ],
+    "vacuum_toast": [
+      {
+        "name":"autovacuum_freeze_max_age"
+      },
+      {
+        "name":"autovacuum_vacuum_cost_delay"
+      },
+      {
+        "name":"autovacuum_vacuum_cost_limit"
+      },
+      {
+        "name":"autovacuum_vacuum_scale_factor"
+      },
+      {
+        "name":"autovacuum_vacuum_threshold"
+      },
+      {
+        "name":"autovacuum_freeze_min_age"
+      },
+      {
+        "name":"autovacuum_freeze_table_age"
+      }
+    ]
   }],
-
-    "sequnce_update_data":
-  {
-    "comment": "This is sequence update comment"
+  "table_update_data": {
+    "comment": "This is table update comment"
   }
-
-
- }
-
-
+}
diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py
index e078eaa..355ceb1 100644
--- a/web/regression/test_utils.py
+++ b/web/regression/test_utils.py
@@ -9,6 +9,7 @@
 
 import os
 import pickle
+
 from test_setup import config_data, pickle_path
 
 
@@ -27,12 +28,14 @@ def get_pickle_id_dict():
         "tfnid": [],  # trigger functions
         "coid": [],  # collation
         "cid": [],  # casts
-        "etid": [], # event_trigger
+        "etid": [],  # event_trigger
         "eid": [],  # extension
         "fid": [],  # FDW
         "fsid": [],  # FRS
         "umid": [],  # user_mapping
-        "seid": []  # sequence
+        "seid": [],  # sequence
+        "doid": [],  # Domain
+        "tid": []  # table
     }
     return pickle_id_dict
 
@@ -47,28 +50,11 @@ def get_ids(url=pickle_path):
     :rtype: dict
     """
 
-    output = open(url, 'rb')
-    ids = pickle.load(output)
-    output.close()
-    return ids
-
-
-# def test_getnodes(tester=None):
-#     # Connect to server and database.
-#
-#     if not tester:
-#         return None
-#
-#     all_id = get_ids()
-#
-#     server_ids = all_id["sid"]
-#     db_ids_dict = all_id["did"][0]
-#
-#     db_con = []
-#     for server_id in server_ids:
-#         db_id = db_ids_dict[int(server_id)]
-#         db_con.append(verify_database(tester, SERVER_GROUP, server_id, db_id))
-#     return db_con
+    if os.path.isfile(url):
+        output = open(url, 'rb')
+        ids = pickle.load(output)
+        output.close()
+        return ids
 
 
 def login_tester_account(tester):
@@ -157,7 +143,56 @@ def delete_parent_id_file():
 
     :return: None
     """
-
     if os.path.isfile(pickle_path):
         os.remove(pickle_path)
 
+
+def drop_objects(tester):
+    if os.path.isfile(pickle_path):
+        db_url = '/browser/database/obj/'
+        table_space_url = '/browser/tablespace/obj/'
+        role_url = '/browser/role/obj/'
+        server_url = '/browser/server/obj/'
+        try:
+            all_id = get_ids()
+            server_ids = all_id['sid']
+            db_ids = all_id['did']
+            if db_ids:
+                db_ids = all_id['did'][0]
+            role_ids = all_id['lrid']
+            if role_ids:
+                role_ids = all_id['lrid'][0]
+            table_space_ids = all_id['tsid']
+            if table_space_ids:
+                table_space_ids = all_id['tsid'][0]
+            for server_id in server_ids:
+                db_id = db_ids[int(server_id)]
+                tablespace_id = None
+                role_id = None
+                if table_space_ids:
+                    tablespace_id = table_space_ids[int(server_id)][0]
+                if role_ids:
+                    role_id = role_ids[int(server_id)]
+                if db_id:
+                    # Delete database
+                    tester.delete(db_url + str(SERVER_GROUP) + '/' +
+                        str(server_id) + '/' + str(db_id),
+                        follow_redirects=True)
+                if tablespace_id:
+                    # Delete tablespace
+                    tester.delete(
+                        table_space_url + str(SERVER_GROUP) + '/' +
+                        str(server_id) + '/' + str(tablespace_id),
+                        follow_redirects=True)
+                if role_id:
+                    # Delete role
+                    tester.delete(role_url + str(SERVER_GROUP) + '/' +
+                        str(server_id) + '/' + str(role_id),
+                        follow_redirects=True)
+                # Delete server
+                tester.delete(server_url + str(server_id))
+        except Exception:
+            pass
+        os.remove(pickle_path)
+    else:
+        pass
