mirror of
https://github.com/pgadmin-org/pgadmin4.git
synced 2025-02-25 18:55:31 -06:00
Introduce a test config database for the regression tests, and track/remove objects that are created during testing.
This commit is contained in:
Navnath Gadakh
committed by
Dave Page
Dave Page
parent
3807ba047b
commit
d3d8836f61
@@ -7,57 +7,52 @@
|
||||
#
|
||||
# ##################################################################
|
||||
|
||||
import json
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from regression import test_server_dict
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from . import utils as database_utils
|
||||
|
||||
|
||||
class DatabaseAddTestCase(BaseTestGenerator):
|
||||
"""
|
||||
This class will check server group node present on the object browser's
|
||||
tree node by response code.
|
||||
"""
|
||||
"""This class will test the ADD database API"""
|
||||
|
||||
scenarios = [
|
||||
# Fetching default URL for database node.
|
||||
('Check Databases Node URL', dict(url='/browser/database/obj/'))
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function used to add the sever
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
# Add the server
|
||||
server_utils.add_server(cls.tester)
|
||||
|
||||
# Connect to server
|
||||
cls.server_connect_response, cls.server_group, cls.server_ids = \
|
||||
server_utils.connect_server(cls.tester)
|
||||
|
||||
if len(cls.server_connect_response) == 0:
|
||||
raise Exception("No Server(s) connected to add the database!!!")
|
||||
def setUp(self):
|
||||
pass
|
||||
|
||||
def runTest(self):
|
||||
""" This function will add database under 1st server of tree node. """
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
server_utils.connect_server(self, server_id)
|
||||
|
||||
database_utils.add_database(self.tester, self.server_connect_response,
|
||||
self.server_ids)
|
||||
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)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
def tearDown(self):
|
||||
"""
|
||||
This function deletes the added database, added server and the
|
||||
'parent_id.pkl' file which is created in setup()
|
||||
|
||||
:return: None
|
||||
This function delete the database from server added in SQLite and
|
||||
clears the node_info_dict
|
||||
"""
|
||||
|
||||
database_utils.delete_database(cls.tester)
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
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)
|
||||
utils.clear_node_info_dict()
|
||||
|
||||
@@ -6,16 +6,14 @@
|
||||
# This software is released under the PostgreSQL Licence
|
||||
#
|
||||
# ##################################################################
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from regression import test_server_dict
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from . import utils as database_utils
|
||||
|
||||
|
||||
class DatabaseDeleteTestCase(BaseTestGenerator):
|
||||
""" This class will delete the database under last added server. """
|
||||
|
||||
scenarios = [
|
||||
# Fetching default URL for database node.
|
||||
('Check Databases Node URL', dict(url='/browser/database/obj/'))
|
||||
@@ -23,42 +21,23 @@ class DatabaseDeleteTestCase(BaseTestGenerator):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function perform the three tasks
|
||||
1. Add the test server
|
||||
2. Connect to server
|
||||
3. Add the databases
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
# Firstly, add the server
|
||||
server_utils.add_server(cls.tester)
|
||||
|
||||
# Connect to server
|
||||
cls.server_connect_response, cls.server_group, cls.server_ids = \
|
||||
server_utils.connect_server(cls.tester)
|
||||
|
||||
if len(cls.server_connect_response) == 0:
|
||||
raise Exception("No Server(s) connected to add the database!!!")
|
||||
|
||||
# Add database
|
||||
database_utils.add_database(cls.tester, cls.server_connect_response,
|
||||
cls.server_ids)
|
||||
cls.db_id = utils.create_database(cls.server, "test_db_delete")
|
||||
|
||||
def runTest(self):
|
||||
""" This function will delete the database."""
|
||||
|
||||
database_utils.delete_database(self.tester)
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
server_response = server_utils.connect_server(self, server_id)
|
||||
if server_response["data"]["connected"]:
|
||||
db_id = self.db_id
|
||||
response = self.tester.delete(
|
||||
self.url + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id) + '/' + str(db_id),
|
||||
follow_redirects=True)
|
||||
self.assertEquals(response.status_code, 200)
|
||||
else:
|
||||
raise Exception("Could not connect to server to delete the "
|
||||
"database.")
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""
|
||||
This function deletes the added server and the 'parent_id.pkl' file
|
||||
which is created in setup() function.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
pass
|
||||
|
||||
@@ -9,9 +9,7 @@
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from regression.test_setup import config_data
|
||||
from regression.test_utils import get_ids
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from regression import test_server_dict
|
||||
from . import utils as database_utils
|
||||
|
||||
|
||||
@@ -19,66 +17,32 @@ class DatabasesGetTestCase(BaseTestGenerator):
|
||||
"""
|
||||
This class will fetch database added under last added server.
|
||||
"""
|
||||
|
||||
scenarios = [
|
||||
# Fetching default URL for database node.
|
||||
('Check Dat abases Node URL', dict(url='/browser/database/obj/'))
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function perform the three tasks
|
||||
1. Add the test server
|
||||
2. Connect to server
|
||||
3. Add the databases
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
# Firstly, add the server
|
||||
server_utils.add_server(cls.tester)
|
||||
|
||||
# Connect to server
|
||||
cls.server_connect_response, cls.server_group, cls.server_ids = \
|
||||
server_utils.connect_server(cls.tester)
|
||||
|
||||
if len(cls.server_connect_response) == 0:
|
||||
raise Exception("No Server(s) connected to add the database!!!")
|
||||
|
||||
# Add database
|
||||
database_utils.add_database(cls.tester, cls.server_connect_response,
|
||||
cls.server_ids)
|
||||
|
||||
def runTest(self):
|
||||
""" This function will fetch added database. """
|
||||
|
||||
all_id = get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
|
||||
db_ids_dict = all_id["did"][0]
|
||||
srv_grp = config_data['server_group']
|
||||
|
||||
for server_id in server_ids:
|
||||
db_id = db_ids_dict[int(server_id)]
|
||||
db_con = database_utils.verify_database(self.tester, srv_grp,
|
||||
server_id,
|
||||
db_id)
|
||||
if db_con["info"] == "Database connected.":
|
||||
server_data = test_server_dict["database"][0]
|
||||
server_id = server_data["server_id"]
|
||||
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(srv_grp) + '/' + str(server_id) + '/' +
|
||||
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)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""
|
||||
This function deletes the added database, added server
|
||||
and the 'parent_id.pkl' file which is created in setup() function.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
database_utils.delete_database(cls.tester)
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
else:
|
||||
raise Exception("Could not connect to database.")
|
||||
|
||||
@@ -11,17 +11,13 @@ import json
|
||||
|
||||
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 regression.test_utils import get_ids
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from . import utils as database_utils
|
||||
|
||||
|
||||
class DatabasesUpdateTestCase(BaseTestGenerator):
|
||||
"""
|
||||
This class will update the database under last added server.
|
||||
"""
|
||||
|
||||
"""This class will update the database under last added server."""
|
||||
scenarios = [
|
||||
# Fetching default URL for database node.
|
||||
('Check Databases Node', dict(url='/browser/database/obj/'))
|
||||
@@ -29,63 +25,46 @@ class DatabasesUpdateTestCase(BaseTestGenerator):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function perform the three tasks
|
||||
1. Add the test server
|
||||
2. Connect to server
|
||||
3. Add the databases
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
# Firstly, add the server
|
||||
server_utils.add_server(cls.tester)
|
||||
|
||||
# Connect to server
|
||||
cls.server_connect_response, cls.server_group, cls.server_ids = \
|
||||
server_utils.connect_server(cls.tester)
|
||||
|
||||
if len(cls.server_connect_response) == 0:
|
||||
raise Exception("No Server(s) connected to add the database!!!")
|
||||
|
||||
# Add database
|
||||
database_utils.add_database(cls.tester, cls.server_connect_response,
|
||||
cls.server_ids)
|
||||
cls.db_name = "test_db_put"
|
||||
cls.db_id = utils.create_database(cls.server, cls.db_name)
|
||||
|
||||
def runTest(self):
|
||||
""" This function will update the comments field of database."""
|
||||
|
||||
all_id = get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
db_ids_dict = all_id["did"][0]
|
||||
|
||||
for server_id in server_ids:
|
||||
db_id = db_ids_dict[int(server_id)]
|
||||
db_con = database_utils.verify_database(self.tester,
|
||||
utils.SERVER_GROUP,
|
||||
server_id,
|
||||
db_id)
|
||||
if db_con["info"] == "Database connected.":
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
db_id = self.db_id
|
||||
db_con = database_utils.verify_database(self,
|
||||
utils.SERVER_GROUP,
|
||||
server_id,
|
||||
db_id)
|
||||
if db_con["info"] == "Database connected.":
|
||||
try:
|
||||
data = {
|
||||
"comments": advanced_config_data["db_update_data"][0]
|
||||
["comment"],
|
||||
"comments": advanced_config_data["db_update_data"]["comment"],
|
||||
"id": db_id
|
||||
}
|
||||
put_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(put_response.status_code, 200)
|
||||
self.assertEquals(response.status_code, 200)
|
||||
except Exception as exception:
|
||||
raise Exception("Error while updating database details. %s" %
|
||||
exception)
|
||||
finally:
|
||||
# Disconnect database to delete it
|
||||
database_utils.disconnect_database(self, server_id, db_id)
|
||||
else:
|
||||
raise Exception("Error while updating database details.")
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(self):
|
||||
def tearDownClass(cls):
|
||||
"""
|
||||
This function deletes the added server and 'parent_id.pkl' file
|
||||
which is created in setup() function.
|
||||
|
||||
:return: None
|
||||
This function delete the database from server added in SQLite and
|
||||
clears the node_info_dict
|
||||
"""
|
||||
|
||||
database_utils.delete_database(self.tester)
|
||||
server_utils.delete_server(self.tester)
|
||||
utils.delete_parent_id_file()
|
||||
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()
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -7,6 +7,8 @@
|
||||
#
|
||||
# ##########################################################################
|
||||
|
||||
import json
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from . import utils as server_utils
|
||||
@@ -26,17 +28,19 @@ class ServersAddTestCase(BaseTestGenerator):
|
||||
|
||||
def runTest(self):
|
||||
""" This function will add the server under default server group."""
|
||||
|
||||
server_utils.add_server(self.tester)
|
||||
url = "{0}{1}/".format(self.url, utils.SERVER_GROUP)
|
||||
response = self.tester.post(url, data=json.dumps(self.server),
|
||||
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)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""
|
||||
This function deletes the added server and the 'parent_id.pkl' file
|
||||
which is created in setup() function.
|
||||
|
||||
:return: None
|
||||
This function delete the server from SQLite & clears the node_info_dict
|
||||
"""
|
||||
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
server_id = server_utils.get_server_id()
|
||||
utils.delete_server(server_id)
|
||||
utils.clear_node_info_dict()
|
||||
|
||||
@@ -7,10 +7,10 @@
|
||||
#
|
||||
# ##################################################################
|
||||
|
||||
import json
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
|
||||
from . import utils as server_utils
|
||||
|
||||
|
||||
@@ -24,28 +24,27 @@ class ServerDeleteTestCase(BaseTestGenerator):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function is used to add the server
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
# Firstly, add the server
|
||||
server_utils.add_server(cls.tester)
|
||||
"""This function add the server to test the DELETE API"""
|
||||
server_utils.add_server(cls.server)
|
||||
|
||||
def runTest(self):
|
||||
""" This function will get all available servers under object browser
|
||||
and delete the last server using server id."""
|
||||
"""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) + "/"
|
||||
|
||||
server_utils.delete_server(self.tester)
|
||||
if len(servers_info) == 0:
|
||||
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))
|
||||
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 deletes the 'parent_id.pkl' file which is created in
|
||||
setup() function.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
utils.delete_parent_id_file()
|
||||
"""This function calls the clear_node_info_dict() function to clears
|
||||
the node_info_dict"""
|
||||
utils.clear_node_info_dict()
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from . import utils as server_utils
|
||||
from regression import test_server_dict
|
||||
|
||||
|
||||
class ServersGetTestCase(BaseTestGenerator):
|
||||
@@ -23,29 +23,13 @@ class ServersGetTestCase(BaseTestGenerator):
|
||||
('Default Server Node url', dict(url='/browser/server/obj/'))
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function is used to add the server
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
server_utils.add_server(cls.tester)
|
||||
|
||||
def runTest(self):
|
||||
""" This function will fetch the added servers to object browser. """
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
if not server_id:
|
||||
raise Exception("Server not found to test GET API")
|
||||
response = self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id),
|
||||
follow_redirects=True)
|
||||
self.assertEquals(response.status_code, 200)
|
||||
|
||||
server_utils.get_server(self.tester)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""
|
||||
This function deletes the added server and the 'parent_id.pkl' file
|
||||
which is created in setup() function.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
|
||||
@@ -23,55 +23,35 @@ class ServerUpdateTestCase(BaseTestGenerator):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
"""
|
||||
This function perform the four tasks
|
||||
1. Add the test server
|
||||
2. Get the server
|
||||
3. Connect to server
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
# Firstly, add the server
|
||||
server_utils.add_server(cls.tester)
|
||||
|
||||
# Get the server
|
||||
server_utils.get_server(cls.tester)
|
||||
|
||||
# Connect to server
|
||||
cls.server_connect, cls.server_group, cls.server_ids = \
|
||||
server_utils.connect_server(cls.tester)
|
||||
|
||||
if len(cls.server_connect) == 0:
|
||||
raise Exception("No Server(s) connected to update!!!")
|
||||
"""This function add the server to test the PUT API"""
|
||||
server_utils.add_server(cls.server)
|
||||
|
||||
def runTest(self):
|
||||
""" This function will update the server's comment field. """
|
||||
"""This function update the server details"""
|
||||
all_id = utils.get_node_info_dict()
|
||||
servers_info = all_id["sid"]
|
||||
|
||||
for server_id in self.server_ids:
|
||||
data = {
|
||||
"comment":
|
||||
server_utils.config_data['server_update_data'][0][
|
||||
'comment'],
|
||||
"id": server_id
|
||||
}
|
||||
put_response = self.tester.put(
|
||||
self.url + str(self.server_group) + '/' +
|
||||
str(server_id), data=json.dumps(data),
|
||||
content_type='html/json')
|
||||
self.assertEquals(put_response.status_code, 200)
|
||||
if len(servers_info) == 0:
|
||||
raise Exception("No server to update.")
|
||||
|
||||
response_data = json.loads(put_response.data.decode())
|
||||
self.assertTrue(response_data['success'], 1)
|
||||
server_id = list(servers_info[0].keys())[0]
|
||||
data = {
|
||||
"comment":
|
||||
server_utils.config_data['server_update_data'][0][
|
||||
'comment'],
|
||||
"id": server_id
|
||||
}
|
||||
put_response = self.tester.put(
|
||||
self.url + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id), data=json.dumps(data),
|
||||
content_type='html/json')
|
||||
self.assertEquals(put_response.status_code, 200)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""
|
||||
This function deletes the added server and the 'parent_id.pkl' file
|
||||
which is created in setup() function.
|
||||
|
||||
:return: None
|
||||
This function delete the server from SQLite & clears the node_info_dict
|
||||
"""
|
||||
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
server_id = server_utils.get_server_id()
|
||||
utils.delete_server(server_id)
|
||||
utils.clear_node_info_dict()
|
||||
|
||||
@@ -7,154 +7,64 @@
|
||||
#
|
||||
# ##########################################################################
|
||||
|
||||
import json
|
||||
import os
|
||||
import pickle
|
||||
from __future__ import print_function
|
||||
|
||||
import sys
|
||||
import json
|
||||
import sqlite3
|
||||
import config
|
||||
|
||||
from regression import node_info_dict
|
||||
from regression import test_utils as utils
|
||||
from regression.test_setup import pickle_path, config_data
|
||||
from regression.test_setup import config_data
|
||||
|
||||
SERVER_URL = '/browser/server/obj/'
|
||||
SERVER_CONNECT_URL = 'browser/server/connect/'
|
||||
|
||||
|
||||
def write_server_id(response_data, pickle_id_dict):
|
||||
"""
|
||||
This function writes the server's details to file parent_id.pkl
|
||||
def get_server_id():
|
||||
"""This function returns the server id from node_info_dict"""
|
||||
|
||||
:param response_data: server's data
|
||||
:type response_data: list of dictionary
|
||||
:param pickle_id_dict: contains ids of server,database,tables etc.
|
||||
:type pickle_id_dict: dict
|
||||
:return: None
|
||||
"""
|
||||
|
||||
server_id = response_data['node']['_id']
|
||||
if os.path.isfile(pickle_path):
|
||||
existed_server_id = open(pickle_path, 'rb')
|
||||
pickle_id_dict = pickle.load(existed_server_id)
|
||||
|
||||
pickle_id_dict["sid"].append(str(server_id))
|
||||
output = open(pickle_path, 'wb')
|
||||
pickle.dump(pickle_id_dict, output)
|
||||
output.close()
|
||||
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
|
||||
|
||||
|
||||
def add_server(tester):
|
||||
"""
|
||||
This function add the server in the existing server group
|
||||
|
||||
:param tester: test object
|
||||
:type tester: flask test object
|
||||
:return:None
|
||||
"""
|
||||
|
||||
server_group, db_data, pickle_id_dict = utils.get_config_data()
|
||||
url = "{0}{1}/".format(SERVER_URL, server_group)
|
||||
for db_detail in db_data:
|
||||
response = tester.post(url, data=json.dumps(db_detail),
|
||||
content_type='html/json')
|
||||
assert response.status_code == 200
|
||||
response_data = json.loads(response.data.decode('utf-8'))
|
||||
write_server_id(response_data, pickle_id_dict)
|
||||
|
||||
|
||||
def get_server(tester):
|
||||
"""
|
||||
This function gets the added serer details
|
||||
|
||||
:param tester: test client object
|
||||
:type tester: flask test object
|
||||
:return: response_data
|
||||
:rtype: list
|
||||
"""
|
||||
|
||||
all_id = utils.get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
for server_id in server_ids:
|
||||
response = tester.get(SERVER_URL + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id),
|
||||
follow_redirects=True)
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
def connect_server(tester):
|
||||
def connect_server(self, server_id):
|
||||
"""
|
||||
This function used to connect added server
|
||||
|
||||
:param tester:test client object
|
||||
:type tester: flask test object
|
||||
:param add_db_flag: flag for db add test case
|
||||
:type add_db_flag: bool
|
||||
:return: server_connect, server_group, server_id
|
||||
:rtype: server_connect:dict, server_group:dict, server_id:str
|
||||
: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
|
||||
"""
|
||||
|
||||
server_connect = []
|
||||
servers = []
|
||||
server_config = None
|
||||
|
||||
srv_id = utils.get_ids()
|
||||
server_ids = srv_id["sid"]
|
||||
|
||||
# Connect to all servers
|
||||
for server_id in server_ids:
|
||||
response = tester.post(SERVER_CONNECT_URL + str(utils.SERVER_GROUP) +
|
||||
'/' + server_id,
|
||||
data=dict(
|
||||
password=config_data
|
||||
['server_credentials'][0]
|
||||
['db_password']),
|
||||
follow_redirects=True)
|
||||
server_connect_detail = json.loads(response.data.decode('utf-8'))
|
||||
db_user = server_connect_detail['data']['user']['name']
|
||||
server_connect_detail['tablespace_path'] = None
|
||||
|
||||
# Get the server config of appropriate db user
|
||||
for config in config_data['server_credentials']:
|
||||
if db_user == config['db_username']:
|
||||
server_config = config
|
||||
|
||||
if "tablespace_path" in server_config:
|
||||
server_connect_detail['tablespace_path'] = \
|
||||
server_config['tablespace_path']
|
||||
|
||||
server_connect.append(server_connect_detail)
|
||||
servers.append(server_id)
|
||||
return server_connect, utils.SERVER_GROUP, servers
|
||||
response = self.tester.post(SERVER_CONNECT_URL + str(utils.SERVER_GROUP) +
|
||||
'/' + str(server_id),
|
||||
data=dict(password=self.server['db_password']),
|
||||
follow_redirects=True)
|
||||
assert response.status_code == 200
|
||||
response_data = json.loads(response.data.decode('utf-8'))
|
||||
return response_data
|
||||
|
||||
|
||||
def verify_server(tester, server_group, server_id):
|
||||
"""This function verifies that server is connecting or not"""
|
||||
|
||||
response = tester.post(
|
||||
'{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id),
|
||||
data=dict(password=config_data
|
||||
['server_credentials'][0]
|
||||
['db_password']),
|
||||
follow_redirects=True)
|
||||
srv_connect = json.loads(response.data.decode('utf-8'))
|
||||
return srv_connect
|
||||
|
||||
|
||||
def delete_server(tester):
|
||||
"""
|
||||
This function used to delete the added servers
|
||||
|
||||
:param tester: test client object
|
||||
:return: None
|
||||
"""
|
||||
|
||||
all_id = utils.get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
url = SERVER_URL + str(utils.SERVER_GROUP) + "/"
|
||||
|
||||
if len(server_ids) == 0:
|
||||
raise Exception("No server(s) to delete!!!")
|
||||
|
||||
# Call api to delete the servers
|
||||
for server_id in server_ids:
|
||||
response = tester.delete(url + str(server_id))
|
||||
assert response.status_code == 200
|
||||
response_data = json.loads(response.data.decode('utf-8'))
|
||||
assert response_data['success'] == 1
|
||||
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)
|
||||
|
||||
@@ -7,8 +7,14 @@
|
||||
#
|
||||
##############################################################
|
||||
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from importlib import import_module
|
||||
from werkzeug.utils import find_modules
|
||||
|
||||
import config
|
||||
|
||||
|
||||
class TestsGeneratorRegistry(ABCMeta):
|
||||
@@ -43,20 +49,26 @@ class TestsGeneratorRegistry(ABCMeta):
|
||||
|
||||
ABCMeta.__init__(cls, name, bases, d)
|
||||
|
||||
@staticmethod
|
||||
def import_app_modules(module_name):
|
||||
"""As we are running test suite for each server. To catch
|
||||
the test cases, delete the previously imported module
|
||||
"""
|
||||
if str(module_name) in sys.modules.keys():
|
||||
del sys.modules[module_name]
|
||||
import_module(module_name)
|
||||
|
||||
@classmethod
|
||||
def load_generators(cls, pkg):
|
||||
|
||||
cls.registry = dict()
|
||||
|
||||
from importlib import import_module
|
||||
from werkzeug.utils import find_modules
|
||||
import config
|
||||
|
||||
# Check for SERVER mode
|
||||
if config.SERVER_MODE:
|
||||
for module_name in find_modules(pkg, False, True):
|
||||
try:
|
||||
module = import_module(module_name)
|
||||
if "tests." in str(module_name):
|
||||
cls.import_app_modules(module_name)
|
||||
except ImportError:
|
||||
pass
|
||||
else:
|
||||
@@ -65,7 +77,7 @@ class TestsGeneratorRegistry(ABCMeta):
|
||||
# Exclude the test cases in browser node if SERVER_MODE
|
||||
# is False
|
||||
if "pgadmin.browser.tests" not in module_name:
|
||||
module = import_module(module_name)
|
||||
cls.import_app_modules(module_name)
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
@@ -75,6 +87,11 @@ import six
|
||||
@six.add_metaclass(TestsGeneratorRegistry)
|
||||
class BaseTestGenerator(unittest.TestCase):
|
||||
# Defining abstract method which will override by individual testcase.
|
||||
|
||||
@classmethod
|
||||
def setTestServer(cls, server):
|
||||
cls.server = server
|
||||
|
||||
@abstractmethod
|
||||
def runTest(self):
|
||||
pass
|
||||
|
||||
Reference in New Issue
Block a user