def test_list_databases_handles_query_failure(self):
"""Test that the list databases handler returns an error if the list databases query fails for any reason"""
# Set up the test with mock data
mock_query_results = [('database1',), ('database2',)]
connection_uri = 'someuri'
mock_cursor = MockCursor(mock_query_results)
mock_cursor.fetchall.side_effect = psycopg2.ProgrammingError('')
mock_connection = MockConnection(
dsn_parameters={
'host': 'myserver',
'dbname': 'postgres',
'user': '******'
},
cursor=mock_cursor)
mock_request_context = utils.MockRequestContext()
# Insert a ConnectionInfo object into the connection service's map
connection_details = ConnectionDetails.from_data({})
connection_info = ConnectionInfo(connection_uri, connection_details)
self.connection_service.owner_to_connection_map[connection_uri] = connection_info
# Verify that calling the listdatabases handler returns the expected
# databases
params = ListDatabasesParams()
params.owner_uri = connection_uri
with mock.patch('psycopg2.connect', new=mock.Mock(return_value=mock_connection)):
self.connection_service.handle_list_databases(mock_request_context, params)
self.assertIsNone(mock_request_context.last_notification_method)
self.assertIsNone(mock_request_context.last_notification_params)
self.assertIsNone(mock_request_context.last_response_params)
self.assertIsNotNone(mock_request_context.last_error_message)
def test_handle_get_database_info_request(self):
"""Test that the database info handler responds with the correct database info"""
uri = 'test_uri'
db_name = 'test_db'
user_name = 'test_user'
# Set up the request parameters
params = GetDatabaseInfoParameters()
params.owner_uri = uri
request_context = MockRequestContext()
# Set up a mock connection and cursor for the test
mock_query_results = [(user_name, )]
mock_cursor = MockCursor(mock_query_results)
mock_connection = MockPGServerConnection(mock_cursor, name=db_name)
self.connection_service.get_connection = mock.Mock(
return_value=mock_connection)
# If I send a get_database_info request
self.admin_service._handle_get_database_info_request(
request_context, params)
# Then the service responded with the expected information
response = request_context.last_response_params
self.assertIsInstance(response, GetDatabaseInfoResponse)
expected_info = {'dbname': db_name, 'owner': user_name, 'size': None}
self.assertEqual(response.database_info.options, expected_info)
# And the service retrieved the owner name using a query with the database name as a parameter
owner_query = "SELECT pg_catalog.pg_get_userbyid(db.datdba) FROM pg_catalog.pg_database db WHERE db.datname = '{}'".format(
db_name)
mock_cursor.execute.assert_called_once_with(owner_query)
def setUp(self):
self._row_id = 1
self._rows = [("False", ), ("True", )]
self._result_set = create_result_set(ResultSetStorageType.IN_MEMORY, 0,
0)
cursor = MockCursor(self._rows, ['IsTrue'])
with mock.patch(
'pgsqltoolsservice.query.in_memory_result_set.get_columns_info',
new=mock.Mock()):
self._result_set.read_result_to_end(cursor)
db_column = DbColumn()
db_column.data_type = 'bool'
db_column.column_name = 'IsValid'
db_column.is_key = True
db_column.column_ordinal = 0
self._result_set.columns_info = [db_column]
self._columns_metadata = [
EditColumnMetadata(db_column, 'Default Value')
]
self._table_metadata = EditTableMetadata('public', 'TestTable',
self._columns_metadata)
self._row_delete = RowDelete(self._row_id, self._result_set,
self._table_metadata)
def test_list_databases(self):
"""Test that the list databases handler correctly lists the connection's databases"""
# Set up the test with mock data
mock_query_results = [('database1',), ('database2',)]
connection_uri = 'someuri'
mock_connection = MockConnection(
dsn_parameters={
'host': 'myserver',
'dbname': 'postgres',
'user': '******'
},
cursor=MockCursor(mock_query_results))
mock_request_context = utils.MockRequestContext()
# Insert a ConnectionInfo object into the connection service's map
connection_details = ConnectionDetails.from_data({})
connection_info = ConnectionInfo(connection_uri, connection_details)
self.connection_service.owner_to_connection_map[connection_uri] = connection_info
# Verify that calling the listdatabases handler returns the expected databases
params = ListDatabasesParams()
params.owner_uri = connection_uri
with mock.patch('psycopg2.connect', new=mock.Mock(return_value=mock_connection)):
self.connection_service.handle_list_databases(mock_request_context, params)
expected_databases = [result[0] for result in mock_query_results]
self.assertEqual(mock_request_context.last_response_params.database_names, expected_databases)
def setUp(self):
"""Set up the test by creating a query with multiple batches"""
self.statement_list = statement_list = [
'select version;', 'select * from t1;'
]
self.statement_str = ''.join(statement_list)
self.query_uri = 'test_uri'
self.query = Query(
self.query_uri, self.statement_str,
QueryExecutionSettings(ExecutionPlanOptions(),
ResultSetStorageType.FILE_STORAGE),
QueryEvents())
self.mock_query_results = [('Id1', 'Value1'), ('Id2', 'Value2')]
self.cursor = MockCursor(self.mock_query_results)
self.connection = MockPGServerConnection(cur=self.cursor)
self.columns_info = []
db_column_id = DbColumn()
db_column_id.data_type = 'text'
db_column_id.column_name = 'Id'
db_column_id.provider = PG_PROVIDER_NAME
db_column_value = DbColumn()
db_column_value.data_type = 'text'
db_column_value.column_name = 'Value'
db_column_value.provider = PG_PROVIDER_NAME
self.columns_info = [db_column_id, db_column_value]
self.get_columns_info_mock = mock.Mock(return_value=self.columns_info)
def setUp(self):
self._metadata_factory = mock.MagicMock()
self._mock_cursor = MockCursor(None)
self._connection = MockPsycopgConnection({"port": "8080", "host": "test", "dbname": "test"}, self._mock_cursor)
self._initialize_edit_request = InitializeEditParams()
self._initialize_edit_request.schema_name = 'public'
self._initialize_edit_request.object_name = 'Employee'
self._initialize_edit_request.object_type = 'Table'
db_column = DbColumn()
column = EditColumnMetadata(db_column, None)
self._columns_metadata = [column]
self._schema_name = 'public'
self._table_name = 'table'
self._edit_table_metadata = EditTableMetadata(self._schema_name, self._table_name, self._columns_metadata)
self._query_executer = mock.MagicMock()
self._on_success = mock.MagicMock()
self._on_failure = mock.MagicMock()
self._data_editor_session = DataEditorSession(self._metadata_factory)
self._metadata_factory.get = mock.Mock(return_value=self._edit_table_metadata)
self._query = 'SELECT TESTCOLUMN FROM TESTTABLE LIMIT 100'
self._data_editor_session._construct_initialize_query = mock.Mock(return_value=self._query)
def test_apply_changes(self):
self.assertTrue(len(self._result_set.rows) == 2)
cursor = MockCursor([('True', )], ['IsTrue'])
self._row_create.apply_changes(cursor)
self.assertTrue(len(self._result_set.rows) == 3)
self.assertTrue(self._result_set.rows[2][0] == 'True')
def get_result_set(self, rows: List[tuple]) -> ResultSet:
result_set = create_result_set(ResultSetStorageType.IN_MEMORY, 0, 0)
cursor = MockCursor(rows)
columns_info = []
get_column_info_mock = mock.Mock(return_value=columns_info)
with mock.patch('ossdbtoolsservice.query.in_memory_result_set.get_columns_info', new=get_column_info_mock):
result_set.read_result_to_end(cursor)
return result_set
def test_metadata_list_request(self):
"""Test that the metadata list handler properly starts a thread to list metadata and responds with the list"""
# Set up the parameters and mocks for the request
expected_metadata = [
ObjectMetadata(schema='schema1', name='table1', metadata_type=MetadataType.TABLE),
ObjectMetadata(schema='schema1', name='view1', metadata_type=MetadataType.VIEW),
ObjectMetadata(schema='schema1', name='function1', metadata_type=MetadataType.FUNCTION),
ObjectMetadata(schema='schema1', name='table2', metadata_type=MetadataType.TABLE),
ObjectMetadata(schema='schema2', name='view1', metadata_type=MetadataType.VIEW),
ObjectMetadata(schema='schema2', name='function1', metadata_type=MetadataType.FUNCTION),
]
metadata_type_to_str_map = {
MetadataType.TABLE: 't',
MetadataType.VIEW: 'v',
MetadataType.FUNCTION: 'f'
}
# Query results have schema_name, object_name, and object_type columns in that order
list_query_result = [(metadata.schema, metadata.name, metadata_type_to_str_map[metadata.metadata_type]) for metadata in expected_metadata]
mock_cursor = MockCursor(list_query_result)
mock_connection = MockPGServerConnection(cur=mock_cursor)
self.connection_service.get_connection = mock.Mock(return_value=mock_connection)
request_context = MockRequestContext()
params = MetadataListParameters()
params.owner_uri = self.test_uri
mock_thread = MockThread()
with mock.patch('threading.Thread', new=mock.Mock(side_effect=mock_thread.initialize_target)):
# If I call the metadata list request handler
self.metadata_service._handle_metadata_list_request(request_context, params)
# Then the worker thread was kicked off
self.assertEqual(mock_thread.target, self.metadata_service._metadata_list_worker)
mock_thread.start.assert_called_once()
# And the worker retrieved the correct connection and executed a query on it
self.connection_service.get_connection.assert_called_once_with(self.test_uri, ConnectionType.DEFAULT)
mock_cursor.execute.assert_called_once()
# And the handler responded with the expected results
self.assertIsNone(request_context.last_error_message)
self.assertIsNone(request_context.last_notification_method)
response = request_context.last_response_params
self.assertIsInstance(response, MetadataListResponse)
for index, actual_metadata in enumerate(response.metadata):
self.assertIsInstance(actual_metadata, ObjectMetadata)
self.assertEqual(actual_metadata.schema, expected_metadata[index].schema)
self.assertEqual(actual_metadata.name, expected_metadata[index].name)
self.assertEqual(actual_metadata.metadata_type, expected_metadata[index].metadata_type)
def setUp(self):
self._row_id = 1
self._rows = [("False"), ("True")]
self._result_set = create_result_set(ResultSetStorageType.IN_MEMORY, 0, 0)
self._cursor = MockCursor(self._rows, ['IsTrue'])
with mock.patch('pgsqltoolsservice.query.in_memory_result_set.get_columns_info', new=mock.Mock()):
self._result_set.read_result_to_end(self._cursor)
db_column = DbColumn()
db_column.data_type = 'bool'
db_column.column_name = 'IsValid'
db_column.is_updatable = True
self._result_set.columns_info = [db_column]
self._table_metadata = EditTableMetadata('public', 'TestTable', [])
self._row_create = RowCreate(self._row_id, self._result_set, self._table_metadata)
def setUp(self):
self._row_id = 1
self._rows = [("Result1",), ("Result2",)]
db_column = DbColumn()
db_column.data_type = 'varchar'
db_column.column_name = 'TextType'
self._result_set = create_result_set(ResultSetStorageType.IN_MEMORY, 0, 0)
cursor = MockCursor(self._rows, ['IsTrue'])
with mock.patch('pgsqltoolsservice.query.in_memory_result_set.get_columns_info', new=mock.Mock()):
self._result_set.read_result_to_end(cursor)
self._result_set.columns_info = [db_column]
self._table_metadata = None
self._column_index = 0
self._new_value = 'Updated'
self._row_update = RowUpdate(self._row_id, self._result_set, self._table_metadata)
