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')
