def runTest(self): """ This function will add collation under schema node. """ schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_id = self.schema_details[0] schema_name = self.schema_details[1] schema_response = schema_utils.verify_schemas(self.server, self.db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") data = { "copy_collation": "pg_catalog.\"C\"", "name": "collation_add_%s" % str(uuid.uuid4())[1:8], "owner": self.server["username"], "schema": schema_name } response = self.tester.post(self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def tearDown(self): """This function disconnect the test database and drop added extension. """ db_name = parent_node_dict["database"][-1]['db_name'] extension_utils.drop_extension(self.server, db_name, self.data['name']) database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): db_con = database_utils.connect_database(self, test_utils.SERVER_GROUP, self.encode_sid, self.encode_did) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to the database.") # Initialize query tool url = '/datagrid/initialize/query_tool/{0}/{1}/{2}'.format( test_utils.SERVER_GROUP, self.encode_sid, self.encode_did) response = self.tester.post(url) self.assertEquals(response.status_code, 200) response_data = json.loads(response.data.decode('utf-8')) self.trans_id = response_data['data']['gridTransId'] # Check character url = "/sqleditor/query_tool/start/{0}".format(self.trans_id) sql = "select E'{0}';".format(self.test_str) response = self.tester.post(url, data=json.dumps({"sql": sql}), content_type='html/json') self.assertEquals(response.status_code, 200) url = '/sqleditor/poll/{0}'.format(self.trans_id) response = self.tester.get(url) self.assertEquals(response.status_code, 200) response_data = json.loads(response.data.decode('utf-8')) self.assertEquals(response_data['data']['rows_fetched_to'], 1) database_utils.disconnect_database(self, self.encode_sid, self.encode_did)
def tearDown(self): """This function delete added language and disconnect the test database.""" language_utils.delete_language(self.server, self.db_name, self.lang_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will add trigger function under schema node. """ super(TriggerFuncAddTestCase, self).runTest() self = funcs_utils.set_up(self) db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "plpgsql", "name": "test_abort_any_command", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": self.prorettypename, "prosecdef": True, "prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled'," " tg_tag; END;", "provolatile": "s", "seclabels": [], "variables": [ { "name": "enable_sort", "value": True } ] } # Get the type from data. We are adding two types # i.e. event_trigger and trigger. trigger_func_types = data['prorettypename'].split('/') for func_type in trigger_func_types: data['prorettypename'] = func_type data["name"] = "test_event_add_%s" % str(uuid.uuid4())[1:8] if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will update procedure under database node. """ super(ProcedurePutTestCase, self).setUp() self = funcs_utils.set_up(self) if self.server_type == "pg" and\ self.server_version < 110000: message = "Procedures are not supported by PG < 110000." self.skipTest(message) func_name = "test_procedure_put_%s" % str(uuid.uuid4())[1:8] proc_info = funcs_utils.create_procedure( self.server, self.db_name, self.schema_name, func_name, self.server_type, self.server_version) proc_id = proc_info[0] data = { "description": "This is procedure update comment", "id": proc_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(proc_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will delete procedure under database node. """ super(procedureDeleteTestCase, self).setUp() self = funcs_utils.set_up(self) if self.server_type == "pg" and\ self.server_version < 110000: message = "Procedures are not supported by PG < 110000." self.skipTest(message) func_name = "test_procedure_delete_%s" % str(uuid.uuid4())[1:8] proc_info = funcs_utils.create_procedure( self.server, self.db_name, self.schema_name, func_name, self.server_type, self.server_version) proc_id = proc_info[0] response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(proc_id), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will delete collation under schema node. """ server_id = self.schema_info["server_id"] db_id = self.schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") collation_id = self.collation[0] schema_id = self.schema_info["schema_id"] get_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str( server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/' + str(collation_id), content_type='html/json') self.assertEquals(get_response.status_code, 200) # Disconnect database to delete it database_utils.disconnect_database(self, server_id, db_id)
def runTest(self): """ This function will add domain under schema node. """ db_id = self.database_info["db_id"] server_id = self.database_info["server_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to get the domain.") db_name = self.database_info["db_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to get the domain.") domain_id = self.domain_info[0] # Call GET API to verify the domain get_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(domain_id), content_type='html/json') self.assertEquals(get_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def runTest(self): """ This function will update domain under schema node. """ db_id = self.database_info["db_id"] server_id = self.database_info["server_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to get the domain.") db_name = self.database_info["db_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to get the domain.") domain_response = domain_utils.verify_domain(self.server, db_name, self.schema_id, self.domain_name) if not domain_response: raise Exception("Could not find the domain to update.") domain_id = self.domain_info[0] data = {"description": "This is domain update comment", "id": domain_id, } response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(domain_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def runTest(self): """ This function will update function under database node. """ super(FunctionPutTestCase, self).setUp() self = funcs_utils.set_up(self) func_name = "test_event_delete_%s" % str(uuid.uuid4())[1:8] function_info = funcs_utils.create_function( self.server, self.db_name, self.schema_name, func_name) func_id = function_info[0] data = { "description": "This is a procedure update comment", "id": func_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(func_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """ This function disconnect the test database and delete test foreign table object. """ ft_utils.delete_foregin_table(self.server, self.db_name, self.schema_name, self.ft_name ) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function delete the fts_parser and disconnect the test database.""" fts_parser_utils.delete_fts_parser(self.server, self.db_name, self.schema_name, self.fts_parser_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added cast.""" connection = utils.get_db_connection(self.server_data['db_name'], self.server['username'], self.server['db_password'], self.server['host'], self.server['port'], self.server['sslmode']) cast_utils.drop_cast(connection, self.data["srctyp"], self.data["trgtyp"]) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added cast.""" connection = utils.get_db_connection(self.server['db'], self.server['username'], self.server['db_password'], self.server['host'], self.server['port']) cast_utils.drop_cast(connection, self.source_type, self.target_type) database_utils.disconnect_database(self, self.server_id, self.db_id) self.server['db'] = self.default_db
def runTest(self): """ This function will add function under schema node. """ super(FunctionAddTestCase, self).runTest() self = funcs_utils.set_up(self) db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "sql", "name": "test_function", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": "integer", "prosecdef": True, "prosrc": "SELECT 1;", "probin": "$libdir/", "provolatile": "s", "seclabels": [], "variables": [] } data["name"] = "test_function_add_%s" % str(uuid.uuid4())[1:8] if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will check messages return by query tool polling. """ database_info = parent_node_dict["database"][-1] self.server_id = database_info["server_id"] self.db_id = database_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to the database.") # Initialize query tool url = '/datagrid/initialize/query_tool/{0}/{1}/{2}'.format( utils.SERVER_GROUP, self.server_id, self.db_id) response = self.tester.post(url) self.assertEquals(response.status_code, 200) response_data = json.loads(response.data.decode('utf-8')) self.trans_id = response_data['data']['gridTransId'] cnt = 0 for s in self.sql: print("Executing and polling with: " + self.print_messages[cnt]) # Start query tool transaction url = '/sqleditor/query_tool/start/{0}'.format(self.trans_id) response = self.tester.post(url, data=json.dumps({"sql": s}), content_type='html/json') self.assertEquals(response.status_code, 200) # Query tool polling url = '/sqleditor/poll/{0}'.format(self.trans_id) response = self.tester.get(url) self.assertEquals(response.status_code, 200) response_data = json.loads(response.data.decode('utf-8')) if self.expected_message[cnt] is not None: # Check the returned messages self.assertIn(self.expected_message[cnt], response_data['data']['additional_messages']) # Check the output self.assertEquals(self.expected_result[cnt], response_data['data']['result'][0][0]) cnt += 1 # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will update trigger function under database node. """ schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] func_name = "test_event_put_%s" % str(uuid.uuid4())[1:8] server_con = server_utils.connect_server(self, server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add resource " "groups.") server_version = 0 if "type" in server_con["data"]: if server_con["data"]["version"] < 90300: server_version = server_con["data"]["version"] self.function_info = trigger_funcs_utils.create_trigger_function( self.server, self.db_name, self.schema_name, func_name, server_version) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") func_name = self.function_info[1] func_response = trigger_funcs_utils.verify_trigger_function( self.server, self.db_name, func_name) if not func_response: raise Exception("Could not find the trigger function to update" " it's details.") trigger_func_id = self.function_info[0] data = { "description": "This is trigger function update comment", "id": trigger_func_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(trigger_func_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def runTest(self): """ This function will delete function under database node. """ super(FunctionGetTestCase, self).setUp() self = funcs_utils.set_up(self) func_name = "test_function_get_%s" % str(uuid.uuid4())[1:8] function_info = funcs_utils.create_function( self.server, self.db_name, self.schema_name, func_name) trigger_func_id = function_info[0] response = self.tester.get( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(trigger_func_id), content_type='html/json') self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will delete trigger function under database node. """ schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] func_name = "test_event_delete_%s" % str(uuid.uuid4())[1:8] server_con = server_utils.connect_server(self, server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add resource " "groups.") server_version = 0 if "type" in server_con["data"]: if server_con["data"]["version"] < 90300: server_version = server_con["data"]["version"] self.function_info = trigger_funcs_utils.create_trigger_function( self.server, self.db_name, self.schema_name, func_name, server_version) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") trigger_func_id = self.function_info[0] response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(trigger_func_id), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def tearDown(self): """This function disconnect the test database.""" database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added extension and dependant objects.""" database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): db_con = database_utils.connect_database(self, test_utils.SERVER_GROUP, self._sid, self._did) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to the database.") # Initialize query tool self.trans_id = str(random.randint(1, 9999999)) url = self.init_url.format(self.trans_id, test_utils.SERVER_GROUP, self._sid, self._did) response = self.tester.post(url) self.assertEqual(response.status_code, 200) res = self.initiate_sql_query_tool(self.trans_id, self.sql) # If invalid tx test then make the Tx id invalid so that tests fails if not self.is_valid_tx: self.trans_id = self.trans_id + '007' # Check character url = self.donwload_url.format(self.trans_id) # Disable the console logging from Flask logger self.app.logger.disabled = True if not self.is_valid and self.is_valid_tx: # When user enters wrong query, poll will throw 500, so expecting # 500, as poll is never called for a wrong query. self.assertEqual(res.status_code, 500) elif self.filename is None: if self.download_as_txt: with patch( 'pgadmin.tools.sqleditor.blueprint.' 'csv_field_separator.get', return_value=';'), patch( 'time.time', return_value=1587031962.3808076): response = self.tester.post(url, data={"query": self.sql}) headers = dict(response.headers) # when valid query self.assertEqual(response.status_code, 200) csv_data = response.data.decode() self.assertTrue(self.output_columns in csv_data) self.assertTrue(self.output_values in csv_data) self.assertIn('text/plain', headers['Content-Type']) self.assertIn('1587031962.txt', headers['Content-Disposition']) else: with patch('time.time', return_value=1587031962.3808076): response = self.tester.post(url, data={"query": self.sql}) headers = dict(response.headers) # when valid query self.assertEqual(response.status_code, 200) csv_data = response.data.decode() self.assertTrue(self.output_columns in csv_data) self.assertTrue(self.output_values in csv_data) self.assertIn('text/csv', headers['Content-Type']) self.assertIn('1587031962.csv', headers['Content-Disposition']) else: response = self.tester.post(url, data={ "query": self.sql, "filename": self.filename }) headers = dict(response.headers) # Enable the console logging from Flask logger self.app.logger.disabled = False if self.is_valid: # when valid query self.assertEqual(response.status_code, 200) csv_data = response.data.decode() self.assertTrue(self.output_columns in csv_data) self.assertTrue(self.output_values in csv_data) self.assertIn('text/csv', headers['Content-Type']) self.assertIn(self.filename, headers['Content-Disposition']) elif not self.is_valid and self.is_valid_tx: # When user enters wrong query self.assertEqual(response.status_code, 200) response_data = json.loads(response.data.decode('utf-8')) self.assertFalse(response_data['data']['status']) self.assertTrue( 'relation "this_table_does_not_exist" does not exist' in response_data['data']['result']) else: # when TX id is invalid self.assertEqual(response.status_code, 500) # Close query tool url = '/datagrid/close/{0}'.format(self.trans_id) response = self.tester.delete(url) self.assertEqual(response.status_code, 200) database_utils.disconnect_database(self, self._sid, self._did)
def tearDown(self): """This function delete the FDW and disconnect the test database """ fdw_utils.delete_fdw(self.server, self.db_name, self.fdw_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDownClass(cls): # Disconnect the database database_utils.disconnect_database(cls, cls.server_id, cls.db_id)
def tearDown(self): """This function will disconnect test database.""" database_utils.disconnect_database(self, self.server_id, self.db_id) self.server['db'] = self.default_db
def tearDownClass(cls): # Disconnect the database database_utils.disconnect_database(cls, cls.server_id, cls.db_id)
def runTest(self): """ This function will add procedure under schema node. """ super(ProcedureAddTestCase, self).setUp() self = funcs_utils.set_up(self) if self.server_type == "pg" and\ self.server_version < 110000: message = "Procedures are not supported by PG < 110000." self.skipTest(message) db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "sql", "name": "test_pg_11_proc", "options": [], "proleakproof": True, "pronamespace": 2200, "prosecdef": True, "prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled'," " tg_tag; END;", "seclabels": [], "variables": [ { "name": "enable_sort", "value": True } ] } data["name"] = "test_proc_add_%s" % str(uuid.uuid4())[1:8] if self.server_type == 'pg': data['prosrc'] = 'SELECT 1;' if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database.""" database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added extension.""" extension_utils.drop_extension(self.server, self.db_name, self.extension_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will add trigger function under schema node. """ super(TriggerFuncAddTestCase, self).runTest() self = funcs_utils.set_up(self) db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "plpgsql", "name": "test_abort_any_command", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": self.prorettypename, "prosecdef": True, "prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled'," " tg_tag; END;", "provolatile": "s", "seclabels": [], "variables": [ { "name": "enable_sort", "value": True }, { "name": "search_path", "value": "public, pg_temp" } ] } # Get the type from data. We are adding two types # i.e. event_trigger and trigger. trigger_func_types = data['prorettypename'].split('/') for func_type in trigger_func_types: data['prorettypename'] = func_type data["name"] = "test_event_add_%s" % str(uuid.uuid4())[1:8] if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json' ) self.assertEqual(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect database.""" database_utils.disconnect_database(self, self.sid, self.did)
def runTest(self): """ This function will add procedure under schema node. """ super(ProcedureAddTestCase, self).setUp() self = funcs_utils.set_up(self) if self.server_type == "pg" and\ self.server_version < 110000: message = "Procedures are not supported by PG < 110000." self.skipTest(message) db_user = self.server["username"] data = { "acl": [{ "grantee": db_user, "grantor": db_user, "privileges": [{ "privilege_type": "X", "privilege": True, "with_grant": True }] }], "arguments": [], "funcowner": db_user, "lanname": "sql", "name": "test_pg_11_proc", "options": [], "proleakproof": True, "pronamespace": 2200, "prosecdef": True, "prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled'," " tg_tag; END;", "seclabels": [], "variables": [{ "name": "enable_sort", "value": True }, { "name": "search_path", "value": "public, pg_temp" }] } data["name"] = "test_proc_add_%s" % str(uuid.uuid4())[1:8] if self.server_type == 'pg': data['prosrc'] = 'SELECT 1;' if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEqual(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added cast.""" if self.is_positive_test: database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop foreign data wrapper and dependant objects.""" fdw_utils.delete_fdw(self.server, self.db_name, self.fdw_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): # Disconnect the database extension_utils.drop_extension(self.server, self.db_name, self.extension_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will add trigger function under schema node. """ super(TriggerFuncAddTestCase, self).runTest() db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] prorettypename = "event_trigger/trigger" server_con = server_utils.connect_server(self, server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add resource " "groups.") if "type" in server_con["data"]: if server_con["data"]["version"] < 90300: prorettypename = "trigger" db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a function.") schema_id = schema_info["schema_id"] schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add a function.") db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "plpgsql", "name": "test_abort_any_command", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": prorettypename, "prosecdef": True, "prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled'," " tg_tag; END;", "provolatile": "s", "seclabels": [], "variables": [ { "name": "enable_sort", "value": True } ] } # Get the type from data. We are adding two types # i.e. event_trigger and trigger. trigger_func_types = data['prorettypename'].split('/') for func_type in trigger_func_types: data['prorettypename'] = func_type data["name"] = "test_event_add_%s" % str(uuid.uuid4())[1:8] if schema_id: data['pronamespace'] = schema_id else: schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/', data=json.dumps(data), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def tearDown(self): publication_utils.delete_publication(self.server, self.db_name, self.publication_name) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will add function under schema node. """ super(FunctionAddTestCase, self).runTest() self = funcs_utils.set_up(self) db_user = self.server["username"] data = { "acl": [{ "grantee": db_user, "grantor": db_user, "privileges": [{ "privilege_type": "X", "privilege": True, "with_grant": True }] }], "arguments": [], "funcowner": db_user, "lanname": "sql", "name": "test_function", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": "integer", "prosecdef": True, "prosrc": "SELECT 1;", "probin": "$libdir/", "provolatile": "s", "seclabels": [], "variables": [] } data["name"] = "test_function_add_%s" % str(uuid.uuid4())[1:8] if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] if self.server_version >= 120000: support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8] support_func = funcs_utils.create_support_internal_function( self.server, self.db_name, self.schema_name, support_function_name) data['prosupportfuc'] = support_function_name response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added extension and dependant objects.""" extension_utils.drop_extension(self.server, self.db_name, self.extension_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): # Close query tool self._close_query_tool() # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added foreign data wrapper.""" extension_utils.drop_extension(self.server, self.db_name, self.extension_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function disconnect the test database and drop added extension. """ db_name = parent_node_dict["database"][-1]['db_name'] extension_utils.drop_extension(self.server, db_name, self.data['name']) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function delete added language and disconnect the test database.""" language_utils.delete_language(self.server, self.db_name, self.lang_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function delete the FDW and disconnect the test database """ fdw_utils.delete_fdw(self.server, self.db_name, self.fdw_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): database_utils.disconnect_database( self, self.server_information['server_id'], self.server_information['db_id'])
def tearDown(self): """This function delete the server from SQLite """ debugger_utils.close_debugger(self) debugger_utils.delete_function(self, utils) db_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): # Disconnect the database subscription_utils.delete_subscription(self.server, self.db_name, self.subscription_name) database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): # Disconnect database to delete it database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """This function delete the server from SQLite """ db_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self): """ This function will add function under schema node. """ super(FunctionAddTestCase, self).runTest() self = funcs_utils.set_up(self) db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "sql", "name": "test_function", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": "integer", "prosecdef": True, "prosrc": "SELECT 1;", "probin": "$libdir/", "provolatile": "s", "seclabels": [], "variables": [{ "name": "search_path", "value": "public, pg_temp" }] } data["name"] = "test_function_add_%s" % str(uuid.uuid4())[1:8] if self.schema_id: data['pronamespace'] = self.schema_id else: self.schema_id = data['pronamespace'] if self.server_version >= 120000: support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8] funcs_utils.create_support_internal_function( self.server, self.db_name, self.schema_name, support_function_name ) data['prosupportfuc'] = support_function_name if self.is_positive_test: response = self.create_function(data) else: if hasattr(self, 'is_mock_function'): def _get_sql(self, **kwargs): return False, '' with patch.object(FunctionView, self.mock_data["function_name"], new=_get_sql): response = self.create_function(data) else: with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): response = self.create_function(data) self.assertEqual(response.status_code, self.expected_data['status_code']) # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): database_utils.disconnect_database( self, self.server_information['server_id'], self.server_information['db_id']) self.test_config_db_conn.close()
def tearDown(self): """This function will disconnect test database.""" database_utils.disconnect_database(self, self.server_id, self.db_id) self.server['db'] = self.default_db
def runTest(self): """ This function will delete schema under database node. """ server_id = self.database_info["server_id"] db_id = self.database_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to delete the" " schema.") schema_id = self.schema_details[0] schema_name = self.schema_details[1] schema_response = schema_utils.verify_schemas(self.server, self.db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to update.") db_user = self.server["username"] data = { "deffuncacl": { "added": [{ "grantee": db_user, "grantor": db_user, "privileges": [{ "privilege_type": "X", "privilege": True, "with_grant": True }] }] }, "defseqacl": { "added": [{ "grantee": db_user, "grantor": db_user, "privileges": [{ "privilege_type": "r", "privilege": True, "with_grant": False }, { "privilege_type": "w", "privilege": True, "with_grant": False }, { "privilege_type": "U", "privilege": True, "with_grant": False }] }] }, "deftblacl": { "added": [{ "grantee": "public", "grantor": db_user, "privileges": [{ "privilege_type": "D", "privilege": True, "with_grant": False }, { "privilege_type": "x", "privilege": True, "with_grant": False }] }] }, "id": schema_id } put_response = self.tester.put(self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def tearDown(self): # Disconnect the database database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self): """Close debugger connection.""" debugger_utils.close_debugger(self) debugger_utils.delete_function(self, utils) db_utils.disconnect_database(self, self.server_id, self.db_id)