Enhanced summary output for the test suite.

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

@@ -29,25 +29,29 @@ class DatabaseAddTestCase(BaseTestGenerator):
 
     def runTest(self):
         """ This function will add database under 1st server of tree node. """
+        self.db_name = ''
         server_id = test_server_dict["server"][0]["server_id"]
-        server_utils.connect_server(self, server_id)
-
-        data = database_utils.get_db_data()
-        self.db_name = data['name']
-        response = self.tester.post(self.url + str(utils.SERVER_GROUP) +
-                                    "/" + str(server_id) + "/",
-                                    data=json.dumps(data),
-                                    content_type='html/json')
-        self.assertEquals(response.status_code, 200)
-        response_data = json.loads(response.data.decode('utf-8'))
-        db_id = response_data['node']['_id']
-        db_dict = {"db_id": db_id, "db_name": self.db_name}
-        utils.write_node_info(int(server_id), "did", db_dict)
+        server_response = server_utils.connect_server(self, server_id)
+        if server_response["info"] == "Server connected.":
+            db_owner = server_response['data']['user']['name']
+            self.data = database_utils.get_db_data(db_owner)
+            self.db_name = self.data['name']
+            response = self.tester.post(self.url + str(utils.SERVER_GROUP) +
+                                        "/" + str(server_id) + "/",
+                                        data=json.dumps(self.data),
+                                        content_type='html/json')
+            self.assertEquals(response.status_code, 200)
+            response_data = json.loads(response.data.decode('utf-8'))
+            db_id = response_data['node']['_id']
+            db_dict = {"db_id": db_id, "db_name": self.db_name}
+            utils.write_node_info(int(server_id), "did", db_dict)
+        else:
+            raise Exception("Error while connecting server to add the"
+                            " database.")
 
     def tearDown(self):
         """
-        This function delete the database from server added in SQLite and
-        clears the node_info_dict
+        This function delete the database from server added in SQLite.
         """
         connection = utils.get_db_connection(self.server['db'],
                                              self.server['username'],
@@ -55,4 +59,3 @@ class DatabaseAddTestCase(BaseTestGenerator):
                                              self.server['host'],
                                              self.server['port'])
         utils.drop_database(connection, self.db_name)
-        utils.clear_node_info_dict()

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

@@ -6,6 +6,8 @@
 # This software is released under the PostgreSQL Licence
 #
 # ##################################################################
+import uuid
+
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
 from regression import test_server_dict
@@ -19,9 +21,9 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
         ('Check Databases Node URL', dict(url='/browser/database/obj/'))
     ]
 
-    @classmethod
-    def setUpClass(cls):
-        cls.db_id = utils.create_database(cls.server, "test_db_delete")
+    def setUp(self):
+        self.db_name = "db_delete_%s" % str(uuid.uuid4())[1:4],
+        self.db_id = utils.create_database(self.server, self.db_name)
 
     def runTest(self):
         """ This function will delete the database."""
@@ -38,6 +40,11 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
             raise Exception("Could not connect to server to delete the "
                             "database.")
 
-    @classmethod
-    def tearDownClass(cls):
-        pass
+    def tearDown(self):
+        """This function drop the added database"""
+        connection = utils.get_db_connection(self.server['db'],
+                                             self.server['username'],
+                                             self.server['db_password'],
+                                             self.server['host'],
+                                             self.server['port'])
+        utils.drop_database(connection, self.db_name)

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

@@ -19,30 +19,30 @@ class DatabasesGetTestCase(BaseTestGenerator):
     """
     scenarios = [
         # Fetching default URL for database node.
-        ('Check Dat abases Node URL', dict(url='/browser/database/obj/'))
+        ('Check Databases Node URL', dict(url='/browser/database/obj/'))
     ]
 
     def runTest(self):
         """ This function will fetch added database. """
         server_data = test_server_dict["database"][0]
-        server_id = server_data["server_id"]
-        db_id = server_data['db_id']
+        self.server_id = server_data["server_id"]
+        self.db_id = server_data['db_id']
         db_con = database_utils.verify_database(self,
                                                 utils.SERVER_GROUP,
-                                                server_id,
-                                                db_id)
-        if db_con["info"] == "Database connected.":
-            try:
-                response = self.tester.get(
-                    self.url + str(utils.SERVER_GROUP) + '/' + str(
-                        server_id) + '/' +
-                    str(db_id), follow_redirects=True)
-                self.assertEquals(response.status_code, 200)
-            except Exception as exception:
-                raise Exception("Error while getting database. %s" % exception)
-            finally:
-                # Disconnect database to delete it
-                database_utils.disconnect_database(self, server_id, db_id)
-
-        else:
-            raise Exception("Could not connect to database.")
+                                                self.server_id,
+                                                self.db_id)
+        try:
+            if db_con["info"] == "Database connected.":
+                    response = self.tester.get(
+                        self.url + str(utils.SERVER_GROUP) + '/' + str(
+                            self.server_id) + '/' +
+                        str(self.db_id), follow_redirects=True)
+                    self.assertEquals(response.status_code, 200)
+            else:
+                raise Exception("Could not connect to database.")
+        except Exception as exception:
+            raise Exception("Error while getting database. %s" % exception)
+        finally:
+            # Disconnect database to delete it
+            database_utils.disconnect_database(self, self.server_id,
+                                               self.db_id)

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

@@ -8,11 +8,11 @@
 # ##################################################################
 
 import json
+import uuid
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
 from regression import test_server_dict
-from regression.test_setup import advanced_config_data
 from . import utils as database_utils
 
 
@@ -23,10 +23,9 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
         ('Check Databases Node', dict(url='/browser/database/obj/'))
     ]
 
-    @classmethod
-    def setUpClass(cls):
-        cls.db_name = "test_db_put"
-        cls.db_id = utils.create_database(cls.server, cls.db_name)
+    def setUp(self):
+        self.db_name = "test_db_put_%s" % str(uuid.uuid4())[1:8],
+        self.db_id = utils.create_database(self.server, self.db_name)
 
     def runTest(self):
         """ This function will update the comments field of database."""
@@ -39,10 +38,11 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
         if db_con["info"] == "Database connected.":
             try:
                 data = {
-                    "comments": advanced_config_data["db_update_data"]["comment"],
+                    "comments": "This is db update comment",
                     "id": db_id
                 }
-                response = self.tester.put(self.url + str(utils.SERVER_GROUP) + '/' + str(
+                response = self.tester.put(
+                    self.url + str(utils.SERVER_GROUP) + '/' + str(
                         server_id) + '/' +
                     str(db_id), data=json.dumps(data), follow_redirects=True)
                 self.assertEquals(response.status_code, 200)
@@ -55,16 +55,13 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
         else:
             raise Exception("Error while updating database details.")
 
-    @classmethod
-    def tearDownClass(cls):
+    def tearDown(self):
         """
-        This function delete the database from server added in SQLite and
-        clears the node_info_dict
+        This function delete the database from server added in SQLite.
         """
-        connection = utils.get_db_connection(cls.server['db'],
-                                             cls.server['username'],
-                                             cls.server['db_password'],
-                                             cls.server['host'],
-                                             cls.server['port'])
-        utils.drop_database(connection, cls.db_name)
-        utils.clear_node_info_dict()
+        connection = utils.get_db_connection(self.server['db'],
+                                             self.server['username'],
+                                             self.server['db_password'],
+                                             self.server['host'],
+                                             self.server['port'])
+        utils.drop_database(connection, self.db_name)

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

@@ -19,28 +19,103 @@ DATABASE_URL = '/browser/database/obj/'
 DATABASE_CONNECT_URL = 'browser/database/connect/'
 
 
-def get_db_data():
-    """This function returns the database details from json file"""
-    data = 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'],
-            "datowner": adv_config_data['owner'],
-            "deffuncacl": adv_config_data['fun_acl'],
-            "defseqacl": adv_config_data['seq_acl'],
-            "deftblacl": adv_config_data['tbl_acl'],
-            "deftypeacl": adv_config_data['type_acl'],
-            "encoding": adv_config_data['encoding'],
-            "name": str(uuid.uuid4())[1:8],
-            "privileges": adv_config_data['privileges'],
-            "securities": adv_config_data['securities'],
-            "variables": adv_config_data['variables']
-        }
+def get_db_data(db_owner):
+    """
+    This function returns the database details in dict format
+    """
+    data = {
+        "datconnlimit": -1,
+        "datowner": db_owner,
+        "deffuncacl": [
+      {
+        "grantee": db_owner,
+        "grantor": db_owner,
+        "privileges": [
+          {
+            "privilege_type": "X",
+            "privilege": True,
+            "with_grant": False
+          }
+        ]
+      }
+    ],
+        "defseqacl": [
+      {
+        "grantee": db_owner,
+        "grantor": db_owner,
+        "privileges": [
+          {
+            "privilege_type": "r",
+            "privilege": True,
+            "with_grant": False
+          },
+          {
+            "privilege_type": "w",
+            "privilege": True,
+            "with_grant": False
+          },
+          {
+            "privilege_type": "U",
+            "privilege": True,
+            "with_grant": False
+          }
+        ]
+      }
+    ],
+        "deftblacl": [
+      {
+        "grantee": db_owner,
+        "grantor": db_owner,
+        "privileges": [
+          {
+            "privilege_type": "a",
+            "privilege": True,
+            "with_grant": True
+          },
+          {
+            "privilege_type": "r",
+            "privilege": True,
+            "with_grant": False
+          }
+        ]
+      }
+    ],
+        "deftypeacl": [
+      {
+        "grantee": db_owner,
+        "grantor": db_owner,
+        "privileges": [
+          {
+            "privilege_type": "U",
+            "privilege": True,
+            "with_grant": False
+          }
+        ]
+      }
+    ],
+        "encoding": "UTF8",
+        "name": "db_add_%s" % str(uuid.uuid4())[1:4],
+        "privileges": [],
+        "securities": [],
+        "variables": []
+    }
     return data
 
 
+def create_database(connection, db_name):
+    """This function used to create database"""
+    try:
+        old_isolation_level = connection.isolation_level
+        connection.set_isolation_level(0)
+        pg_cursor = connection.cursor()
+        pg_cursor.execute("CREATE DATABASE %s" % db_name)
+        connection.set_isolation_level(old_isolation_level)
+        connection.commit()
+        return pg_cursor
+    except Exception as exception:
+        raise Exception("Error while creating database. %s" % exception)
+
+
 def verify_database(self, server_group, server_id, db_id):
     """
     This function verifies that database is exists and whether it connect

web/pgadmin/browser/server_groups/servers/tests/test_server_add.py

@@ -11,7 +11,6 @@ import json
 
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from . import utils as server_utils
 
 
 class ServersAddTestCase(BaseTestGenerator):
@@ -22,8 +21,7 @@ class ServersAddTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    @classmethod
-    def setUpClass(cls):
+    def setUp(self):
         pass
 
     def runTest(self):
@@ -33,14 +31,9 @@ class ServersAddTestCase(BaseTestGenerator):
                                     content_type='html/json')
         self.assertEquals(response.status_code, 200)
         response_data = json.loads(response.data.decode('utf-8'))
-        server_id = response_data['node']['_id']
-        utils.write_node_info(int(server_id), "sid", self.server)
+        self.server_id = response_data['node']['_id']
+        utils.write_node_info(int(self.server_id), "sid", self.server)
 
-    @classmethod
-    def tearDownClass(cls):
-        """
-        This function delete the server from SQLite & clears the node_info_dict
-        """
-        server_id = server_utils.get_server_id()
-        utils.delete_server(server_id)
-        utils.clear_node_info_dict()
+    def tearDown(self):
+        """This function delete the server from SQLite """
+        utils.delete_server(self.server_id)

web/pgadmin/browser/server_groups/servers/tests/test_server_delete.py

@@ -6,12 +6,8 @@
 # This software is released under the PostgreSQL Licence
 #
 # ##################################################################
-
-import json
-
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from . import utils as server_utils
 
 
 class ServerDeleteTestCase(BaseTestGenerator):
@@ -22,29 +18,19 @@ class ServerDeleteTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    @classmethod
-    def setUpClass(cls):
+    def setUp(self):
         """This function add the server to test the DELETE API"""
-        server_utils.add_server(cls.server)
+        self.server_id = utils.create_server(self.server)
 
     def runTest(self):
         """This function deletes the added server"""
-        all_id = utils.get_node_info_dict()
-        servers_info = all_id["sid"]
         url = self.url + str(utils.SERVER_GROUP) + "/"
-
-        if len(servers_info) == 0:
+        if not self.server_id:
             raise Exception("No server to delete!!!")
-
         # Call API to delete the servers
-        server_id = list(servers_info[0].keys())[0]
-        response = self.tester.delete(url + str(server_id))
+        response = self.tester.delete(url + str(self.server_id))
         self.assertEquals(response.status_code, 200)
-        response_data = json.loads(response.data.decode('utf-8'))
-        self.assertEquals(response_data['success'], 1)
 
-    @classmethod
-    def tearDownClass(cls):
-        """This function calls the clear_node_info_dict() function to clears
-        the node_info_dict"""
-        utils.clear_node_info_dict()
+    def tearDown(self):
+        """This function delete the server from SQLite """
+        utils.delete_server(self.server_id)

web/pgadmin/browser/server_groups/servers/tests/test_server_put.py

@@ -10,7 +10,6 @@
 import json
 from pgadmin.utils.route import BaseTestGenerator
 from regression import test_utils as utils
-from . import utils as server_utils
 
 
 class ServerUpdateTestCase(BaseTestGenerator):
@@ -21,37 +20,21 @@ class ServerUpdateTestCase(BaseTestGenerator):
         ('Default Server Node url', dict(url='/browser/server/obj/'))
     ]
 
-    @classmethod
-    def setUpClass(cls):
+    def setUp(self):
         """This function add the server to test the PUT API"""
-        server_utils.add_server(cls.server)
+        self.server_id = utils.create_server(self.server)
 
     def runTest(self):
         """This function update the server details"""
-        all_id = utils.get_node_info_dict()
-        servers_info = all_id["sid"]
-
-        if len(servers_info) == 0:
+        if not self.server_id:
             raise Exception("No server to update.")
-
-        server_id = list(servers_info[0].keys())[0]
-        data = {
-            "comment":
-                server_utils.config_data['server_update_data'][0][
-                    'comment'],
-            "id": server_id
-        }
+        data = {"comment": self.server['comment'], "id": self.server_id}
         put_response = self.tester.put(
             self.url + str(utils.SERVER_GROUP) + '/' +
-            str(server_id), data=json.dumps(data),
+            str(self.server_id), data=json.dumps(data),
             content_type='html/json')
         self.assertEquals(put_response.status_code, 200)
 
-    @classmethod
-    def tearDownClass(cls):
-        """
-        This function delete the server from SQLite & clears the node_info_dict
-        """
-        server_id = server_utils.get_server_id()
-        utils.delete_server(server_id)
-        utils.clear_node_info_dict()
+    def tearDown(self):
+        """This function delete the server from SQLite"""
+        utils.delete_server(self.server_id)

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

@@ -19,17 +19,7 @@ from regression import test_utils as utils
 from regression.test_setup import config_data
 
 SERVER_URL = '/browser/server/obj/'
-SERVER_CONNECT_URL = 'browser/server/connect/'
-
-
-def get_server_id():
-    """This function returns the server id from node_info_dict"""
-
-    server_id = 0
-    if "sid" in node_info_dict:
-        if node_info_dict['sid']:
-            server_id = list(node_info_dict['sid'][0].keys())[0]
-    return server_id
+SERVER_CONNECT_URL = '/browser/server/connect/'
 
 
 def connect_server(self, server_id):
@@ -37,8 +27,8 @@ def connect_server(self, server_id):
     This function used to connect added server
     :param self: class object of server's test class
     :type self: class
-    :param server_id: flag for db add test case
-    :type server_id: bool
+    :param server_id: server id
+    :type server_id: str
     """
     response = self.tester.post(SERVER_CONNECT_URL + str(utils.SERVER_GROUP) +
                                 '/' + str(server_id),
@@ -47,24 +37,3 @@ def connect_server(self, server_id):
     assert response.status_code == 200
     response_data = json.loads(response.data.decode('utf-8'))
     return response_data
-
-
-def add_server(server):
-    try:
-        conn = sqlite3.connect(config.SQLITE_PATH)
-        cur = conn.cursor()
-        server_details = (
-            1, utils.SERVER_GROUP, server['name'], server['host'],
-            server['port'], server['db'], server['username'],
-            server['role'], server['sslmode'],
-            server['comment'])
-        cur.execute(
-            'INSERT INTO server (user_id, servergroup_id, name, host, '
-            'port, maintenance_db, username, role, ssl_mode,'
-            ' comment) VALUES (?,?,?,?,?,?,?,?,?,?)', server_details)
-        server_id = cur.lastrowid
-        # Add server info to node_info_dict
-        utils.write_node_info(int(server_id), "sid", server)
-        conn.commit()
-    except Exception as err:
-        raise Exception(err)