def test_function_duplicate_indicator(self): """Unit tests for custom function duplicate_indicator.""" # Insert test indicator group test_case_name = get_test_case_name() insert_indicator_group_query = f'INSERT INTO base.indicator_group (name) VALUES (\'{test_case_name}\');' self.connection.execute(insert_indicator_group_query) self.connection.commit() # Get test indicator group Id select_indicator_group_query = f'SELECT id FROM base.indicator_group WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_indicator_group_query) row = cursor.fetchone() indicator_group_id = row[0] # Insert test indicator insert_indicator_query = f'''INSERT INTO base.indicator (name, flag_active, indicator_type_id, indicator_group_id) VALUES ('{test_case_name}', true, 1, {indicator_group_id});''' self.connection.execute(insert_indicator_query) self.connection.commit() # Get test indicator Id select_indicator_query = f'SELECT id FROM base.indicator WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_indicator_query) row = cursor.fetchone() indicator_id = row[0] # Insert test parameter insert_parameter_query = f'INSERT INTO base.parameter (value, indicator_id, parameter_type_id) VALUES (\'{test_case_name}\', {indicator_id}, 1);' self.connection.execute(insert_parameter_query) self.connection.commit() # Call test duplicate indicator function new_test_case_name = get_test_case_name() call_test_duplicate_indicator_query = f'SELECT base.duplicate_indicator({indicator_id}, \'{new_test_case_name}\');' self.connection.execute(call_test_duplicate_indicator_query) # Get new indicator and parameter select_new_indicator_query = f'''SELECT a.name, b.value FROM base.indicator a INNER JOIN base.parameter b ON a.id=b.indicator_id WHERE name = '{new_test_case_name}';''' cursor = self.connection.execute(select_new_indicator_query) row = cursor.fetchone() # Assert duplicated indicator name and parameter value name = row[0] value = row[0] self.assertEqual(name, new_test_case_name) self.assertEqual(value, new_test_case_name)
def test_verify_indicator_parameters_latency(self): """Unit tests for method verify_indicator_parameters for latency indicators.""" # Authenticate user authorization = get_authorization() # Create test indicator group test_case_name = get_test_case_name() mutation_create_indicator_group = '''mutation{createIndicatorGroup(input:{indicatorGroup:{name:"test_case_name",}}){indicatorGroup{id}}}''' mutation_create_indicator_group = mutation_create_indicator_group.replace('test_case_name', str(test_case_name)) # Use replace() instead of format() because of curly braces mutation_create_indicator_group = {'query': mutation_create_indicator_group} # Convert to dictionary indicator_group = utils.execute_graphql_request(authorization, mutation_create_indicator_group) indicator_group_id = indicator_group['data']['createIndicatorGroup']['indicatorGroup']['id'] # Create test indicator indicator_type_id = IndicatorType.LATENCY mutation_create_indicator = '''mutation{createIndicator(input:{indicator:{name:"test_case_name",flagActive:true,indicatorTypeId:indicator_type_id,indicatorGroupId:indicator_group_id}}){indicator{id}}}''' mutation_create_indicator = mutation_create_indicator.replace('indicator_type_id', str(indicator_type_id)) # Use replace() instead of format() because of curly braces mutation_create_indicator = mutation_create_indicator.replace('test_case_name', str(test_case_name)) # Use replace() instead of format() because of curly braces mutation_create_indicator = mutation_create_indicator.replace('indicator_group_id', str(indicator_group_id)) # Use replace() instead of format() because of curly braces mutation_create_indicator = {'query': mutation_create_indicator} # Convert to dictionary indicator = utils.execute_graphql_request(authorization, mutation_create_indicator) indicator_id = indicator['data']['createIndicator']['indicator']['id'] # Create test indicator parameters default_parameters = { 1: "==", # Alert operator 2: "0", # Alert threshold 3: "['email_1', 'email_2', 'email_3']", # Distribution list 4: "['dimension_1', 'dimension_2', 'dimension_3']", # Dimension 5: "['measure_1', 'measure_2', 'measure_3']", # Measures 6: "Source", # Source 7: "Source request", # Source request 8: "Target", # Target 9: "Target request" # Target request } for param_key, param_value in default_parameters.items(): mutation_create_parameter = '''mutation{createParameter(input:{parameter:{parameterTypeId:param_key,value:"param_value",indicatorId:indicator_id}}){parameter{id}}}''' mutation_create_parameter = mutation_create_parameter.replace('param_key', str(param_key)) # Use replace() instead of format() because of curly braces mutation_create_parameter = mutation_create_parameter.replace('param_value', str(param_value)) # Use replace() instead of format() because of curly braces mutation_create_parameter = mutation_create_parameter.replace('indicator_id', str(indicator_id)) # Use replace() instead of format() because of curly braces mutation_create_parameter = {'query': mutation_create_parameter} # Convert to dictionary utils.execute_graphql_request(authorization, mutation_create_parameter) # Get list of parameters query_get_parameters = '''query{indicatorById(id:indicator_id){parametersByIndicatorId{nodes{parameterTypeId,value}}}}''' query_get_parameters = query_get_parameters.replace('indicator_id', str(indicator_id)) # Use replace() instead of format() because of curly braces query_get_parameters = {'query': query_get_parameters} # Convert to dictionary parameters = utils.execute_graphql_request(authorization, query_get_parameters) parameters = parameters['data']['indicatorById']['parametersByIndicatorId']['nodes'] indicator = Indicator() verified_parameters = indicator.verify_indicator_parameters(authorization, indicator_type_id, parameters) # Assert list of parameters is correct self.assertEqual(len(verified_parameters), 9) self.assertEqual(len(verified_parameters[3]), 3) self.assertEqual(len(verified_parameters[4]), 3) self.assertEqual(len(verified_parameters[5]), 3)
def test_get_data_frame(self): """Unit tests for method get_data_frame.""" # Authenticate user authorization = get_authorization() # Create data source test_case_name = get_test_case_name() mutation_create_data_source = '''mutation{createDataSource(input:{dataSource:{name:"test_case_name",connectionString:"driver={PostgreSQL Unicode};server=db-postgresql;port=5432;database=star_wars;",login:"******",password:"******",dataSourceTypeId:7}}){dataSource{name}}}''' mutation_create_data_source = mutation_create_data_source.replace('test_case_name', str(test_case_name)) # Use replace() instead of format() because of curly braces mutation_create_data_source = {'query': mutation_create_data_source} # Convert to dictionary data_source = utils.execute_graphql_request(authorization, mutation_create_data_source) data_source = data_source['data']['createDataSource']['dataSource']['name'] # Set parameters and call method request = 'SELECT gender, COUNT(id) FROM people GROUP BY gender;' dimensions = ['gender'] measures = ['nb_people'] indicator = Indicator() data_frame = indicator.get_data_frame(authorization, data_source, request, dimensions, measures) # Assert data frame is correct nb_records = len(data_frame) nb_females = data_frame.loc[data_frame['gender'] == 'female', 'nb_people'].item() self.assertEqual(nb_records, 5) self.assertEqual(nb_females, 19)
def test_trigger_delete_children(self): """Unit tests for trigger function delete_children.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name) # Insert user group user_group_id = self.create_user_group(test_case_name) # Insert user group user user_group_user_id = self.create_user_group_user( user_group_id, user_id) # Delete user group self.delete_user_group(user_group_id) # Get user group user select_user_group_user_query = f'''SELECT id FROM base.user_group_user WHERE id = '{user_group_user_id}';''' cursor = self.connection.execute(select_user_group_user_query) row = cursor.fetchone() # Assert user group user has been deleted self.assertTrue(row is None) # Rollback uncommitted data self.rollback()
def test_kill_test_data_source(self): """Unit tests for custom function kill_test_data_source.""" # Insert data source test_case_name = get_test_case_name() data = self.create_data_source(test_case_name) data_source_id = data[0] # Call test data source function call_test_data_source_query = f'''SELECT base.test_data_source({data_source_id});''' self.connection.execute(call_test_data_source_query) # Call kill test data source function call_kill_test_data_source_query = f'''SELECT base.kill_test_data_source({data_source_id});''' self.connection.execute(call_kill_test_data_source_query) # Get data source connectivity status select_data_source_status_query = f'''SELECT A.connectivity_status FROM base.data_source A WHERE A.id = {data_source_id};''' cursor = self.connection.execute(select_data_source_status_query) row = cursor.fetchone() # Assert batch and session status are Pending data_source_status = row[0] self.assertEqual(data_source_status, 'Killed') # Rollback uncommitted data self.rollback()
def test_function_execute_batch(self): """Unit tests for custom function execute_batch.""" # Insert user group test_case_name = get_test_case_name() user_group_id = self.create_user_group(test_case_name) # Insert indicator group indicator_group_id = self.create_indicator_group( test_case_name, user_group_id) # Insert indicator self.create_indicator(test_case_name, indicator_group_id, user_group_id) # Call execute batch function call_execute_batch_query = f'''SELECT base.execute_batch({indicator_group_id});''' self.connection.execute(call_execute_batch_query) # Get batch and indicator session select_batch_query = f'''SELECT B.status, C.status FROM base.indicator_group A INNER JOIN base.batch B ON A.id = B.indicator_group_id INNER JOIN base.session C ON B.id = C.batch_id WHERE A.id = '{indicator_group_id}';''' cursor = self.connection.execute(select_batch_query) row = cursor.fetchone() # Assert batch and session status are Pending batch_status = row[0] session_status = row[1] self.assertEqual(batch_status, 'Pending') self.assertEqual(session_status, 'Pending') # Rollback uncommitted data self.rollback()
def test_trigger_revoke_user_group(self): """Unit tests for trigger function revoke_user_group.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name) user = f'user_{user_id}' # Insert user group user_group_id = self.create_user_group(test_case_name) user_group = f'user_group_{user_group_id}' # Insert user group user user_group_user_id = self.create_user_group_user( user_group_id, user_id) # Delete user group user insert_user_group_user_query = f'''DELETE FROM base.user_group_user WHERE id = {user_group_user_id};''' self.connection.execute(insert_user_group_user_query) # Get user and user group select_user_group_user_query = f'''SELECT a.rolname, c.rolname FROM pg_catalog.pg_roles a INNER JOIN pg_catalog.pg_auth_members b ON a.oid = b.member INNER JOIN pg_catalog.pg_roles c ON b.roleid = c.oid WHERE a.rolname = '{user}' AND c.rolname = '{user_group}';''' cursor = self.connection.execute(select_user_group_user_query) row = cursor.fetchone() # Assert user group role has been revoked self.assertTrue(row is None) # Rollback uncommitted data self.rollback()
def test_update_batch_status(self): """Unit tests for method update_batch_status.""" # Create test indicator group test_case_name = get_test_case_name() mutation_create_indicator_group = '''mutation{createIndicatorGroup(input:{indicatorGroup:{name:"test_case_name"}}){indicatorGroup{id}}}''' mutation_create_indicator_group = mutation_create_indicator_group.replace( 'test_case_name', str(test_case_name) ) # Use replace() instead of format() because of curly braces indicator_group = utils.execute_graphql_request( mutation_create_indicator_group) indicator_group_id = indicator_group['data']['createIndicatorGroup'][ 'indicatorGroup']['id'] # Create test batch mutation_create_batch = '''mutation{createBatch(input:{batch:{indicatorGroupId:indicator_group_id,status:"Pending"}}){batch{id}}}''' mutation_create_batch = mutation_create_batch.replace( 'indicator_group_id', str(indicator_group_id) ) # Use replace() instead of format() because of curly braces batch = utils.execute_graphql_request(mutation_create_batch) batch_id = batch['data']['createBatch']['batch']['id'] # Update test batch status batch = Batch() data = batch.update_batch_status(batch_id, 'Running') batch_status = data['data']['updateBatchById']['batch']['status'] # Assert batch status is Running self.assertEqual(batch_status, 'Running')
def test_trigger_update_updated_date(self): """Unit tests for trigger function update_updated_date.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name) # Commit is necessary here for the test case to pass # It ensure updated_date will be greater than created_date self.connection.commit() # Update user data = self.update_user(user_id) updated_date = data[1] created_date = data[2] # Assert created_date is older than updated_date self.assertLess(created_date, updated_date) # Delete committed data delete_user_group_user_query = f'''DELETE FROM base.user_group_user WHERE user_id = {user_id};''' self.connection.execute(delete_user_group_user_query) delete_user_query = f'''DELETE FROM base.user WHERE id = {user_id};''' self.connection.execute(delete_user_query) self.connection.commit()
def test_trigger_delete_children(self): """Unit tests for trigger delete_children.""" # Insert test parent record test_case_name = get_test_case_name() insert_parent_query = f'INSERT INTO base.data_source_type (name) VALUES (\'{test_case_name}\');' self.connection.execute(insert_parent_query) self.connection.commit() # Get test parent record Id select_parent_query = f'SELECT id FROM base.data_source_type WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_parent_query) row = cursor.fetchone() data_source_type_id = row[0] # Insert test child record insert_child_query = f'INSERT INTO base.data_source (name, data_source_type_id) VALUES (\'{test_case_name}\', \'{data_source_type_id}\');' self.connection.execute(insert_child_query) self.connection.commit() # Delete test parent record delete_parent_query = f'DELETE FROM base.data_source_type WHERE id = {data_source_type_id}' self.connection.execute(delete_parent_query) self.connection.commit() # Gat test child record select_child_query = f'SELECT id FROM base.data_source WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_child_query) row = cursor.fetchone() # Assert test child record has been deleted self.assertTrue(row is None)
def test_function_test_data_source(self): """Unit tests for custom function test_data_source.""" # Insert test data source test_case_name = get_test_case_name() insert_data_source_query = f'INSERT INTO base.data_source (name, data_source_type_id) VALUES (\'{test_case_name}\', 1);' self.connection.execute(insert_data_source_query) self.connection.commit() # Get test data source Id select_data_source_query = f'SELECT id FROM base.data_source WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_data_source_query) row = cursor.fetchone() data_source_id = row[0] # Call test data source function call_test_data_source_query = f'SELECT base.test_data_source({data_source_id});' self.connection.execute(call_test_data_source_query) # Get data source connectivity status select_data_source_query = f'SELECT connectivity_status FROM base.data_source WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_data_source_query) row = cursor.fetchone() # Assert connectivity status is Pending connectivity_status = row[0] self.assertEqual(connectivity_status, 'Pending')
def test_function_get_current_user_id(self): """Unit tests for custom function get_current_user_id.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name) user = f'user_{user_id}' # Change role set_role_query = f'''SET ROLE {user};''' self.connection.execute(set_role_query) # Get current user Id based on current role select_query = f'''SELECT base.get_current_user_id();''' cursor = self.connection.execute(select_query) current_user_id = cursor.fetchone()[0] # Assert user Id is equal to Id extracted from role self.assertEqual(user_id, current_user_id) # Reverse current role to postgres set_role_query = f'''SET ROLE postgres;''' self.connection.execute(set_role_query) # Rollback uncommitted data self.rollback()
def test_trigger_update_updated_by_id(self): """Unit tests for trigger function update_updated_by_id.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name, True) user = f'user_{user_id}' # Change current role to new user set_role_query = f'''SET ROLE {user};''' self.connection.execute(set_role_query) # Update user data = self.update_user(user_id) updated_by_id = data[0] # Assert user Id is equal updated by Id self.assertEqual(user_id, updated_by_id) # Reverse current role to postgres set_role_query = f'''SET ROLE postgres;''' self.connection.execute(set_role_query) # Rollback uncommitted data self.rollback()
def test_trigger_grant_user_group(self): """Unit tests for trigger function grant_user_group.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name) user = f'user_{user_id}' # Insert user group user_group_id = self.create_user_group(test_case_name) user_group = f'user_group_{user_group_id}' # Insert user group user self.create_user_group_user(user_group_id, user_id) # Get user and user group roles select_user_group_user_query = f'''SELECT a.rolname, c.rolname FROM pg_catalog.pg_roles a INNER JOIN pg_catalog.pg_auth_members b ON a.oid = b.member INNER JOIN pg_catalog.pg_roles c ON b.roleid = c.oid WHERE a.rolname = '{user}' AND c.rolname = '{user_group}';''' cursor = self.connection.execute(select_user_group_user_query) row = cursor.fetchone() # Assert user was created and user group role granted self.assertEqual(row[0], user) self.assertEqual(row[1], user_group) # Rollback uncommitted data self.rollback()
def test_trigger_data_source_insert_password(self): """Unit tests for trigger function data_source_insert_password.""" # Insert data source test_case_name = get_test_case_name() data = self.create_data_source(test_case_name) password = data[1] # Assert password is encrypted self.assertNotEqual(password, '1234') # Rollback uncommitted data self.rollback()
def test_update_session_status(self): """Unit tests for method update_session_status.""" # Create test indicator group test_case_name = get_test_case_name() mutation_create_indicator_group = '''mutation{createIndicatorGroup(input:{indicatorGroup:{name:"test_case_name"}}){indicatorGroup{id}}}''' mutation_create_indicator_group = mutation_create_indicator_group.replace( 'test_case_name', str(test_case_name) ) # Use replace() instead of format() because of curly braces indicator_group = utils.execute_graphql_request( mutation_create_indicator_group) indicator_group_id = indicator_group['data']['createIndicatorGroup'][ 'indicatorGroup']['id'] # Create test indicator mutation_create_indicator = '''mutation{createIndicator(input:{indicator:{name:"test_case_name",flagActive:true,indicatorTypeId:1,indicatorGroupId:indicator_group_id}}){indicator{id}}}''' mutation_create_indicator = mutation_create_indicator.replace( 'test_case_name', str(test_case_name) ) # Use replace() instead of format() because of curly braces mutation_create_indicator = mutation_create_indicator.replace( 'indicator_group_id', str(indicator_group_id) ) # Use replace() instead of format() because of curly braces indicator = utils.execute_graphql_request(mutation_create_indicator) indicator_id = indicator['data']['createIndicator']['indicator']['id'] # Create test batch mutation_create_batch = '''mutation{createBatch(input:{batch:{indicatorGroupId:indicator_group_id,status:"Pending"}}){batch{id}}}''' mutation_create_batch = mutation_create_batch.replace( 'indicator_group_id', str(indicator_group_id) ) # Use replace() instead of format() because of curly braces batch = utils.execute_graphql_request(mutation_create_batch) batch_id = batch['data']['createBatch']['batch']['id'] # Create test session mutation_create_session = '''mutation{createSession(input:{session:{indicatorId:indicator_id,batchId:batch_id,status:"Pending"}}){session{id}}}''' mutation_create_session = mutation_create_session.replace( 'indicator_id', str(indicator_id) ) # Use replace() instead of format() because of curly braces mutation_create_session = mutation_create_session.replace( 'batch_id', str(batch_id) ) # Use replace() instead of format() because of curly braces session = utils.execute_graphql_request(mutation_create_session) session_id = session['data']['createSession']['session']['id'] # Update test session status data = update_session_status(session_id, 'Running') session_status = data['data']['updateSessionById']['session']['status'] # Assert batch status is Running self.assertEqual(session_status, 'Running')
def test_function_duplicate_indicator(self): """Unit tests for custom function duplicate_indicator.""" # Insert user group test_case_name = get_test_case_name() user_group_id = self.create_user_group(test_case_name) # Insert indicator group indicator_group_id = self.create_indicator_group( test_case_name, user_group_id) # Insert indicator indicator_id = self.create_indicator(test_case_name, indicator_group_id, user_group_id) # Insert test parameter insert_parameter_query = f'''INSERT INTO base.parameter (value, indicator_id, parameter_type_id, user_group_id) VALUES ('{test_case_name}', {indicator_id}, 1, {user_group_id});''' self.connection.execute(insert_parameter_query) # Call test duplicate indicator function new_test_case_name = get_test_case_name() call_test_duplicate_indicator_query = f'''SELECT base.duplicate_indicator({indicator_id}, '{new_test_case_name}');''' self.connection.execute(call_test_duplicate_indicator_query) # Get new indicator and parameter select_new_indicator_query = f'''SELECT a.name, b.value FROM base.indicator a INNER JOIN base.parameter b ON a.id = b.indicator_id WHERE a.name = '{new_test_case_name}';''' cursor = self.connection.execute(select_new_indicator_query) row = cursor.fetchone() # Assert duplicated indicator name and parameter value indiator_name = row[0] parameter_value = row[1] self.assertEqual(indiator_name, new_test_case_name) self.assertEqual(parameter_value, test_case_name) # Rollback uncommitted data self.rollback()
def test_trigger_update_updated_date(self): """Unit tests for trigger update_updated_date.""" # Insert test record test_case_name = get_test_case_name() insert_query = f'INSERT INTO base.data_source_type (name) VALUES (\'{test_case_name}\');' self.connection.execute(insert_query) self.connection.commit() # Update test record test_case_name_updated = get_test_case_name() update_query = f'UPDATE base.data_source_type SET name = \'{test_case_name_updated}\' WHERE name = \'{test_case_name}\';' self.connection.execute(update_query) self.connection.commit() # Get updated record select_query = f'SELECT created_date, updated_date FROM base.data_source_type WHERE name = \'{test_case_name_updated}\';' cursor = self.connection.execute(select_query) row = cursor.fetchone() # Assert created_date < updated_date created_date = row[0] updated_date = row[1] self.assertTrue(created_date < updated_date)
def test_trigger_create_user_group(self): """Unit tests for trigger function create_user_group.""" # Insert user group test_case_name = get_test_case_name() user_group_id = self.create_user_group(test_case_name) user_group = f'user_group_{user_group_id}' # Get user group role select_user_role_query = f'''SELECT a.rolname AS user_group FROM pg_catalog.pg_roles a WHERE a.rolname = '{user_group}';''' cursor = self.connection.execute(select_user_role_query) row = cursor.fetchone() # Assert user group role was created self.assertEqual(row[0], user_group) # Rollback uncommitted data self.rollback()
def test_trigger_data_source_update_password(self): """Unit tests for trigger function data_source_update_password.""" # Insert data source test_case_name = get_test_case_name() data = self.create_data_source(test_case_name) data_source_id = data[0] password = data[1] # Update data source updated_password = self.update_data_source(data_source_id) # Assert password is encrypted self.assertNotEqual(updated_password, '0000') self.assertNotEqual(password, updated_password) # Rollback uncommitted data self.rollback()
def test_trigger_delete_user_group(self): """Unit tests for trigger function delete_user_group.""" # Insert user group test_case_name = get_test_case_name() user_group_id = self.create_user_group(test_case_name) user_group = f'user_group_{user_group_id}' # Delete user group self.delete_user_group(user_group_id) # Get user group role select_user_role_query = f'''SELECT a.rolname AS user_group FROM pg_catalog.pg_roles a WHERE a.rolname = '{user_group}';''' cursor = self.connection.execute(select_user_role_query) row = cursor.fetchone() # Assert user group role has been deleted self.assertTrue(row is None) # Rollback uncommitted data self.rollback()
def test_function_test_data_source(self): """Unit tests for custom function test_data_source.""" # Insert data source test_case_name = get_test_case_name() data = self.create_data_source(test_case_name) data_source_id = data[0] # Call test data source function call_test_data_source_query = f'''SELECT base.test_data_source({data_source_id});''' self.connection.execute(call_test_data_source_query) # Get data source connectivity status select_data_source_query = f'''SELECT connectivity_status FROM base.data_source WHERE id = '{data_source_id}';''' cursor = self.connection.execute(select_data_source_query) connectivity_status = cursor.fetchone()[0] # Assert connectivity status is Pending self.assertEqual(connectivity_status, 'Pending') # Rollback uncommitted data self.rollback()
def test_trigger_update_user_permission(self): """Unit tests for trigger function update_user_permission.""" # Insert user test_case_name = get_test_case_name() user_id = self.create_user(test_case_name) user = f'user_{user_id}' # Update user role to admin self.update_user(user_id) # Get user and role select_user_role_query = f'''SELECT a.rolname AS user, c.rolname AS role FROM pg_catalog.pg_roles a INNER JOIN pg_catalog.pg_auth_members b ON a.oid = b.member INNER JOIN pg_catalog.pg_roles c ON b.roleid = c.oid AND c.rolname = 'admin' WHERE a.rolname = '{user}';''' cursor = self.connection.execute(select_user_role_query) row = cursor.fetchone() # Assert user was created and standard role granted self.assertEqual(row[0], user) self.assertEqual(row[1], 'admin') # Rollback uncommitted data self.rollback()
def test_function_execute_batch(self): """Unit tests for custom function execute_batch.""" # Insert test indicator group test_case_name = get_test_case_name() insert_indicator_group_query = f'INSERT INTO base.indicator_group (name) VALUES (\'{test_case_name}\');' self.connection.execute(insert_indicator_group_query) self.connection.commit() # Get test indicator group Id select_indicator_group_query = f'SELECT id FROM base.indicator_group WHERE name = \'{test_case_name}\';' cursor = self.connection.execute(select_indicator_group_query) row = cursor.fetchone() indicator_group_id = row[0] # Insert test indicator insert_indicator_query = f'''INSERT INTO base.indicator (name, flag_active, indicator_type_id, indicator_group_id) VALUES ('{test_case_name}', true, 1, {indicator_group_id});''' self.connection.execute(insert_indicator_query) self.connection.commit() # Call execute batch function call_execute_batch_query = f'SELECT base.execute_batch({indicator_group_id});' self.connection.execute(call_execute_batch_query) # Get batch and indicator session select_batch_query = f'''SELECT B.status, C.status FROM base.indicator_group A INNER JOIN base.batch B ON A.id = B.indicator_group_id INNER JOIN base.session C ON B.id = C.batch_id WHERE A.name = '{test_case_name}';''' cursor = self.connection.execute(select_batch_query) row = cursor.fetchone() # Assert batch and session status are Pending batch_status = row[0] session_status = row[1] self.assertEqual(batch_status, 'Pending') self.assertEqual(session_status, 'Pending')