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)