mirror of
https://github.com/pgadmin-org/pgadmin4.git
synced 2025-02-25 18:55:31 -06:00
Update role and tablespace tests to cleanup properly following a failure.
This commit is contained in:
Navnath Gadakh
committed by
Dave Page
Dave Page
parent
a0a6428e86
commit
a4aae4c245
@@ -6,50 +6,68 @@
|
||||
# This software is released under the PostgreSQL Licence
|
||||
#
|
||||
# ##################################################################
|
||||
from __future__ import print_function
|
||||
|
||||
import os
|
||||
import sys
|
||||
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 tablespace_utils
|
||||
|
||||
|
||||
class TableSpaceAddTestCase(BaseTestGenerator):
|
||||
"""This class will add tablespace node under server"""
|
||||
|
||||
scenarios = [
|
||||
# Fetching default URL for tablespace node.
|
||||
('Check Tablespace Node', dict(url='/browser/tablespace/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 roles!!!")
|
||||
def setUp(self):
|
||||
self.tablespace_name = ''
|
||||
if not self.server['tablespace_path']\
|
||||
or self.server['tablespace_path'] is None:
|
||||
message = "Skipped tablespace add test case. Tablespace path" \
|
||||
" not configured for server: %s" % self.server['name']
|
||||
# Skip the test case if tablespace_path not found.
|
||||
self.skipTest(message)
|
||||
|
||||
def runTest(self):
|
||||
"""This function test the add tablespace scenario"""
|
||||
"""This function test the add tablespace API"""
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
server_response = server_utils.connect_server(self, server_id)
|
||||
if not server_response['data']['connected']:
|
||||
raise Exception("Unable to connect server to get tablespace.")
|
||||
|
||||
tablespace_status = tablespace_utils.add_table_space(
|
||||
self.tester, self.server_connect_response, self.server_group,
|
||||
self.server_ids)
|
||||
db_owner = server_response['data']['user']['name']
|
||||
table_space_path = self.server['tablespace_path']
|
||||
data = tablespace_utils.get_tablespace_data(
|
||||
table_space_path, db_owner)
|
||||
self.tablespace_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'))
|
||||
tablespace_id = response_data['node']['_id']
|
||||
tablespace_dict = {"tablespace_id": tablespace_id,
|
||||
"tablespace_name": self.tablespace_name,
|
||||
"server_id": server_id}
|
||||
utils.write_node_info(tablespace_id, "tsid", tablespace_dict)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""This function deletes the tablespaces,server and parent_id file"""
|
||||
|
||||
tablespace_utils.delete_table_space(cls.tester)
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
def tearDown(self):
|
||||
"""
|
||||
This function delete the tablespace from server added in SQLite and
|
||||
clears the node_info_dict
|
||||
"""
|
||||
connection = utils.get_db_connection(self.server['db'],
|
||||
self.server['username'],
|
||||
self.server['db_password'],
|
||||
self.server['host'],
|
||||
self.server['port'])
|
||||
tablespace_utils.delete_tablespace(connection, self.tablespace_name)
|
||||
|
||||
@@ -6,11 +6,13 @@
|
||||
# This software is released under the PostgreSQL Licence
|
||||
#
|
||||
# ##################################################################
|
||||
|
||||
from __future__ import print_function
|
||||
import uuid
|
||||
import json
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from regression import test_server_dict
|
||||
from . import utils as tablespace_utils
|
||||
|
||||
|
||||
@@ -22,37 +24,39 @@ class TableSpaceDeleteTestCase(BaseTestGenerator):
|
||||
('Check Tablespace Node', dict(url='/browser/tablespace/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 roles!!!")
|
||||
|
||||
# Add tablespace
|
||||
tablespace_utils.add_table_space(cls.tester,
|
||||
cls.server_connect_response,
|
||||
cls.server_group, cls.server_ids)
|
||||
def setUp(self):
|
||||
if not self.server['tablespace_path']\
|
||||
or self.server['tablespace_path'] is None:
|
||||
message = "Skipped tablespace delete test case. Tablespace path" \
|
||||
" not configured for server: %s" % self.server['name']
|
||||
# Skip the test case if tablespace_path not found.
|
||||
self.skipTest(message)
|
||||
self.tablespace_name = "tablespace_delete_%s" % str(uuid.uuid4())[1:6]
|
||||
self.tablespace_id = tablespace_utils.create_tablespace(
|
||||
self.server, self.tablespace_name)
|
||||
|
||||
def runTest(self):
|
||||
"""This function tests the delete table space scenario"""
|
||||
"""This function tests the delete table space api"""
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
tablespace_count = tablespace_utils.verify_table_space(
|
||||
self.server, self.tablespace_name)
|
||||
if tablespace_count == 0:
|
||||
raise Exception("No tablespace(s) to delete!!!")
|
||||
|
||||
tablespace_utils.delete_table_space(self.tester)
|
||||
response = self.tester.delete(self.url + str(utils.SERVER_GROUP)
|
||||
+ '/' + str(server_id) + '/'
|
||||
+ str(self.tablespace_id),
|
||||
follow_redirects=True)
|
||||
self.assertEquals(response.status_code, 200)
|
||||
delete_response_data = json.loads(response.data.decode('utf-8'))
|
||||
self.assertEquals(delete_response_data['success'], 1)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""This function deletes the server and parent id file"""
|
||||
def tearDown(self):
|
||||
"""This function deletes the tablespace"""
|
||||
connection = utils.get_db_connection(self.server['db'],
|
||||
self.server['username'],
|
||||
self.server['db_password'],
|
||||
self.server['host'],
|
||||
self.server['port'])
|
||||
tablespace_utils.delete_tablespace(connection, self.tablespace_name)
|
||||
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
|
||||
@@ -6,9 +6,11 @@
|
||||
# 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
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from . import utils as tablespace_utils
|
||||
|
||||
@@ -21,58 +23,39 @@ class TablespaceGetTestCase(BaseTestGenerator):
|
||||
('Check Tablespace Node', dict(url='/browser/tablespace/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 roles!!!")
|
||||
|
||||
# Add tablespace
|
||||
tablespace_utils.add_table_space(cls.tester,
|
||||
cls.server_connect_response,
|
||||
cls.server_group, cls.server_ids)
|
||||
def setUp(self):
|
||||
if not self.server['tablespace_path']\
|
||||
or self.server['tablespace_path'] is None:
|
||||
message = "Skipped tablespace get test case. Tablespace path" \
|
||||
" not configured for server: %s" % self.server['name']
|
||||
# Skip the test case if tablespace_path not found.
|
||||
self.skipTest(message)
|
||||
self.tablespace_name = "tablespace_delete_%s" % str(uuid.uuid4())[1:6]
|
||||
self.tablespace_id = tablespace_utils.create_tablespace(
|
||||
self.server, self.tablespace_name)
|
||||
|
||||
def runTest(self):
|
||||
"""This function test the get table space scenario"""
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
server_response = server_utils.connect_server(self, server_id)
|
||||
if not server_response['data']['connected']:
|
||||
raise Exception("Unable to connect server to get tablespace.")
|
||||
|
||||
tablespace_ids_dict = None
|
||||
all_id = utils.get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
if "tsid" in all_id and all_id["tsid"]:
|
||||
tablespace_ids_dict = all_id["tsid"][0]
|
||||
tablespace_count = tablespace_utils.verify_table_space(
|
||||
self.server, self.tablespace_name)
|
||||
if tablespace_count == 0:
|
||||
raise Exception("No tablespace(s) to update!!!")
|
||||
response = self.tester.get(
|
||||
self.url + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id) + '/' + str(self.tablespace_id),
|
||||
follow_redirects=True)
|
||||
self.assertEquals(response.status_code, 200)
|
||||
|
||||
if tablespace_ids_dict:
|
||||
for server_id in server_ids:
|
||||
tablespace_id = tablespace_ids_dict[int(server_id)]
|
||||
server_response = server_utils.verify_server(self.tester,
|
||||
utils.SERVER_GROUP,
|
||||
server_id)
|
||||
if server_response['data']['connected']:
|
||||
tablespace_utils.verify_table_space(
|
||||
self.tester, utils.SERVER_GROUP, server_id, tablespace_id)
|
||||
response = self.tester.get(
|
||||
self.url + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id) + '/' + str(
|
||||
tablespace_id),
|
||||
follow_redirects=True)
|
||||
self.assertEquals(response.status_code, 200)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""This function deletes the tablespaces,server and parent id file"""
|
||||
|
||||
tablespace_utils.delete_table_space(cls.tester)
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
def tearDown(self):
|
||||
"""This function delete the tablespace from added server"""
|
||||
connection = utils.get_db_connection(self.server['db'],
|
||||
self.server['username'],
|
||||
self.server['db_password'],
|
||||
self.server['host'],
|
||||
self.server['port'])
|
||||
tablespace_utils.delete_tablespace(connection, self.tablespace_name)
|
||||
|
||||
@@ -8,11 +8,11 @@
|
||||
# ##################################################################
|
||||
|
||||
import json
|
||||
import uuid
|
||||
|
||||
from pgadmin.utils.route import BaseTestGenerator
|
||||
from regression import test_utils as utils
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
from test_setup import advanced_config_data
|
||||
from regression import test_server_dict
|
||||
from . import utils as tablespace_utils
|
||||
|
||||
|
||||
@@ -24,67 +24,40 @@ class TableSpaceUpdateTestCase(BaseTestGenerator):
|
||||
('Check Tablespace Node', dict(url='/browser/tablespace/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 roles!!!")
|
||||
|
||||
# Add tablespace
|
||||
tablespace_utils.add_table_space(cls.tester,
|
||||
cls.server_connect_response,
|
||||
cls.server_group, cls.server_ids)
|
||||
def setUp(self):
|
||||
if not self.server['tablespace_path']\
|
||||
or self.server['tablespace_path'] is None:
|
||||
message = "Skipped tablespace delete test case. Tablespace path" \
|
||||
" not configured for server: %s" % self.server['name']
|
||||
# Skip the test case if tablespace_path not found.
|
||||
self.skipTest(message)
|
||||
self.tablespace_name = "tablespace_delete_%s" % str(uuid.uuid4())[1:6]
|
||||
self.tablespace_id = tablespace_utils.create_tablespace(
|
||||
self.server, self.tablespace_name)
|
||||
|
||||
def runTest(self):
|
||||
"""This function tests the update tablespace data scenario"""
|
||||
server_id = test_server_dict["server"][0]["server_id"]
|
||||
tablespace_count = tablespace_utils.verify_table_space(
|
||||
self.server, self.tablespace_name)
|
||||
if tablespace_count == 0:
|
||||
raise Exception("No tablespace(s) to update!!!")
|
||||
|
||||
tablespace_ids_dict = None
|
||||
all_id = utils.get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
if "tsid" in all_id and all_id["tsid"]:
|
||||
tablespace_ids_dict = all_id["tsid"][0]
|
||||
data = {
|
||||
"description": "This is test description.",
|
||||
"table_space_id": self.tablespace_id
|
||||
}
|
||||
put_response = self.tester.put(
|
||||
self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/'
|
||||
+ str(self.tablespace_id), data=json.dumps(data),
|
||||
follow_redirects=True)
|
||||
self.assertEquals(put_response.status_code, 200)
|
||||
|
||||
if tablespace_ids_dict:
|
||||
for server_id in server_ids:
|
||||
tablespace_id = tablespace_ids_dict[int(server_id)]
|
||||
tablespace_response = tablespace_utils.verify_table_space(
|
||||
self.tester,
|
||||
utils.SERVER_GROUP, server_id,
|
||||
tablespace_id)
|
||||
if len(tablespace_response) == 0:
|
||||
raise Exception("No tablespace(s) to update!!!")
|
||||
|
||||
data = {
|
||||
"description": advanced_config_data["tbspc_update_data"]
|
||||
["comment"],
|
||||
"table_space_id": tablespace_id
|
||||
}
|
||||
|
||||
put_response = self.tester.put(
|
||||
self.url + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id) + '/' + str(
|
||||
tablespace_id),
|
||||
data=json.dumps(data),
|
||||
follow_redirects=True)
|
||||
|
||||
self.assertEquals(put_response.status_code, 200)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
"""This function deletes the tablespaces,server and parent id file"""
|
||||
|
||||
tablespace_utils.delete_table_space(cls.tester)
|
||||
server_utils.delete_server(cls.tester)
|
||||
utils.delete_parent_id_file()
|
||||
def tearDown(self):
|
||||
"""This function deletes the tablespace"""
|
||||
connection = utils.get_db_connection(self.server['db'],
|
||||
self.server['username'],
|
||||
self.server['db_password'],
|
||||
self.server['host'],
|
||||
self.server['port'])
|
||||
tablespace_utils.delete_tablespace(connection, self.tablespace_name)
|
||||
|
||||
@@ -9,187 +9,114 @@
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import json
|
||||
import os
|
||||
import pickle
|
||||
import uuid
|
||||
import sys
|
||||
|
||||
from regression.test_setup import pickle_path, config_data, \
|
||||
advanced_config_data
|
||||
from pgadmin.browser.server_groups.servers.tests import utils as server_utils
|
||||
|
||||
from regression import test_utils as utils
|
||||
|
||||
TABLE_SPACE_URL = '/browser/tablespace/obj/'
|
||||
file_name = os.path.basename(__file__)
|
||||
|
||||
|
||||
# Tablespace utility
|
||||
def get_tablespace_data(server_connect):
|
||||
"""This function returns the tablespace data from config file"""
|
||||
|
||||
adv_config_data = None
|
||||
data = None
|
||||
db_user = server_connect['data']['user']['name']
|
||||
server_config_data = config_data['server_credentials']
|
||||
|
||||
# Get the config data of appropriate db user
|
||||
for config_test_data in advanced_config_data['tablespc_credentials']:
|
||||
if db_user == config_test_data['spc_user']:
|
||||
# Add the tablespace path from server config
|
||||
server_config = (item for item in server_config_data if
|
||||
item["db_username"] == db_user).next()
|
||||
if "tablespace_path" in server_config:
|
||||
config_test_data['spc_location'] = server_config['tablespace_path']
|
||||
adv_config_data = config_test_data
|
||||
else:
|
||||
config_test_data['spc_location'] = None
|
||||
|
||||
if adv_config_data is not None:
|
||||
data = {
|
||||
"name": str(uuid.uuid4())[1:8],
|
||||
"seclabels": adv_config_data["spc_seclable"],
|
||||
"spcacl": adv_config_data["spc_acl"],
|
||||
"spclocation": adv_config_data["spc_location"],
|
||||
"spcoptions": adv_config_data["spc_opts"],
|
||||
"spcuser": adv_config_data["spc_user"]
|
||||
}
|
||||
def get_tablespace_data(tablespace_path, db_owner):
|
||||
"""This function returns the tablespace data"""
|
||||
data = {
|
||||
"name": "test_%s" % str(uuid.uuid4())[1:8],
|
||||
"seclabels": [],
|
||||
"spcacl": [
|
||||
{
|
||||
"grantee": db_owner,
|
||||
"grantor": db_owner,
|
||||
"privileges": [
|
||||
{
|
||||
"privilege_type": "C",
|
||||
"privilege": True,
|
||||
"with_grant": False
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"spclocation": tablespace_path,
|
||||
"spcoptions": [],
|
||||
"spcuser": db_owner
|
||||
}
|
||||
return data
|
||||
|
||||
|
||||
def write_tablespace_id(response_data):
|
||||
"""
|
||||
This function write the table space id to parent_id.pkl
|
||||
def create_tablespace(server, test_tablespace_name):
|
||||
try:
|
||||
connection = utils.get_db_connection(server['db'],
|
||||
server['username'],
|
||||
server['db_password'],
|
||||
server['host'],
|
||||
server['port'])
|
||||
old_isolation_level = connection.isolation_level
|
||||
connection.set_isolation_level(0)
|
||||
pg_cursor = connection.cursor()
|
||||
pg_cursor.execute("CREATE TABLESPACE %s LOCATION '%s'" %
|
||||
(test_tablespace_name, server['tablespace_path']))
|
||||
connection.set_isolation_level(old_isolation_level)
|
||||
connection.commit()
|
||||
|
||||
:param response_data: create table space API response data
|
||||
:type response_data: dict
|
||||
:return: None
|
||||
"""
|
||||
|
||||
table_space_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 'tsid' in pickle_id_dict:
|
||||
if pickle_id_dict['tsid']:
|
||||
# Add the db_id as value in dict
|
||||
pickle_id_dict["tsid"][0].update(
|
||||
{server_id: table_space_id})
|
||||
else:
|
||||
# Create new dict with server_id and db_id
|
||||
pickle_id_dict["tsid"].append(
|
||||
{server_id: table_space_id})
|
||||
db_output = open(pickle_path, 'wb')
|
||||
pickle.dump(pickle_id_dict, db_output)
|
||||
db_output.close()
|
||||
# Get 'oid' from newly created tablespace
|
||||
pg_cursor.execute(
|
||||
"SELECT ts.oid from pg_tablespace ts WHERE ts.spcname='%s'" %
|
||||
test_tablespace_name)
|
||||
oid = pg_cursor.fetchone()
|
||||
tspc_id = ''
|
||||
if oid:
|
||||
tspc_id = oid[0]
|
||||
connection.close()
|
||||
return tspc_id
|
||||
except Exception as exception:
|
||||
raise Exception("Error while creating tablespace. %s" % exception)
|
||||
|
||||
|
||||
def add_table_space(tester, server_connect_response, server_group, server_ids):
|
||||
"""
|
||||
This function is used to add the roles to server
|
||||
|
||||
:param tester: flask test client
|
||||
:type tester: flask test client object
|
||||
:param server_connect_response: server connect API response
|
||||
:type server_connect_response: dict
|
||||
:param server_group: server group
|
||||
:type server_group: int
|
||||
:param server_ids: list of server id
|
||||
:type server_ids: list
|
||||
:return: None
|
||||
"""
|
||||
|
||||
total_servers_count = len(server_ids)
|
||||
servers_without_tablespace_path = []
|
||||
|
||||
for server_connect, server_id in zip(server_connect_response,
|
||||
server_ids):
|
||||
tablespace_path = server_connect['tablespace_path']
|
||||
# Skip the test case if tablespace_path does not exist
|
||||
if not tablespace_path or tablespace_path is None:
|
||||
file_name = os.path.basename(
|
||||
sys._getframe().f_back.f_code.co_filename)
|
||||
servers_without_tablespace_path.append(server_id)
|
||||
if total_servers_count == len(servers_without_tablespace_path):
|
||||
print("Skipping tablespaces test cases for the file <{0}>, "
|
||||
"Tablespace path not configured for the servers: "
|
||||
"{1}".format(file_name, server_ids), file=sys.stderr)
|
||||
return
|
||||
else:
|
||||
print("Skipping tablespaces test case for the file <{0}>: "
|
||||
"Tablespace path not configured for server: {1}".format(
|
||||
file_name, server_id), file=sys.stderr)
|
||||
continue
|
||||
|
||||
if server_connect['data']['connected']:
|
||||
data = get_tablespace_data(server_connect)
|
||||
response = tester.post(TABLE_SPACE_URL + str(server_group) + '/'
|
||||
+ server_id + '/',
|
||||
data=json.dumps(data),
|
||||
content_type='html/json')
|
||||
assert response.status_code == 200
|
||||
response_data = json.loads(response.data.decode('utf-8'))
|
||||
write_tablespace_id(response_data)
|
||||
|
||||
|
||||
def verify_table_space(tester, server_group, server_id, tablespace_id):
|
||||
def verify_table_space(server, test_tablespace_name):
|
||||
"""
|
||||
This function calls the GET API for role to verify
|
||||
|
||||
:param tester: test client
|
||||
:type tester: flask test client object
|
||||
:param server_group: server group id
|
||||
:type server_group: int
|
||||
:param server_id: server id
|
||||
:type server_id: str
|
||||
:param tablespace_id: table space id
|
||||
:type tablespace_id: int
|
||||
:return: dict/None
|
||||
:param server: server info
|
||||
:type server: dict
|
||||
:param test_tablespace_name: tablespace name
|
||||
:type test_tablespace_name: str
|
||||
:return tablespace_count: tablespace count
|
||||
:rtype: int
|
||||
"""
|
||||
|
||||
srv_connect = server_utils.verify_server(tester, server_group, server_id)
|
||||
if srv_connect['data']['connected']:
|
||||
response = tester.get(
|
||||
'{0}{1}/{2}/{3}'.format(TABLE_SPACE_URL, server_group, server_id,
|
||||
tablespace_id),
|
||||
content_type='html/json')
|
||||
assert response.status_code == 200
|
||||
temp_response = json.loads(response.data.decode('utf-8'))
|
||||
return temp_response
|
||||
else:
|
||||
return None
|
||||
try:
|
||||
connection = utils.get_db_connection(server['db'],
|
||||
server['username'],
|
||||
server['db_password'],
|
||||
server['host'],
|
||||
server['port'])
|
||||
pg_cursor = connection.cursor()
|
||||
pg_cursor.execute("SELECT * FROM pg_tablespace ts WHERE"
|
||||
" ts.spcname='%s'" % test_tablespace_name)
|
||||
tablespace_count = len(pg_cursor.fetchall())
|
||||
connection.close()
|
||||
return tablespace_count
|
||||
except Exception as exception:
|
||||
exception = "%s: line:%s %s" % (
|
||||
file_name, sys.exc_traceback.tb_lineno, exception)
|
||||
print(exception, file=sys.stderr)
|
||||
|
||||
|
||||
def delete_table_space(tester):
|
||||
"""
|
||||
This function use to delete the existing tablespace in the servers
|
||||
|
||||
:param tester: flask test client
|
||||
:type tester: flask test object
|
||||
:return: None
|
||||
"""
|
||||
|
||||
all_id = utils.get_ids()
|
||||
server_ids = all_id["sid"]
|
||||
if "tsid" in all_id and all_id["tsid"]:
|
||||
tablespace_ids_dict = all_id["tsid"][0]
|
||||
else:
|
||||
tablespace_ids_dict = None
|
||||
|
||||
if tablespace_ids_dict is not None:
|
||||
for server_id in server_ids:
|
||||
tablespace_id = tablespace_ids_dict[int(server_id)]
|
||||
role_response = verify_table_space(tester, utils.SERVER_GROUP,
|
||||
server_id,
|
||||
tablespace_id)
|
||||
if len(role_response) == 0:
|
||||
raise Exception("No tablespace(s) to delete!!!")
|
||||
response = tester.delete(
|
||||
TABLE_SPACE_URL + str(utils.SERVER_GROUP) + '/' +
|
||||
str(server_id) + '/' + str(tablespace_id),
|
||||
follow_redirects=True)
|
||||
assert response.status_code == 200
|
||||
delete_response_data = json.loads(response.data.decode('utf-8'))
|
||||
assert delete_response_data['success'] == 1
|
||||
def delete_tablespace(connection, test_tablespace_name):
|
||||
try:
|
||||
pg_cursor = connection.cursor()
|
||||
pg_cursor.execute("SELECT * FROM pg_tablespace ts WHERE"
|
||||
" ts.spcname='%s'" % test_tablespace_name)
|
||||
tablespace_count = len(pg_cursor.fetchall())
|
||||
if tablespace_count:
|
||||
old_isolation_level = connection.isolation_level
|
||||
connection.set_isolation_level(0)
|
||||
pg_cursor.execute("DROP TABLESPACE %s" % test_tablespace_name)
|
||||
connection.set_isolation_level(old_isolation_level)
|
||||
connection.commit()
|
||||
connection.close()
|
||||
except Exception as exception:
|
||||
exception = "%s: line:%s %s" % (
|
||||
file_name, sys.exc_traceback.tb_lineno, exception)
|
||||
print(exception, file=sys.stderr)
|
||||
raise Exception(exception)
|
||||
|
||||
Reference in New Issue
Block a user