Introduce a test config database for the regression tests, and track/remove objects that are created during testing.

web/pgadmin/browser/server_groups/servers/databases/tests/utils.py

@@ -8,11 +8,9 @@
 # ##########################################################################
 
 import json
-import os
-import pickle
 import uuid
 
-from regression.test_setup import pickle_path, advanced_config_data
+from regression.test_setup import advanced_config_data
 from pgadmin.browser.server_groups.servers.tests import utils as server_utils
 from regression import test_utils as utils
 
@@ -21,26 +19,11 @@ DATABASE_URL = '/browser/database/obj/'
 DATABASE_CONNECT_URL = 'browser/database/connect/'
 
 
-def get_db_data(server_connect_data):
-    """
-    This function is used to get advance config test data for appropriate
-    server
-
-    :param server_connect_data: list of server details
-    :return data: database details
-    :rtype: dict
-    """
-
-    adv_config_data = None
+def get_db_data():
+    """This function returns the database details from json file"""
     data = None
-    db_user = server_connect_data['data']['user']['name']
-
-    # Get the config data of appropriate db user
-    for config_test_data in advanced_config_data['add_database_data']:
-        if db_user == config_test_data['owner']:
-            adv_config_data = config_test_data
-
-    if adv_config_data is not None:
+    if advanced_config_data['add_database_data'] is not None:
+        adv_config_data = advanced_config_data['add_database_data']
         data = {
             "datacl": adv_config_data['privileges_acl'],
             "datconnlimit": adv_config_data['conn_limit'],
@@ -58,67 +41,13 @@ def get_db_data(server_connect_data):
     return data
 
 
-def write_db_id(response_data):
-    """
-    This function writes the server and database related data like server
-    name, server id , database name, database id etc.
-
-    :param response_data: server and databases details
-    :type response_data: dict
-    :return: None
-    """
-
-    db_id = response_data['node']['_id']
-    server_id = response_data['node']['_pid']
-    pickle_id_dict = utils.get_pickle_id_dict()
-    if os.path.isfile(pickle_path):
-        existing_server_id = open(pickle_path, 'rb')
-        tol_server_id = pickle.load(existing_server_id)
-        pickle_id_dict = tol_server_id
-    if 'did' in pickle_id_dict:
-        if pickle_id_dict['did']:
-            # Add the db_id as value in dict
-            pickle_id_dict["did"][0].update({server_id: db_id})
-        else:
-            # Create new dict with server_id and db_id
-            pickle_id_dict["did"].append({server_id: db_id})
-    db_output = open(pickle_path, 'wb')
-    pickle.dump(pickle_id_dict, db_output)
-    db_output.close()
-
-
-def add_database(tester, server_connect_response, server_ids):
-    """
-    This function add the database into servers
-
-    :param tester: flask test client
-    :type tester: flask test object
-    :param server_connect_response: server response
-    :type server_connect_response: dict
-    :param server_ids: server ids
-    :type server_ids: list
-    :return: None
-    """
-
-    for server_connect, server_id in zip(server_connect_response, server_ids):
-        if server_connect['data']['connected']:
-            data = get_db_data(server_connect)
-            db_response = tester.post(DATABASE_URL + str(utils.SERVER_GROUP) +
-                                           "/" + server_id + "/",
-                                           data=json.dumps(data),
-                                           content_type='html/json')
-            assert db_response.status_code == 200
-            response_data = json.loads(db_response.data.decode('utf-8'))
-            write_db_id(response_data)
-
-
-def verify_database(tester, server_group, server_id, db_id):
+def verify_database(self, server_group, server_id, db_id):
     """
     This function verifies that database is exists and whether it connect
     successfully or not
 
-    :param tester: test client
-    :type tester: flask test client object
+    :param self: class object of test case class
+    :type self: class
     :param server_group: server group id
     :type server_group: int
     :param server_id: server id
@@ -130,15 +59,23 @@ def verify_database(tester, server_group, server_id, db_id):
     """
 
     # Verify servers
-    server_utils.verify_server(tester, server_group, server_id)
+    server_utils.connect_server(self, server_id)
 
     # Connect to database
-    con_response = tester.post('{0}{1}/{2}/{3}'.format(
+    db_con = self.tester.post('{0}{1}/{2}/{3}'.format(
         DATABASE_CONNECT_URL, server_group, server_id, db_id),
         follow_redirects=True)
-    temp_db_con = json.loads(con_response.data.decode('utf-8'))
+    self.assertEquals(db_con.status_code, 200)
+    db_con = json.loads(db_con.data.decode('utf-8'))
+    return db_con
 
-    return temp_db_con
+
+def disconnect_database(self, server_id, db_id):
+    """This function disconnect the db"""
+    db_con = self.tester.delete('{0}{1}/{2}/{3}'.format(
+        'browser/database/connect/', utils.SERVER_GROUP, server_id, db_id),
+        follow_redirects=True)
+    self.assertEquals(db_con.status_code, 200)
 
 
 def delete_database(tester):