diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py index 85dcc6c..22cd7ce 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py +++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py @@ -38,7 +38,7 @@ class DatabaseAddTestCase(BaseTestGenerator): """ This function will add database under 1st server of tree node. """ server_connect_response, server_group, server_ids = \ - utils.connect_server(self.tester) + utils.connect_server(self.tester, True) for server_connect, server_id in zip(server_connect_response, server_ids): diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py index 4615d34..6740534 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py +++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_put.py @@ -70,5 +70,6 @@ class DatabasesUpdateTestCase(BaseTestGenerator): :return: None """ + utils.delete_database(self.tester) utils.delete_server(self.tester) utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py new file mode 100644 index 0000000..4a11bf8 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/roles/tests/__init__.py @@ -0,0 +1,16 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from pgadmin.utils.route import BaseTestGenerator + + +class RoleGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py new file mode 100644 index 0000000..27cae52 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_add.py @@ -0,0 +1,54 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator + + +class LoginRoleAddTestCase(BaseTestGenerator): + """This class has add role scenario""" + + scenarios = [ + # Fetching default URL for roles node. + ('Check Role Node', dict(url='/browser/role/obj/')) + ] + + def setUp(self): + """This function used to add the sever""" + + # Add the server + utils.add_server(self.tester) + + def runTest(self): + """This function test the add role scenario""" + + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, True) + + for server_connect, server_id in zip(server_connect_response, + server_ids): + if server_connect['data']['connected']: + data = utils.get_role_data() + response = self.tester.post(self.url + str(server_group) + '/' + + server_id + '/', + data=json.dumps(data), + content_type='html/json') + self.assertTrue(response.status_code, 200) + response_data = json.loads(response.data.decode('utf-8')) + utils.write_role_id(response_data) + + def tearDown(self): + """This function deletes the role,server and parent id file""" + + utils.delete_role(self.tester) + utils.delete_server(self.tester) + utils.delete_parent_id_file() + diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py new file mode 100644 index 0000000..47769cb --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_delete.py @@ -0,0 +1,63 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + + +import json +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from test_setup import config_data +from regression.test_utils import get_ids + + +class LoginRoleDeleteTestCase(BaseTestGenerator): + """This class has delete role scenario""" + + scenarios = [ + # Fetching default URL for roles node. + ('Check Role Node', dict(url='/browser/role/obj/')) + ] + + def setUp(self): + """This function used to add the server""" + + # Add the server + utils.add_server(self.tester) + # Connect to server + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, False) + # Add the role + utils.add_role(self.tester, server_connect_response, server_group, + server_ids) + + def runTest(self): + """This function tests the delete role scenario""" + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + role_ids_dict = all_id["lrid"][0] + + for server_id in server_ids: + role_id = role_ids_dict[int(server_id)] + role_response = utils.verify_role(self.tester, srv_grp, server_id, + role_id) + if len(role_response) == 0: + raise Exception("No roles(s) to delete!!!") + response = self.tester.delete(self.url + str(srv_grp) + '/' + + str(server_id) + '/' + str(role_id), + follow_redirects=True) + delete_response_data = json.loads(response.data.decode('utf-8')) + self.assertTrue(delete_response_data['success'], 1) + + def tearDown(self): + """This function deletes the role,server and parent id file""" + + utils.delete_server(self.tester) + utils.delete_parent_id_file() + diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py new file mode 100644 index 0000000..3c2ed9c --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_get.py @@ -0,0 +1,53 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from test_setup import config_data +from pgadmin.utils.route import BaseTestGenerator +from regression.test_utils import get_ids + + +class LoginRoleGetTestCase(BaseTestGenerator): + """This class tests the get role scenario""" + + scenarios = [ + # Fetching default URL for roles node. + ('Check Role Node', dict(url='/browser/role/obj/')) + ] + + def setUp(self): + # Add the server + utils.add_server(self.tester) + # Connect to server + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, False) + # Add the role + utils.add_role(self.tester, server_connect_response, server_group, + server_ids) + + def runTest(self): + """This function test the get role scenario""" + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + role_ids_dict = all_id["lrid"][0] + + for server_id in server_ids: + role_id = role_ids_dict[int(server_id)] + response = self.tester.get(self.url + str(srv_grp) + '/' + + str(server_id) + '/' + str(role_id), + follow_redirects=True) + self.assertEquals(response.status_code, 200) + + def tearDown(self): + """This function deletes the role,server and parent id file""" + + utils.delete_role(self.tester) + utils.delete_server(self.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py new file mode 100644 index 0000000..b1f8ba2 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/roles/tests/test_role_put.py @@ -0,0 +1,68 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from test_setup import config_data, advanced_config_data +from pgadmin.utils.route import BaseTestGenerator +from regression.test_utils import get_ids + + +class LoginRolePutTestCase(BaseTestGenerator): + """This class has update role scenario""" + + scenarios = [ + # Fetching default URL for roles node. + ('Check Role Node', dict(url='/browser/role/obj/')) + ] + + def setUp(self): + # Add the server + utils.add_server(self.tester) + # Connect to server + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, False) + # Add the role + utils.add_role(self.tester, server_connect_response, server_group, + server_ids) + + def runTest(self): + """This function tests the update role data scenario""" + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + role_ids_dict = all_id["lrid"][0] + + for server_id in server_ids: + role_id = role_ids_dict[int(server_id)] + role_response = utils.verify_role(self.tester, srv_grp, server_id, + role_id) + if len(role_response) == 0: + raise Exception("No roles(s) to update!!!") + + data = { + "description": advanced_config_data["test_lr_update_data"] + ["test_comment"], + "lrid": role_id + } + put_response = self.tester.put(self.url + str(srv_grp) + '/' + + str(server_id) + '/' + str(role_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + def tearDown(self): + """This function deletes the role,server and parent id file""" + + utils.delete_role(self.tester) + utils.delete_server(self.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py new file mode 100644 index 0000000..3302027 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/__init__.py @@ -0,0 +1,16 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from pgadmin.utils.route import BaseTestGenerator + + +class TblspaceGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py new file mode 100644 index 0000000..48c7628 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_add.py @@ -0,0 +1,53 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator + + +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/')) + ] + + def setUp(self): + """This function used to add the sever""" + + # Add the server + utils.add_server(self.tester) + + def runTest(self): + """This function test the add tablespace scenario""" + + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, True) + + for server_connect, server_id in zip(server_connect_response, + server_ids): + if server_connect['data']['connected']: + data = utils.get_tablespace_data(server_connect) + response = self.tester.post(self.url + str(server_group) + '/' + + server_id + '/', + data=json.dumps(data), + content_type='html/json') + self.assertTrue(response.status_code, 200) + response_data = json.loads(response.data.decode('utf-8')) + utils.write_tablespace_id(response_data) + + def tearDown(self): + """This function deletes the tablespace,server and parent id file""" + + utils.delete_table_space(self.tester) + utils.delete_server(self.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py new file mode 100644 index 0000000..298a8e8 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_delete.py @@ -0,0 +1,65 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from test_setup import config_data +from regression.test_utils import get_ids + + +class TableSpaceDeleteTestCase(BaseTestGenerator): + """This class has delete table space scenario""" + + scenarios = [ + # Fetching default URL for tablespace node. + ('Check Tablespace Node', dict(url='/browser/tablespace/obj/')) + ] + + def setUp(self): + """This function used to add the server""" + + # Add the server + utils.add_server(self.tester) + # Connect to server + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, False) + # Add the table space + utils.add_table_space(self.tester, server_connect_response, + server_group, + server_ids) + + def runTest(self): + """This function tests the delete table space scenario""" + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + table_space_ids_dict = all_id["table_space_id"][0] + + for server_id in server_ids: + table_space_id = table_space_ids_dict[int(server_id)] + table_space_response = utils.verify_table_space(self.tester, + srv_grp, server_id, + table_space_id) + if len(table_space_response) == 0: + raise Exception("No tablespace(s) to delete!!!") + + response = self.tester.delete(self.url + str(srv_grp) + '/' + + str(server_id) + '/' + str( + table_space_id), + follow_redirects=True) + delete_response_data = json.loads(response.data.decode('utf-8')) + self.assertTrue(delete_response_data['success'], 1) + + def tearDown(self): + """This function deletes the server and parent id file""" + + utils.delete_server(self.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py new file mode 100644 index 0000000..45e12c0 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py @@ -0,0 +1,59 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from test_setup import config_data +from pgadmin.utils.route import BaseTestGenerator +from regression.test_utils import get_ids + + +class TablespaceGetTestCase(BaseTestGenerator): + """This class tests the get table space scenario""" + + scenarios = [ + # Fetching default URL for roles node. + ('Check Tablespace Node', dict(url='/browser/tablespace/obj/')) + ] + + def setUp(self): + # Add the server + utils.add_server(self.tester) + # Connect to server + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, False) + # Add the table space + utils.add_table_space(self.tester, server_connect_response, + server_group, + server_ids) + + def runTest(self): + """This function test the get table space scenario""" + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + tablespace_ids_dict = all_id["table_space_id"][0] + + for server_id in server_ids: + tablespace_id = tablespace_ids_dict[int(server_id)] + server_response = utils.verify_server(self.tester, srv_grp, + server_id) + if server_response['data']['connected']: + response = self.tester.get(self.url + str(srv_grp) + '/' + + str(server_id) + '/' + str( + tablespace_id), + follow_redirects=True) + self.assertEquals(response.status_code, 200) + + def tearDown(self): + """This function deletes the role,server and parent id file""" + + utils.delete_table_space(self.tester) + utils.delete_server(self.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py new file mode 100644 index 0000000..927640f --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py @@ -0,0 +1,72 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from test_setup import config_data, advanced_config_data +from pgadmin.utils.route import BaseTestGenerator +from regression.test_utils import get_ids + + +class TableSpaceUpdateTestCase(BaseTestGenerator): + """This class has update tablespace scenario""" + + scenarios = [ + # Fetching default URL for roles node. + ('Check Tablespace Node', dict(url='/browser/tablespace/obj/')) + ] + + def setUp(self): + # Add the server + utils.add_server(self.tester) + # Connect to server + server_connect_response, server_group, server_ids = \ + utils.connect_server(self.tester, False) + # Add the tablespace + utils.add_table_space(self.tester, server_connect_response, + server_group, + server_ids) + + def runTest(self): + """This function tests the update tablespace data scenario""" + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + tablespace_ids_dict = all_id["table_space_id"][0] + + for server_id in server_ids: + tablespace_id = tablespace_ids_dict[int(server_id)] + tablespace_response = utils.verify_table_space(self.tester, + srv_grp, server_id, + tablespace_id) + if len(tablespace_response) == 0: + raise Exception("No tablespace(s) to update!!!") + + data = { + "description": advanced_config_data["test_tbspc_update_data"] + ["test_comment"], + "table_space_id": tablespace_id + } + + put_response = self.tester.put(self.url + str(srv_grp) + '/' + + str(server_id) + '/' + str( + tablespace_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + def tearDown(self): + """This function deletes the role,server and parent id file""" + + utils.delete_table_space(self.tester) + utils.delete_server(self.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py index 2b1eb45..37d6949 100644 --- a/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py +++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_add.py @@ -32,10 +32,8 @@ class ServersAddTestCase(BaseTestGenerator): url = "{0}{1}/".format(self.url, server_group) response = self.tester.post(url, data=json.dumps(server_data), content_type='html/json') - self.assertTrue(response.status_code, 200) - - response_data = json.loads(response.data.decode()) + response_data = json.loads(response.data.decode('utf-8')) utils.write_parent_id(response_data, pickle_id_dict) def tearDown(self): diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py index 5e810ba..9973359 100644 --- a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py +++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py @@ -68,5 +68,6 @@ class ServerUpdateTestCase(BaseTestGenerator): :return: None """ + utils.delete_database(self.tester) utils.delete_server(self.tester) utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/tests/test_change_password.py b/web/pgadmin/browser/tests/test_change_password.py index 2f714a7..3dbd386 100644 --- a/web/pgadmin/browser/tests/test_change_password.py +++ b/web/pgadmin/browser/tests/test_change_password.py @@ -11,6 +11,8 @@ import uuid from pgadmin.utils.route import BaseTestGenerator from regression.test_setup import config_data +from regression import test_utils as utils +from utils import change_password class ChangePasswordTestCase(BaseTestGenerator): @@ -56,51 +58,58 @@ class ChangePasswordTestCase(BaseTestGenerator): ['test_new_password']), respdata='Invalid password')), - # This testcase checks for valid password + # This test case checks for valid password ('TestCase for Changing Valid_Password', dict( - password=(config_data['pgAdmin4_login_credentials'] + valid_password='reassigning_password', + username=(config_data['pgAdmin4_test_user_credentials'] + ['test_login_username']), + password=(config_data['pgAdmin4_test_user_credentials'] ['test_login_password']), - new_password=(config_data['pgAdmin4_login_credentials'] + new_password=(config_data['pgAdmin4_test_user_credentials'] ['test_new_password']), new_password_confirm=( - config_data['pgAdmin4_login_credentials'] + config_data['pgAdmin4_test_user_credentials'] ['test_new_password']), - respdata='You successfully changed your password.')), - ('Reassigning_Password', dict( - test_case='reassigning_password', - password=(config_data['pgAdmin4_login_credentials'] - ['test_new_password']), - new_password=(config_data['pgAdmin4_login_credentials'] - ['test_login_password']), - new_password_confirm=( - config_data['pgAdmin4_login_credentials'] - ['test_login_password']), respdata='You successfully changed your password.')) - ] + def setUp(self): + pass + def runTest(self): """This function will check change password functionality.""" - # Check for 'test_case' exists in self For reassigning the password. - # Password gets change in change password test case. - if 'test_case' in dir(self): - email = \ - config_data['pgAdmin4_login_credentials'][ - 'test_login_username'] - password = \ - config_data['pgAdmin4_login_credentials'][ - 'test_new_password'] + # Check for 'valid_password' exists in self to test 'valid password' + # test case + if 'valid_password' in dir(self): + response = self.tester.post('/user_management/user/', data=dict( + email=self.username, newPassword=self.password, + confirmPassword=self.password, active=1, role="2"), + follow_redirects=True) + assert response.status_code == 200 + + # Logout the Administrator before login normal user + utils.logout_tester_account(self.tester) + response = self.tester.post('/login', data=dict( - email=email, password=password), follow_redirects=True) - - response = self.tester.get('/change', follow_redirects=True) - self.assertIn('pgAdmin 4 Password Change', response.data.decode( - 'utf-8')) - - response = self.tester.post('/change', data=dict( - password=self.password, - new_password=self.new_password, - new_password_confirm=self.new_password_confirm), - follow_redirects=True) - self.assertIn(self.respdata, response.data.decode('utf-8')) + email=self.username, password=self.password), + follow_redirects=True) + assert response.status_code == 200 + + # test the 'change password' test case + change_password(self) + + # Delete the normal user after changing it's password + utils.logout_tester_account(self.tester) + + # Login the Administrator before deleting normal user + utils.login_tester_account(self.tester) + response = self.tester.delete('/user_management/user/2', + follow_redirects=True) + assert response.status_code == 200 + else: + change_password(self) + + def tearDown(self): + utils.login_tester_account(self.tester) + diff --git a/web/pgadmin/browser/tests/utils.py b/web/pgadmin/browser/tests/utils.py new file mode 100644 index 0000000..18548ce --- /dev/null +++ b/web/pgadmin/browser/tests/utils.py @@ -0,0 +1,21 @@ +# ########################################################################## +# +# #pgAdmin 4 - PostgreSQL Tools +# +# #Copyright (C) 2013 - 2016, The pgAdmin Development Team +# #This software is released under the PostgreSQL Licence +# +# ########################################################################## + + +def change_password(self): + response = self.tester.get('/change', follow_redirects=True) + self.assertIn('pgAdmin 4 Password Change', response.data.decode( + 'utf-8')) + + response = self.tester.post('/change', data=dict( + password=self.password, + new_password=self.new_password, + new_password_confirm=self.new_password_confirm), + follow_redirects=True) + self.assertIn(self.respdata, response.data.decode('utf-8')) \ No newline at end of file diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in index c0d278b..8b679ad 100644 --- a/web/regression/test_advanced_config.json.in +++ b/web/regression/test_advanced_config.json.in @@ -194,6 +194,50 @@ { "test_comment": "This is db update comment" } - ] + ], + "test_lr_credentials": { + "test_can_login": "true", + "test_conn_limit": -1, + "test_create_role": "true", + "test_role_inherit": "true", + "test_role_membership": [], + "test_lr_name": "testlrg1", + "test_lr_password": "edb", + "test_lr_validity": "12/27/2016", + "test_sec_lable": [], + "test_variable":[ + {"name":"work_mem", + "database":"postgres", + "value":65 + }] + }, + "test_lr_update_data": { + "test_comment": "This is db update comment" + }, + + "test_tablespc_credentials":[{ + "test_tblspace_name": "test_tablespace", + "test_spc_seclable": [], + "test_spc_acl": [ + { + "grantee":"postgres", + "grantor":"postgres", + "privileges":[ + { + "privilege_type":"C", + "privilege":true, + "with_grant":false + } + ] + } + ], + "test_spc_location": "/Library/PostgreSQL/9.6/data", + "test_spc_opts": [], + "test_spc_user": "postgres" + }], + + "test_tbspc_update_data": { + "test_comment": "This is tablespace update comment" + } -} \ No newline at end of file +} diff --git a/web/regression/test_config.json.in b/web/regression/test_config.json.in index 028d1e7..9fcf197 100644 --- a/web/regression/test_config.json.in +++ b/web/regression/test_config.json.in @@ -4,6 +4,11 @@ "test_login_password": "PASSWORD", "test_login_username": "USER@EXAMPLE.COM" }, + "pgAdmin4_test_user_credentials": { + "test_new_password": "NEWPASSWORD", + "test_login_password": "PASSWORD", + "test_login_username": "USER@EXAMPLE.COM" + }, "test_server_group": 1, "test_server_credentials": [ { diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py index 6be2bb2..18c5981 100644 --- a/web/regression/test_utils.py +++ b/web/regression/test_utils.py @@ -19,6 +19,20 @@ SERVER_URL = '/browser/server/obj/' SERVER_CONNECT_URL = 'browser/server/connect/' DATABASE_URL = '/browser/database/obj/' DATABASE_CONNECT_URL = 'browser/database/connect/' +ROLE_URL = '/browser/role/obj/' +TABLE_SPACE_URL = '/browser/tablespace/obj/' + + +def get_pickle_id_dict(): + """This function returns the empty dict of server config data""" + + pickle_id_dict = { + "sid": [], # server + "did": [], # database + "lrid": [], # role + "table_space_id": [] # tablespace + } + return pickle_id_dict def get_ids(url=pickle_path): @@ -34,10 +48,22 @@ def get_ids(url=pickle_path): output = open(url, 'rb') ids = pickle.load(output) output.close() - return ids +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 + ['test_server_credentials'][0] + ['test_db_password']), + follow_redirects=True) + srv_connect = json.loads(response.data.decode('utf-8')) + return srv_connect + + def verify_database(tester, server_group, server_id, db_id): """ This function verifies that database is exists and whether it connect @@ -158,6 +184,7 @@ def logout_tester_account(tester): response = tester.get('/logout') +# Config data for parent_id.pkl def get_config_data(): """ This function get the data related to server group and database @@ -168,12 +195,7 @@ def get_config_data(): """ db_data = [] - - pickle_id_dict = { - "sid": [], # server - "did": [] # database - } - + pickle_id_dict = get_pickle_id_dict() server_group = config_data['test_server_group'] for srv in config_data['test_server_credentials']: @@ -205,7 +227,7 @@ def write_parent_id(response_data, pickle_id_dict): existed_server_id = open(pickle_path, 'rb') pickle_id_dict = pickle.load(existed_server_id) - pickle_id_dict["sid"].append(server_id) + pickle_id_dict["sid"].append(str(server_id)) output = open(pickle_path, 'wb') pickle.dump(pickle_id_dict, output) output.close() @@ -223,20 +245,22 @@ def write_db_parent_id(response_data): db_id = response_data['node']['_id'] server_id = response_data['node']['_pid'] + # TODO: modify logic to write in file / file exists or create new + pickle_id_dict = 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() + 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 delete_parent_id_file(): @@ -265,7 +289,7 @@ def add_server(tester): for db_detail in db_data: response = tester.post(url, data=json.dumps(db_detail), content_type='html/json') - response_data = json.loads(response.data.decode()) + response_data = json.loads(response.data.decode('utf-8')) write_parent_id(response_data, pickle_id_dict) @@ -289,12 +313,14 @@ def get_server(tester): response_data = json.loads(response.data.decode()) -def connect_server(tester): +def connect_server(tester, add_db_flag=False): """ 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 """ @@ -315,9 +341,10 @@ def connect_server(tester): ['test_server_credentials'][0] ['test_db_password']), follow_redirects=True) - server_connect_detail = json.loads(response.data.decode()) - connect_database(tester, server_connect_detail, server_id, - server_group) + server_connect_detail = json.loads(response.data.decode('utf-8')) + if not add_db_flag: + connect_database(tester, server_connect_detail, server_id, + server_group) server_connect.append(server_connect_detail) servers.append(server_id) return server_connect, server_group, servers @@ -345,7 +372,7 @@ def connect_database(tester, server_connect, server_id, server_group): DATABASE_URL + str(server_group) + "/" + server_id + "/", data=json.dumps(db_data), content_type='html/json') - response_data = json.loads(db_response.data.decode()) + response_data = json.loads(db_response.data.decode('utf-8')) write_db_parent_id(response_data) @@ -366,7 +393,7 @@ def delete_server(tester): 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()) + response_data = json.loads(response.data.decode('utf-8')) assert response_data['success'] == 1 @@ -395,3 +422,309 @@ def delete_database(tester): assert response.status_code == 200 response_data = json.loads(response.data.decode('utf-8')) assert response_data['success'] == 1 + + +# Roles utility +def verify_role(tester, server_group, server_id, role_id): + """ + 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 role_id: role id + :type role_id: int + :return: dict/None + """ + + response = tester.post( + '{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id), + data=dict(password=config_data + ['test_server_credentials'][0] + ['test_db_password']), + follow_redirects=True) + srv_connect = json.loads(response.data.decode('utf-8')) + if srv_connect['data']['connected']: + response = tester.get( + '{0}{1}/{2}/{3}'.format(ROLE_URL, server_group, server_id, + role_id), + content_type='html/json') + temp_response = json.loads(response.data.decode('utf-8')) + return temp_response + else: + return None + + +def test_getrole(tester): + if not tester: + return None + + all_id = get_ids() + + server_ids = all_id["sid"] + role_ids_dict = all_id["lrid"][0] + server_group = config_data['test_server_group'] + + role_response_data = [] + for server_id in server_ids: + role_id = role_ids_dict[int(server_id)] + role_response_data.append( + verify_role(tester, server_group, server_id, role_id)) + return role_response_data + + +def get_role_data(): + """This function returns the role data from config file""" + + data = { + "rolcanlogin": advanced_config_data['test_lr_credentials'] + ['test_can_login'], + "rolconnlimit": advanced_config_data['test_lr_credentials'] + ['test_conn_limit'], + "rolcreaterole": advanced_config_data['test_lr_credentials'] + ['test_create_role'], + "rolinherit": advanced_config_data['test_lr_credentials'] + ['test_role_inherit'], + "rolmembership": advanced_config_data['test_lr_credentials'] + ['test_role_membership'], + "rolname": str(uuid.uuid4())[1:8], + "rolpassword": advanced_config_data['test_lr_credentials'] + ['test_lr_password'], + "rolvaliduntil": advanced_config_data['test_lr_credentials'] + ['test_lr_validity'], + "seclabels": advanced_config_data['test_lr_credentials'] + ['test_sec_lable'], + "variables": advanced_config_data['test_lr_credentials'] + ['test_variable'] + } + return data + + +def add_role(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 + """ + + for server_connect, server_id in zip(server_connect_response, + server_ids): + if server_connect['data']['connected']: + data = get_role_data() + response = tester.post(ROLE_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_role_id(response_data) + + +def write_role_id(response_data): + """ + + :param response_data: + :return: + """ + + lr_id = response_data['node']['_id'] + server_id = response_data['node']['_pid'] + pickle_id_dict = get_pickle_id_dict() + # TODO: modify logic to write in file / file exists or create new check + # old file + 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 'lrid' in pickle_id_dict: + if pickle_id_dict['lrid']: + # Add the db_id as value in dict + pickle_id_dict["lrid"][0].update({server_id: lr_id}) + else: + # Create new dict with server_id and db_id + pickle_id_dict["lrid"].append({server_id: lr_id}) + db_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, db_output) + db_output.close() + + +def delete_role(tester): + """ + This function use to delete the existing roles in the servers + + :param tester: flask test client + :type tester: flask test object + :return: None + """ + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + role_ids_dict = all_id["lrid"][0] + + for server_id in server_ids: + role_id = role_ids_dict[int(server_id)] + role_response = verify_role(tester, srv_grp, server_id, + role_id) + if len(role_response) == 0: + raise Exception("No roles(s) to delete!!!") + response = tester.delete(ROLE_URL + str(srv_grp) + '/' + + str(server_id) + '/' + str(role_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 + + +# 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'] + + # Get the config data of appropriate db user + for config_test_data in advanced_config_data['test_tablespc_credentials']: + if db_user == config_test_data['test_spc_user']: + adv_config_data = config_test_data + + if adv_config_data is not None: + data = { + "name": str(uuid.uuid4())[1:8], + "seclabels": adv_config_data["test_spc_seclable"], + "spcacl": adv_config_data["test_spc_acl"], + "spclocation": adv_config_data["test_spc_location"], + "spcoptions": adv_config_data["test_spc_opts"], + "spcuser": adv_config_data["test_spc_user"] + } + return data + + +def write_tablespace_id(response_data): + """ + This function write the table space id to parent_id.pkl + + :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 = 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 'table_space_id' in pickle_id_dict: + if pickle_id_dict['table_space_id']: + # Add the db_id as value in dict + pickle_id_dict["table_space_id"][0].update( + {server_id: table_space_id}) + else: + # Create new dict with server_id and db_id + pickle_id_dict["table_space_id"].append( + {server_id: table_space_id}) + db_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, db_output) + db_output.close() + + +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 + """ + + for server_connect, server_id in zip(server_connect_response, + server_ids): + 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): + """ + 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 + """ + + response = tester.post( + '{0}{1}/{2}'.format(SERVER_CONNECT_URL, server_group, server_id), + data=dict(password=config_data + ['test_server_credentials'][0] + ['test_db_password']), + follow_redirects=True) + srv_connect = json.loads(response.data.decode('utf-8')) + 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') + temp_response = json.loads(response.data.decode('utf-8')) + return temp_response + else: + return None + + +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 + """ + + srv_grp = config_data['test_server_group'] + all_id = get_ids() + server_ids = all_id["sid"] + tablespace_ids_dict = all_id["table_space_id"][0] + + for server_id in server_ids: + tablespace_id = tablespace_ids_dict[int(server_id)] + role_response = verify_table_space(tester, srv_grp, server_id, + tablespace_id) + if len(role_response) == 0: + raise Exception("No tablespace(s) to delete!!!") + response = tester.delete(TABLE_SPACE_URL + str(srv_grp) + '/' + + 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