diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/fts_configurations_test_data.json b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/fts_configurations_test_data.json
new file mode 100644
index 0000000..9aac0a9
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/fts_configurations_test_data.json
@@ -0,0 +1,291 @@
+{
+  "dependency_dependent_fts_configurations": [
+    {
+      "name": "Get FTS Configuration dependency",
+      "url": "/browser/fts_configuration/dependency/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Get FTS Configuration dependent",
+      "url": "/browser/fts_configuration/dependent/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    }
+  ],
+  "get_fts_configuration_nodes_and_node": [
+    {
+      "name": "Get FTS Configuration nodes",
+      "url": "/browser/fts_configuration/nodes/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Configuration nodes",
+      "url": "/browser/fts_configuration/nodes/",
+      "error_fetching_fts_configuration": true,
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts configuration nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Get FTS Configuration node",
+      "url": "/browser/fts_configuration/nodes/",
+      "is_positive_test": true,
+      "node": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Configuration node",
+      "url": "/browser/fts_configuration/nodes/",
+      "error_fetching_fts_configuration": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts configuration nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Error while fetching FTS Configuration node",
+      "url": "/browser/fts_configuration/nodes/",
+      "error_fetching_fts_configuration": true,
+      "set_wrong_fts_configuration_value": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(True, {'rows': []})"
+      },
+      "expected_data": {
+        "status_code": 410
+      }
+    },
+    {
+      "name": "Get FTS Configuration nodes list",
+      "url": "/browser/fts_configuration/obj/",
+      "is_positive_test": true,
+      "node": false,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Configuration nodes list",
+      "url": "/browser/fts_configuration/obj/",
+      "is_positive_test": false,
+      "error_fetching_fts_configuration": true,
+      "node": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts configuration nodes list')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "fts_configuration_get_sql": [
+    {
+      "name": "Get fts configuration SQL",
+      "url": "/browser/fts_configuration/sql/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching a created fts configuration sql",
+      "url": "/browser/fts_configuration/sql/",
+      "error_fetching_fts_configuration": true,
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching a fts configuration sql')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Error while fetching a created fts configuration sql",
+      "url": "/browser/fts_configuration/sql/",
+      "error_fetching_fts_configuration": true,
+      "is_positive_test": false,
+      "msql": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar",
+        "return_value": "(True, None)"
+      },
+      "expected_data": {
+        "status_code": 410
+      }
+    },
+    {
+      "name": "Get fts configuration msql: With existing fts configuration id.",
+      "url": "/browser/fts_configuration/msql/",
+      "is_positive_test": true,
+      "msql": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200,
+        "error_msg": null,
+        "test_result_data": {}
+      },
+      "is_list": false
+    },
+    {
+      "name": "Error while fetching a created fts configuration sql",
+      "url": "/browser/fts_configuration/msql/",
+      "error_fetching_fts_configuration": true,
+      "is_positive_test": false,
+      "msql": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching a fts configuration sql')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "get_fts_configuration_get_dictionaries": [
+    {
+      "name": "Get fts configuration dictionaries",
+      "url": "/browser/fts_configuration/dictionaries/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Get fts configuration dictionaries",
+      "url": "/browser/fts_configuration/dictionaries/",
+      "is_positive_test": false,
+      "error_fetching_fts_configuration": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching a fts configuration dictionaries')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "get_fts_configuration_get_tokens": [
+    {
+      "name": "Get fts configuration tokens",
+      "url": "/browser/fts_configuration/tokens/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get fts configuration tokens",
+      "url": "/browser/fts_configuration/tokens/",
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar",
+        "return_value": "(False, 0)"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "get_fts_configuration_copy_config": [
+    {
+      "name": "Get fts configuration copy",
+      "url": "/browser/fts_configuration/copyConfig/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Get fts configuration copy negative",
+      "url": "/browser/fts_configuration/copyConfig/",
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching a fts configuration dictionaries')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "get_fts_configuration_parsers": [
+    {
+      "name": "Get fts configuration parsers",
+      "url": "/browser/fts_configuration/parsers/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get fts configuration parsers",
+      "url": "/browser/fts_configuration/parsers/",
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching a fts configuration dictionaries')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "delete_fts_configuration": [
+  ]
+}
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_copyConfig.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_copyConfig.py
new file mode 100644
index 0000000..a33d0df
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_copyConfig.py
@@ -0,0 +1,121 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_configuration_copy_config',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def _fts_configuration_copy_config(self):
+        """
+        This functions returns the fts configuration copy config
+        :return: fts configuration copy config
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            response = self._fts_configuration_copy_config()
+        else:
+            with patch(self.mock_data["function_name"],
+                       return_value=eval(self.mock_data["return_value"])):
+                response = self._fts_configuration_copy_config()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(self.server, self.db_name,
+                                                   self.schema_name,
+                                                   self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_delete.py
index 0a06b62..64a2dff 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_delete.py
@@ -78,6 +78,15 @@ class FTSConfDeleteTestCase(BaseTestGenerator):
             follow_redirects=True)
         self.assertEquals(delete_response.status_code, 200)
 
+        negative_delete_response = self.tester.delete(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            follow_redirects=True)
+        self.assertEquals(negative_delete_response.status_code, 500)
+
     def tearDown(self):
         """This function disconnect the test database."""
 
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_dependency_dependent.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_dependency_dependent.py
new file mode 100644
index 0000000..08a8761
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_dependency_dependent.py
@@ -0,0 +1,118 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import json
+import uuid
+
+from pgadmin.utils import server_utils as server_utils
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression.python_test_utils import test_utils as utils
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'dependency_dependent_fts_configurations',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            response = self.get_dependency_dependent()
+            actual_response_code = response.status_code
+            expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_dependency_dependent(self):
+        """
+        This function returns the fts configuration dependency and dependent
+        :return: fts configuration dependency and dependent
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(self.fts_configuration_id),
+            follow_redirects=True)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(self.server, self.db_name,
+                                                   self.schema_name,
+                                                   self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_dictionaries.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_dictionaries.py
new file mode 100644
index 0000000..fbb71b4
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_dictionaries.py
@@ -0,0 +1,122 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_configuration_get_dictionaries',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def get_fts_configuration_dictionaries(self):
+        """
+        This functions returns the fts configuration dictionaries
+        :return: fts configuration dictionaries
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            response = self.get_fts_configuration_dictionaries()
+        else:
+            if hasattr(self, "error_fetching_fts_configuration"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_configuration_dictionaries()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(self.server, self.db_name,
+                                                   self.schema_name,
+                                                   self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_nodes.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_nodes.py
new file mode 100644
index 0000000..d41af21
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_nodes.py
@@ -0,0 +1,142 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationNodesTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_configuration_nodes_and_node',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def get_fts_configuration_nodes(self):
+        """
+        This functions returns the fts configuration nodes
+        :return: fts configuration nodes
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def get_fts_configuration_node(self):
+        """
+        This functions returns the fts configuration node
+        :return: fts configuration node
+        """
+        if hasattr(self, "set_wrong_fts_configuration_value"):
+            self.fts_configuration_id = 0
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/' +
+            str(self.fts_configuration_id), content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            if hasattr(self, "node"):
+                response = self.get_fts_configuration_node()
+            else:
+                response = self.get_fts_configuration_nodes()
+        else:
+            if hasattr(self, "error_fetching_fts_configuration"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    if hasattr(self, "node"):
+                        response = self.get_fts_configuration_node()
+                    else:
+                        response = self.get_fts_configuration_nodes()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(
+            self.server, self.db_name, self.schema_name,
+            self.fts_configuration_name
+        )
+        database_utils.disconnect_database(self, self.server_id, self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_sql.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_sql.py
new file mode 100644
index 0000000..9cbf986
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_get_sql.py
@@ -0,0 +1,124 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'fts_configuration_get_sql',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def get_fts_configuration_sql(self):
+        """
+        this function fetch event trigger sql
+        :return: event trigger sql details
+        """
+        return self.tester.get(
+            self.url +
+            str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/' +
+            str(self.fts_configuration_id),
+            content_type='html/json'
+        )
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            response = self.get_fts_configuration_sql()
+        else:
+            if hasattr(self, "error_fetching_fts_configuration"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_configuration_sql()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(self.server, self.db_name,
+                                                   self.schema_name,
+                                                   self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_parsers.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_parsers.py
new file mode 100644
index 0000000..4b90882
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_parsers.py
@@ -0,0 +1,121 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_configuration_parsers',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def _fts_configuration_parses(self):
+        """
+        This functions returns the fts configuration parsers
+        :return: fts configuration parsers
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            response = self._fts_configuration_parses()
+        else:
+            with patch(self.mock_data["function_name"],
+                       return_value=eval(self.mock_data["return_value"])):
+                response = self._fts_configuration_parses()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(self.server, self.db_name,
+                                                   self.schema_name,
+                                                   self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_put.py
index d79031c..ffe754e 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_put.py
@@ -90,6 +90,16 @@ class FTSConfPutTestCase(BaseTestGenerator):
             follow_redirects=True)
         self.assertEquals(put_response.status_code, 200)
 
+        negative_put_response = self.tester.put(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            data=json.dumps(data),
+            follow_redirects=True)
+        self.assertEquals(negative_put_response.status_code, 500)
+
     def tearDown(self):
         """This function delete the fts_config and disconnect the test
         database."""
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_tokens.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_tokens.py
new file mode 100644
index 0000000..bb5bb27
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/test_fts_configuration_tokens.py
@@ -0,0 +1,123 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_configurations.tests import utils as fts_config_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_configurations_utils
+
+
+class FTSConfigurationDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS configuration
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_configuration_get_tokens',
+        fts_configurations_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_configuration_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_configuration_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Configuration are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_configuration_id = fts_configurations_utils. \
+            create_fts_configuration(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name
+            )
+
+    def get_fts_configuration_tokens(self):
+        """
+        This functions returns the fts configuration tokens
+        :return: fts configuration tokens
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/' +
+            str(self.fts_configuration_id),
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS configuration under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_configurations_utils.verify_fts_configuration(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Configuration.")
+
+        if self.is_positive_test:
+            response = self.get_fts_configuration_tokens()
+        else:
+            with patch(self.mock_data["function_name"],
+                       return_value=eval(self.mock_data["return_value"])):
+                response = self.get_fts_configuration_tokens()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_config and disconnect the test
+        database."""
+        fts_config_utils.delete_fts_configurations(self.server, self.db_name,
+                                                   self.schema_name,
+                                                   self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/utils.py
index 0e4b550..6e05cf0 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_configurations/tests/utils.py
@@ -12,10 +12,14 @@ from __future__ import print_function
 import os
 import sys
 import traceback
+import json
 
 from regression.python_test_utils.test_utils import get_db_connection
 
 file_name = os.path.basename(__file__)
+CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
+with open(CURRENT_PATH + "/fts_configurations_test_data.json") as data_file:
+    test_cases = json.load(data_file)
 
 
 def create_fts_configuration(server, db_name, schema_name, fts_conf_name):
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/fts_dictionaries_test_data.json b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/fts_dictionaries_test_data.json
new file mode 100644
index 0000000..672524a
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/fts_dictionaries_test_data.json
@@ -0,0 +1,143 @@
+{
+  "get_fts_dictionaries_nodes_and_node": [
+    {
+      "name": "Get FTS Dictionary nodes",
+      "url": "/browser/fts_dictionary/nodes/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Dictionary nodes",
+      "url": "/browser/fts_dictionary/nodes/",
+      "error_fetching_fts_dictionaries": true,
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts dictionary nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Get FTS Dictionary node",
+      "url": "/browser/fts_dictionary/nodes/",
+      "is_positive_test": true,
+      "node": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Dictionary node",
+      "url": "/browser/fts_dictionary/nodes/",
+      "error_fetching_fts_dictionaries": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts dictionary nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Error while fetching FTS Dictionary node",
+      "url": "/browser/fts_dictionary/nodes/",
+      "error_fetching_fts_dictionaries": true,
+      "set_wrong_fts_configuration_value": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(True, {'rows': []})"
+      },
+      "expected_data": {
+        "status_code": 410
+      }
+    },
+    {
+      "name": "Get FTS Dictionary nodes list",
+      "url": "/browser/fts_dictionary/obj/",
+      "is_positive_test": true,
+      "node": false,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Dictionary nodes list",
+      "url": "/browser/fts_dictionary/obj/",
+      "is_positive_test": false,
+      "error_fetching_fts_dictionaries": true,
+      "node": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts dictionary nodes list')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "dependency_dependent_fts_dictionaries": [
+    {
+      "name": "Get FTS Dictionaries dependency",
+      "url": "/browser/fts_dictionary/dependency/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Get FTS Dictionaries dependent",
+      "url": "/browser/fts_dictionary/dependent/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    }
+  ],
+  "fetch_templates_fts_dictionaries": [
+    {
+      "name": "Get FTS Dictionaries templates",
+      "url": "/browser/fts_dictionary/fetch_templates/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Dictionaries templates",
+      "url": "/browser/fts_dictionary/fetch_templates/",
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts dictionary template')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ]
+}
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_delete.py
index dcf12bb..c415ef0 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_delete.py
@@ -81,6 +81,16 @@ class FtsDictionaryDeleteTestCase(BaseTestGenerator):
 
         self.assertEquals(delete_response.status_code, 200)
 
+        negative_delete_response = self.tester.delete(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            follow_redirects=True)
+
+        self.assertEquals(negative_delete_response.status_code, 500)
+
     def tearDown(self):
         """This function disconnect the test database."""
 
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_dependency_dependent.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_dependency_dependent.py
new file mode 100644
index 0000000..6ce55c5
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_dependency_dependent.py
@@ -0,0 +1,118 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import json
+import uuid
+
+from pgadmin.utils import server_utils as server_utils
+from regression import trigger_funcs_utils as fts_dict_funcs_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_dictionaries.tests import utils as fts_dict_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression.python_test_utils import test_utils as utils
+from . import utils as fts_dictionaries_utils
+
+
+class FTSDictionariesDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS dictionaries
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'dependency_dependent_fts_dictionaries',
+        fts_dictionaries_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_dictionaries_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_dictionaries_name = "fts_dictionaries_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Dictionaries are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_dict_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_dictionaries = fts_dictionaries_utils. \
+            create_fts_dictionary(
+                self.server, self.db_name, self.schema_name,
+                self.fts_dictionaries_name)
+
+    def runTest(self):
+        """ This function will add new FTS dictionaries under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_dict_response = fts_dictionaries_utils.verify_fts_dict(
+            self.server, self.db_name, self.fts_dictionaries_name
+        )
+
+        if not fts_dict_response:
+            raise Exception("Could not find the FTS Dictionaries.")
+
+        if self.is_positive_test:
+            response = self.get_dependency_dependent()
+            actual_response_code = response.status_code
+            expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_dependency_dependent(self):
+        """
+        This function returns the fts dictionaries dependency and dependent
+        :return: fts dictionaries dependency and dependent
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(self.fts_dictionaries),
+            follow_redirects=True)
+
+    def tearDown(self):
+        """This function delete the fts_dict and disconnect the test
+        database."""
+        fts_dict_utils.delete_fts_dictionaries(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_dictionaries_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_fetch_templates.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_fetch_templates.py
new file mode 100644
index 0000000..44f64db
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_fetch_templates.py
@@ -0,0 +1,122 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_dictionaries.tests import utils as fts_dict_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_dict_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_dictionaries_utils
+
+
+class FTSDictionariesDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the templates in FTS dictionaries
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'fetch_templates_fts_dictionaries',
+        fts_dictionaries_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_dictionaries_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_dictionaries_name = "fts_dictionaries_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Dictionaries are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_dict_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_dictionaries_id = fts_dictionaries_utils. \
+            create_fts_dictionary(
+                self.server, self.db_name, self.schema_name,
+                self.fts_dictionaries_name)
+
+    def get_fts_dictionaries_fetch_templates(self):
+        """
+        This functions returns the fts dictionaries templates
+        :return: fts dictionaries templates
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS dictionaries under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_dictionaries_utils.verify_fts_dict(
+            self.server, self.db_name, self.fts_dictionaries_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Dictionaries.")
+
+        if self.is_positive_test:
+            response = self.get_fts_dictionaries_fetch_templates()
+        else:
+
+            with patch(self.mock_data["function_name"],
+                       return_value=eval(self.mock_data["return_value"])):
+                response = self.get_fts_dictionaries_fetch_templates()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_dict and disconnect the test
+        database."""
+        fts_dict_utils.delete_fts_dictionaries(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_dictionaries_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_get_nodes.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_get_nodes.py
new file mode 100644
index 0000000..70713a9
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_get_nodes.py
@@ -0,0 +1,142 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_dictionaries.tests import utils as fts_dict_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_dict_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_dictionaries_utils
+
+
+class FTSDictionariesNodesTestCase(BaseTestGenerator):
+    """ This class will get the nodes/node FTS dictionaries
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_dictionaries_nodes_and_node',
+        fts_dictionaries_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_dictionaries_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_configuration_name = "fts_dictionaries_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Dictionaries are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_dict_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_dictionaries_id = fts_dictionaries_utils. \
+            create_fts_dictionary(
+                self.server, self.db_name, self.schema_name,
+                self.fts_configuration_name)
+
+    def get_fts_dictionaries_nodes(self):
+        """
+        This functions returns the fts dictionaries nodes
+        :return: fts dictionaries nodes
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def get_fts_dictionaries_node(self):
+        """
+        This functions returns the fts dictionaries node
+        :return: fts dictionaries node
+        """
+        if hasattr(self, "set_wrong_fts_dictionaries_value"):
+            self.fts_dictionaries_id = 0
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/' +
+            str(self.fts_dictionaries_id), content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS dictionaries under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_dictionaries_utils.verify_fts_dict(
+            self.server, self.db_name, self.fts_configuration_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Dictionaries.")
+
+        if self.is_positive_test:
+            if hasattr(self, "node"):
+                response = self.get_fts_dictionaries_node()
+            else:
+                response = self.get_fts_dictionaries_nodes()
+        else:
+            if hasattr(self, "error_fetching_fts_dictionaries"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    if hasattr(self, "node"):
+                        response = self.get_fts_dictionaries_node()
+                    else:
+                        response = self.get_fts_dictionaries_nodes()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_dict and disconnect the test
+        database."""
+        fts_dict_utils.delete_fts_dictionaries(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_configuration_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_put.py
index d4487ea..f2aa112 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/test_fts_dictionaries_put.py
@@ -89,6 +89,17 @@ class FtsDictionaryPutTestCase(BaseTestGenerator):
 
         self.assertEquals(put_response.status_code, 200)
 
+        negative_put_response = self.tester.put(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            data=json.dumps(data),
+            follow_redirects=True)
+
+        self.assertEquals(negative_put_response.status_code, 500)
+
     def tearDown(self):
         """This function delete the fts dictionaries and disconnect the test
         database."""
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/utils.py
index 61a0448..8c2da7e 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_dictionaries/tests/utils.py
@@ -12,10 +12,14 @@ from __future__ import print_function
 import os
 import sys
 import traceback
+import json
 
 from regression.python_test_utils.test_utils import get_db_connection
 
 file_name = os.path.basename(__file__)
+CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
+with open(CURRENT_PATH + "/fts_dictionaries_test_data.json") as data_file:
+    test_cases = json.load(data_file)
 
 
 def create_fts_dictionary(server, db_name, schema_name, fts_dict_name):
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/fts_parsers_test_data.json b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/fts_parsers_test_data.json
new file mode 100644
index 0000000..c449338
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/fts_parsers_test_data.json
@@ -0,0 +1,248 @@
+{
+  "get_fts_parsers_nodes_and_node": [
+    {
+      "name": "Get FTS Parsers nodes",
+      "url": "/browser/fts_parser/nodes/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Parsers nodes",
+      "url": "/browser/fts_parser/nodes/",
+      "error_fetching_fts_parser": true,
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts Parsers nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Get FTS Dictionary node",
+      "url": "/browser/fts_parser/nodes/",
+      "is_positive_test": true,
+      "node": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Parsers node",
+      "url": "/browser/fts_parser/nodes/",
+      "error_fetching_fts_parser": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts Parsers nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Error while fetching FTS Parsers node",
+      "url": "/browser/fts_parser/nodes/",
+      "error_fetching_fts_parser": true,
+      "set_wrong_fts_parsers_value": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(True, {'rows': []})"
+      },
+      "expected_data": {
+        "status_code": 410
+      }
+    },
+    {
+      "name": "Get FTS Parsers nodes list",
+      "url": "/browser/fts_parser/obj/",
+      "is_positive_test": true,
+      "node": false,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Parsers nodes list",
+      "url": "/browser/fts_parser/obj/",
+      "is_positive_test": false,
+      "error_fetching_fts_parser": true,
+      "node": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts Parsers nodes list')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "dependency_dependent_fts_parsers": [
+    {
+      "name": "Get FTS Parsers dependency",
+      "url": "/browser/fts_parser/dependency/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Get FTS Parsers dependent",
+      "url": "/browser/fts_parser/dependent/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    }
+  ],
+  "head_line_functions_fts_parsers": [
+    {
+      "name": "Get FTS Parsers headline function",
+      "url": "/browser/fts_parser/headline_functions/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Parsers headline function",
+      "url": "/browser/fts_parser/headline_functions/",
+      "is_positive_test": false,
+      "error_fetching_fts_parser": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts parser headline functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "lextype_functions_fts_parsers": [
+    {
+      "name": "Get FTS Parsers lectype function",
+      "url": "/browser/fts_parser/lextype_functions/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Parsers lextype function",
+      "url": "/browser/fts_parser/lextype_functions/",
+      "is_positive_test": false,
+      "error_fetching_fts_parser": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts parser lextype functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "end_functions_fts_parsers": [
+    {
+      "name": "Get FTS Parsers end function",
+      "url": "/browser/fts_parser/end_functions/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Parsers end function",
+      "url": "/browser/fts_parser/end_functions/",
+      "is_positive_test": false,
+      "error_fetching_fts_parser": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts parser end functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "token_functions_fts_parsers": [
+    {
+      "name": "Get FTS Parsers token function",
+      "url": "/browser/fts_parser/token_functions/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Parsers token function",
+      "url": "/browser/fts_parser/token_functions/",
+      "is_positive_test": false,
+      "error_fetching_fts_parser": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts parser token functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "start_functions_fts_parsers": [
+    {
+      "name": "Get FTS Parsers start function",
+      "url": "/browser/fts_parser/start_functions/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Parsers start function",
+      "url": "/browser/fts_parser/start_functions/",
+      "is_positive_test": false,
+      "error_fetching_fts_parser": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts parser start functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ]
+}
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_delete.py
index 3ab813c..4059bdb 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_delete.py
@@ -79,6 +79,16 @@ class FtsParserDeleteTestCase(BaseTestGenerator):
 
         self.assertEquals(delete_response.status_code, 200)
 
+        negative_delete_response = self.tester.delete(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            follow_redirects=True)
+
+        self.assertEquals(negative_delete_response.status_code, 500)
+
     def tearDown(self):
         """This function disconnect the test database."""
 
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_dependency_dependent.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_dependency_dependent.py
new file mode 100644
index 0000000..7789ac2
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_dependency_dependent.py
@@ -0,0 +1,118 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import json
+import uuid
+
+from pgadmin.utils import server_utils as server_utils
+from regression import trigger_funcs_utils as fts_parser_funcs_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression.python_test_utils import test_utils as utils
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'dependency_dependent_fts_parsers',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parsers_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parsers_name = "fts_parsers_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_parser_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parsers = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parsers_name)
+
+    def runTest(self):
+        """ This function will add new FTS dictionaries under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_dict_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parsers_name
+        )
+
+        if not fts_dict_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            response = self.get_dependency_dependent()
+            actual_response_code = response.status_code
+            expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_dependency_dependent(self):
+        """
+        This function returns the fts parsers dependency and dependent
+        :return: fts parsers dependency and dependent
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(self.fts_parsers),
+            follow_redirects=True)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parsers_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_end_functions.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_end_functions.py
new file mode 100644
index 0000000..094e1a0
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_end_functions.py
@@ -0,0 +1,123 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersEndFunctionTestCase(BaseTestGenerator):
+    """ This class will get the end functions FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'end_functions_fts_parsers',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parser_name = "fts_parser_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parser_id = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parser_name)
+
+    def get_fts_parsers_end_functions(self):
+        """
+        This functions returns the fts parsers end functions
+        :return: fts end functions
+        """
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS parsers under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parser_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            response = self.get_fts_parsers_end_functions()
+        else:
+            if hasattr(self, "error_fetching_fts_parser"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_parsers_end_functions()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parser_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_get_nodes.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_get_nodes.py
new file mode 100644
index 0000000..77d6358
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_get_nodes.py
@@ -0,0 +1,142 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersNodesTestCase(BaseTestGenerator):
+    """ This class will get the nodes/node FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_parsers_nodes_and_node',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parser_name = "fts_parser_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parser_id = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parser_name)
+
+    def get_fts_parsers_nodes(self):
+        """
+        This functions returns the fts parsers nodes
+        :return: fts parsers nodes
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def get_fts_parsers_node(self):
+        """
+        This functions returns the fts parsers node
+        :return: fts parsers node
+        """
+        if hasattr(self, "set_wrong_fts_parsers_value"):
+            self.fts_parser_id = 0
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/' +
+            str(self.fts_parser_id), content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS parsers under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parser_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            if hasattr(self, "node"):
+                response = self.get_fts_parsers_node()
+            else:
+                response = self.get_fts_parsers_nodes()
+        else:
+            if hasattr(self, "error_fetching_fts_parser"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    if hasattr(self, "node"):
+                        response = self.get_fts_parsers_node()
+                    else:
+                        response = self.get_fts_parsers_nodes()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parser_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_head_line_functions.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_head_line_functions.py
new file mode 100644
index 0000000..334299b
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_head_line_functions.py
@@ -0,0 +1,123 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersNodesTestCase(BaseTestGenerator):
+    """ This class will get the headline functions FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'head_line_functions_fts_parsers',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parser_name = "fts_parser_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parser_id = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parser_name)
+
+    def get_fts_parsers_headline_functions(self):
+        """
+        This functions returns the fts parsers headline functions
+        :return: fts headline functions node
+        """
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS parsers under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parser_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            response = self.get_fts_parsers_headline_functions()
+        else:
+            if hasattr(self, "error_fetching_fts_parser"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_parsers_headline_functions()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parser_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_lextype_functions.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_lextype_functions.py
new file mode 100644
index 0000000..f523e21
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_lextype_functions.py
@@ -0,0 +1,123 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersLexTypeTestCase(BaseTestGenerator):
+    """ This class will get the lextype functions FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'lextype_functions_fts_parsers',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parser_name = "fts_parser_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parser_id = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parser_name)
+
+    def get_fts_parsers_lextype_functions(self):
+        """
+        This functions returns the fts parsers lextype functions
+        :return: fts lextype functions node
+        """
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS parsers under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parser_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            response = self.get_fts_parsers_lextype_functions()
+        else:
+            if hasattr(self, "error_fetching_fts_parser"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_parsers_lextype_functions()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parser_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_start_functions.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_start_functions.py
new file mode 100644
index 0000000..371758a
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_start_functions.py
@@ -0,0 +1,123 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersEndFunctionTestCase(BaseTestGenerator):
+    """ This class will get the start functions FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'start_functions_fts_parsers',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parser_name = "fts_parser_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parser_id = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parser_name)
+
+    def get_fts_parsers_start_functions(self):
+        """
+        This functions returns the fts parsers start functions
+        :return: fts start functions node
+        """
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS parsers under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parser_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            response = self.get_fts_parsers_start_functions()
+        else:
+            if hasattr(self, "error_fetching_fts_parser"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_parsers_start_functions()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parser_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_token_functions.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_token_functions.py
new file mode 100644
index 0000000..c831e4f
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/test_fts_parser_token_functions.py
@@ -0,0 +1,123 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_parsers.tests import utils as fts_parser_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_config_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_parsers_utils
+
+
+class FTSParsersTokenFunctionTestCase(BaseTestGenerator):
+    """ This class will get the token functions FTS parsers
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'token_functions_fts_parsers',
+        fts_parsers_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_parser_name = "fts_parser_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Parsers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_config_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_parser_id = fts_parsers_utils. \
+            create_fts_parser(
+                self.server, self.db_name, self.schema_name,
+                self.fts_parser_name)
+
+    def get_fts_parsers_token_functions(self):
+        """
+        This functions returns the fts parsers token functions
+        :return: fts token functions node
+        """
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def runTest(self):
+        """ This function will add new FTS parsers under test schema. """
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_conf_response = fts_parsers_utils.verify_fts_parser(
+            self.server, self.db_name, self.fts_parser_name
+        )
+
+        if not fts_conf_response:
+            raise Exception("Could not find the FTS Parsers.")
+
+        if self.is_positive_test:
+            response = self.get_fts_parsers_token_functions()
+        else:
+            if hasattr(self, "error_fetching_fts_parser"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_fts_parsers_token_functions()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def tearDown(self):
+        """This function delete the fts_parser and disconnect the test
+        database."""
+        fts_parser_utils.delete_fts_parser(self.server, self.db_name,
+                                           self.schema_name,
+                                           self.fts_parser_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/utils.py
index 89bff20..52a243c 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_parsers/tests/utils.py
@@ -12,10 +12,14 @@ from __future__ import print_function
 import os
 import sys
 import traceback
+import json
 
 from regression.python_test_utils.test_utils import get_db_connection
 
 file_name = os.path.basename(__file__)
+CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
+with open(CURRENT_PATH + "/fts_parsers_test_data.json") as data_file:
+    test_cases = json.load(data_file)
 
 
 def create_fts_parser(server, db_name, schema_name, fts_parser_name):
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/fts_templates_test_data.json b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/fts_templates_test_data.json
new file mode 100644
index 0000000..2ee0b36
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/fts_templates_test_data.json
@@ -0,0 +1,170 @@
+{
+  "get_fts_template_nodes_and_node": [
+    {
+      "name": "Get FTS Templates nodes",
+      "url": "/browser/fts_template/nodes/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Templates nodes",
+      "url": "/browser/fts_template/nodes/",
+      "error_fetching_fts_template": true,
+      "is_positive_test": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts templates nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Get FTS Templates node",
+      "url": "/browser/fts_template/nodes/",
+      "is_positive_test": true,
+      "node": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while fetching FTS Templates node",
+      "url": "/browser/fts_template/nodes/",
+      "error_fetching_fts_template": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts templates nodes')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    },
+    {
+      "name": "Error while fetching FTS Templates node",
+      "url": "/browser/fts_template/nodes/",
+      "error_fetching_fts_template": true,
+      "set_wrong_fts_templates_value": true,
+      "is_positive_test": false,
+      "node": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray",
+        "return_value": "(True, {'rows': []})"
+      },
+      "expected_data": {
+        "status_code": 410
+      }
+    },
+    {
+      "name": "Get FTS Templates nodes list",
+      "url": "/browser/fts_template/obj/",
+      "is_positive_test": true,
+      "node": false,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Templates nodes list",
+      "url": "/browser/fts_template/obj/",
+      "is_positive_test": false,
+      "error_fetching_fts_template": true,
+      "node": false,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts templates nodes list')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "dependency_dependent_fts_templates": [
+    {
+      "name": "Get FTS Templates dependency",
+      "url": "/browser/fts_template/dependency/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Get FTS Templates dependent",
+      "url": "/browser/fts_template/dependent/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    }
+  ],
+  "get_init_fts_templates": [
+    {
+      "name": "Get FTS Templates get init",
+      "url": "/browser/fts_template/get_init/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Templates get init",
+      "url": "/browser/fts_template/get_init/",
+      "is_positive_test": false,
+      "error_fetching_fts_template": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts template init functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ],
+  "get_lexize_fts_templates": [
+    {
+      "name": "Get FTS Templates get lexize",
+      "url": "/browser/fts_template/get_lexize/",
+      "is_positive_test": true,
+      "mocking_required": false,
+      "mock_data": {},
+      "expected_data": {
+        "status_code": 200
+      }
+    },
+    {
+      "name": "Error while Get FTS Templates get lexize",
+      "url": "/browser/fts_template/get_lexize/",
+      "is_positive_test": false,
+      "error_fetching_fts_template": true,
+      "mocking_required": true,
+      "mock_data": {
+        "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict",
+        "return_value": "(False, 'Mocked Internal Server Error while fetching fts template lexize functions')"
+      },
+      "expected_data": {
+        "status_code": 500
+      }
+    }
+  ]
+}
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_dependency_dependent.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_dependency_dependent.py
new file mode 100644
index 0000000..fa2cecd
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_dependency_dependent.py
@@ -0,0 +1,118 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import json
+import uuid
+
+from pgadmin.utils import server_utils as server_utils
+from regression import trigger_funcs_utils as fts_template_funcs_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_templates.tests import utils as fts_template_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression.python_test_utils import test_utils as utils
+from . import utils as fts_templates_utils
+
+
+class FTSTemplatesDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the dependency and  dependents FTS templates
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'dependency_dependent_fts_templates',
+        fts_templates_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_template_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_templates_name = "fts_template_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Templates are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_template_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_templates = fts_templates_utils. \
+            create_fts_template(
+                self.server, self.db_name, self.schema_name,
+                self.fts_templates_name)
+
+    def runTest(self):
+        """ This function will add new FTS templates under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_dict_response = fts_templates_utils.verify_fts_template(
+            self.server, self.db_name, self.fts_templates_name
+        )
+
+        if not fts_dict_response:
+            raise Exception("Could not find the FTS Templates.")
+
+        if self.is_positive_test:
+            response = self.get_dependency_dependent()
+            actual_response_code = response.status_code
+            expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_dependency_dependent(self):
+        """
+        This function returns the fts templates dependency and dependent
+        :return: fts templates dependency and dependent
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(self.fts_templates),
+            follow_redirects=True)
+
+    def tearDown(self):
+        """This function delete the fts_templates and disconnect the test
+        database."""
+        fts_template_utils.delete_fts_template(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_templates_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_init.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_init.py
new file mode 100644
index 0000000..0cf9930
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_init.py
@@ -0,0 +1,125 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_templates.tests import utils as fts_template_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_template_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_templates_utils
+
+
+class FTSTemplatesGetInitTestCase(BaseTestGenerator):
+    """ This class will get the init FTS templates
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_init_fts_templates',
+        fts_templates_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_template_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_templates_name = "fts_template_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Templates are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_template_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_templates_id = fts_templates_utils. \
+            create_fts_template(
+                self.server, self.db_name, self.schema_name,
+                self.fts_templates_name)
+
+    def runTest(self):
+        """ This function will add new FTS templates under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_dict_response = fts_templates_utils.verify_fts_template(
+            self.server, self.db_name, self.fts_templates_name
+        )
+
+        if not fts_dict_response:
+            raise Exception("Could not find the FTS Templates.")
+
+        if self.is_positive_test:
+            response = self.get_init()
+
+        else:
+            if hasattr(self, "error_fetching_fts_template"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_init()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_init(self):
+        """
+        This function returns the fts templates init
+        :return: fts templates init
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/',
+            follow_redirects=True)
+
+    def tearDown(self):
+        """This function delete the fts_templates and disconnect the test
+        database."""
+        fts_template_utils.delete_fts_template(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_templates_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_lexize.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_lexize.py
new file mode 100644
index 0000000..09a8387
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_lexize.py
@@ -0,0 +1,125 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_templates.tests import utils as fts_template_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_template_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_templates_utils
+
+
+class FTSTemplatesGetLexizeTestCase(BaseTestGenerator):
+    """ This class will get the lexize FTS templates
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_lexize_fts_templates',
+        fts_templates_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_template_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_templates_name = "fts_template_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "FTS Templates are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_template_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_templates_id = fts_templates_utils. \
+            create_fts_template(
+                self.server, self.db_name, self.schema_name,
+                self.fts_templates_name)
+
+    def runTest(self):
+        """ This function will add new FTS templates under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_dict_response = fts_templates_utils.verify_fts_template(
+            self.server, self.db_name, self.fts_templates_name
+        )
+
+        if not fts_dict_response:
+            raise Exception("Could not find the FTS Templates.")
+
+        if self.is_positive_test:
+            response = self.get_lexzie()
+
+        else:
+            if hasattr(self, "error_fetching_fts_template"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    response = self.get_lexzie()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_lexzie(self):
+        """
+        This function returns the fts templates lexize
+        :return: fts templates lexize
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/',
+            follow_redirects=True)
+
+    def tearDown(self):
+        """This function delete the fts_templates and disconnect the test
+        database."""
+        fts_template_utils.delete_fts_template(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_templates_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_nodes.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_nodes.py
new file mode 100644
index 0000000..eca9b96
--- /dev/null
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_template_get_nodes.py
@@ -0,0 +1,143 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2020, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+from __future__ import print_function
+
+import uuid
+from unittest.mock import patch
+
+from pgadmin.browser.server_groups.servers.databases.schemas \
+    .fts_templates.tests import utils as fts_template_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tests import \
+    utils as schema_utils
+from pgadmin.browser.server_groups.servers.databases.tests import \
+    utils as database_utils
+from pgadmin.utils import server_utils as server_utils
+from pgadmin.utils.route import BaseTestGenerator
+from regression import parent_node_dict
+from regression import trigger_funcs_utils as fts_template_funcs_utils
+from regression.python_test_utils import test_utils as utils
+
+from . import utils as fts_templates_utils
+
+
+class FTSTemplatesDependencyDependentTestCase(BaseTestGenerator):
+    """ This class will get the nodes/node FTS templates
+    under test schema. """
+
+    scenarios = utils.generate_scenarios(
+        'get_fts_template_nodes_and_node',
+        fts_templates_utils.test_cases
+    )
+
+    def setUp(self):
+        self.schema_data = parent_node_dict['schema'][-1]
+        self.server_id = self.schema_data['server_id']
+        self.db_id = self.schema_data['db_id']
+        self.schema_name = self.schema_data['schema_name']
+        self.schema_id = self.schema_data['schema_id']
+        self.extension_name = "postgres_fdw"
+        self.db_name = parent_node_dict["database"][-1]["db_name"]
+        self.db_user = self.server["username"]
+        self.func_name = "fts_template_func_%s" % str(uuid.uuid4())[1:8]
+        self.fts_templates_name = "fts_template_delete_%s" % (
+            str(uuid.uuid4())[1:8])
+        server_con = server_utils.connect_server(self, self.server_id)
+        if not server_con["info"] == "Server connected.":
+            raise Exception("Could not connect to server to add resource "
+                            "groups.")
+        server_version = 0
+        if "type" in server_con["data"]:
+            if server_con["data"]["version"] < 90500:
+                message = "Event triggers are not supported by PG9.4 " \
+                          "and PPAS9.4 and below."
+                self.skipTest(message)
+        self.function_info = fts_template_funcs_utils.create_trigger_function(
+            self.server, self.db_name, self.schema_name, self.func_name,
+            server_version)
+        self.fts_templates_id = fts_templates_utils. \
+            create_fts_template(
+                self.server, self.db_name, self.schema_name,
+                self.fts_templates_name)
+
+    def runTest(self):
+        """ This function will add new FTS templates under test schema. """
+
+        db_con = database_utils.connect_database(self,
+                                                 utils.SERVER_GROUP,
+                                                 self.server_id,
+                                                 self.db_id)
+
+        if not db_con["info"] == "Database connected.":
+            raise Exception("Could not connect to database.")
+
+        schema_response = schema_utils.verify_schemas(self.server,
+                                                      self.db_name,
+                                                      self.schema_name)
+        if not schema_response:
+            raise Exception("Could not find the schema.")
+
+        fts_dict_response = fts_templates_utils.verify_fts_template(
+            self.server, self.db_name, self.fts_templates_name
+        )
+
+        if not fts_dict_response:
+            raise Exception("Could not find the FTS Templates.")
+
+        if self.is_positive_test:
+            if hasattr(self, "node"):
+                response = self.get_fts_templates_node()
+            else:
+                response = self.get_fts_templates_nodes()
+        else:
+            if hasattr(self, "error_fetching_fts_template"):
+                with patch(self.mock_data["function_name"],
+                           return_value=eval(self.mock_data["return_value"])):
+                    if hasattr(self, "node"):
+                        response = self.get_fts_templates_node()
+                    else:
+                        response = self.get_fts_templates_nodes()
+
+        actual_response_code = response.status_code
+        expected_response_code = self.expected_data['status_code']
+        self.assertEquals(actual_response_code, expected_response_code)
+
+    def get_fts_templates_nodes(self):
+        """
+        This functions returns the fts templates nodes
+        :return: fts templates nodes
+        """
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/',
+            content_type='html/json')
+
+    def get_fts_templates_node(self):
+        """
+        This functions returns the fts templates node
+        :return: fts templates node
+        """
+        if hasattr(self, "set_wrong_fts_templates_value"):
+            self.fts_templates_id = 0
+
+        return self.tester.get(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' + str(self.schema_id) + '/' +
+            str(self.fts_templates_id), content_type='html/json')
+
+    def tearDown(self):
+        """This function delete the fts_templates and disconnect the test
+        database."""
+        fts_template_utils.delete_fts_template(self.server, self.db_name,
+                                               self.schema_name,
+                                               self.fts_templates_name)
+        database_utils.disconnect_database(self, self.server_id,
+                                           self.db_id)
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_delete.py
index 56e2455..8cfe3a0 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_delete.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_delete.py
@@ -78,6 +78,16 @@ class FtsTemplateDeleteTestCase(BaseTestGenerator):
 
         self.assertEquals(delete_response.status_code, 200)
 
+        negative_delete_response = self.tester.delete(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            follow_redirects=True)
+
+        self.assertEquals(negative_delete_response.status_code, 500)
+
     def tearDown(self):
         """This function disconnect the test database."""
 
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_put.py
index b404ba4..55299e7 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_put.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/test_fts_templates_put.py
@@ -87,6 +87,17 @@ class FtsTemplatePutTestCase(BaseTestGenerator):
 
         self.assertEquals(put_response.status_code, 200)
 
+        negative_put_response = self.tester.put(
+            self.url + str(utils.SERVER_GROUP) + '/' +
+            str(self.server_id) + '/' +
+            str(self.db_id) + '/' +
+            str(self.schema_id) + '/' +
+            str(0),
+            data=json.dumps(data),
+            follow_redirects=True)
+
+        self.assertEquals(negative_put_response.status_code, 500)
+
     def tearDown(self):
         """This function delete the fts_template and disconnect the test
                         database."""
diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/utils.py
index d384fd3..f79f415 100644
--- a/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/utils.py
+++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/fts_templates/tests/utils.py
@@ -12,10 +12,14 @@ from __future__ import print_function
 import os
 import sys
 import traceback
+import json
 
 from regression.python_test_utils.test_utils import get_db_connection
 
 file_name = os.path.basename(__file__)
+CURRENT_PATH = os.path.dirname(os.path.realpath(__file__))
+with open(CURRENT_PATH + "/fts_templates_test_data.json") as data_file:
+    test_cases = json.load(data_file)
 
 
 def create_fts_template(server, db_name, schema_name, fts_temp_name):
