def test_register(self):
"""Test registration of the service"""
# Setup:
# ... Create a mock service provider
server: JSONRPCServer = JSONRPCServer(None, None)
server.set_notification_handler = mock.MagicMock()
server.set_request_handler = mock.MagicMock()
provider: ServiceProvider = ServiceProvider(
server, {constants.CONNECTION_SERVICE_NAME: ConnectionService},
PG_PROVIDER_NAME, utils.get_mock_logger())
provider._is_initialized = True
conn_service: ConnectionService = provider[
constants.CONNECTION_SERVICE_NAME]
self.assertEqual(0, len(conn_service._on_connect_callbacks))
# If: I register a language service
service: LanguageService = LanguageService()
service.register(provider)
# Then:
# ... The notifications should have been registered
server.set_notification_handler.assert_called()
server.set_request_handler.assert_called()
self.assertEqual(1, len(conn_service._on_connect_callbacks))
self.assertEqual(1, server.count_shutdown_handlers())
# ... The service provider should have been stored
self.assertIs(service._service_provider, provider) # noqa
def setUp(self):
"""Constructor"""
self.default_connection_key = 'server_db_user'
self.mock_connection_service = ConnectionService()
self.mock_server = JSONRPCServer(None, None)
self.mock_service_provider = ServiceProvider(self.mock_server, {},
PG_PROVIDER_NAME, None)
self.mock_service_provider._services[
constants.CONNECTION_SERVICE_NAME] = self.mock_connection_service
self.mock_service_provider._is_initialized = True
# Create connection information for use in the tests
self.connection_details = ConnectionDetails.from_data({})
self.connection_details.server_name = 'test_host'
self.connection_details.database_name = 'test_db'
self.connection_details.user_name = 'user'
self.expected_context_key = 'test_host|test_db|user'
self.expected_connection_uri = INTELLISENSE_URI + self.expected_context_key
self.test_uri = 'test_uri'
self.connection_info = ConnectionInfo(self.test_uri,
self.connection_details)
# Create mock CompletionRefresher to avoid calls to create separate thread
self.refresher_mock = mock.MagicMock()
self.refresh_method_mock = mock.MagicMock()
self.refresher_mock.refresh = self.refresh_method_mock
def setUp(self):
"""Constructor"""
self.default_uri = 'file://my.sql'
self.flow_validator = RequestFlowValidator()
self.mock_server_set_request = mock.MagicMock()
self.mock_server = JSONRPCServer(None, None)
self.mock_server.set_request_handler = self.mock_server_set_request
self.mock_workspace_service = WorkspaceService()
self.mock_connection_service = ConnectionService()
self.mock_service_provider = ServiceProvider(self.mock_server, {},
PG_PROVIDER_NAME, None)
self.mock_service_provider._services[
constants.WORKSPACE_SERVICE_NAME] = self.mock_workspace_service
self.mock_service_provider._services[
constants.CONNECTION_SERVICE_NAME] = self.mock_connection_service
self.mock_service_provider._is_initialized = True
self.default_text_position = TextDocumentPosition.from_dict({
'text_document': {
'uri': self.default_uri
},
'position': {
'line': 3,
'character': 10
}
})
self.default_text_document_id = TextDocumentIdentifier.from_dict(
{'uri': self.default_uri})
def test_initialization(self):
# Setup: Create a capabilities service with a mocked out service provider
mock_server_set_request = mock.MagicMock()
mock_server = JSONRPCServer(None, None)
mock_server.set_request_handler = mock_server_set_request
mock_service_provider = ServiceProvider(mock_server, {},
PG_PROVIDER_NAME, None)
service = CapabilitiesService()
# If: I initialize the service
service.register(mock_service_provider)
# Then:
# ... There should have been request handlers set
mock_server_set_request.assert_called()
# ... Each mock call should have an IncomingMessageConfig and a function pointer
for mock_call in mock_server_set_request.mock_calls:
self.assertIsInstance(mock_call[1][0],
IncomingMessageConfiguration)
self.assertTrue(callable(mock_call[1][1]))
def test_registration(self):
# Setup:
# ... Create a mock service provider
server: JSONRPCServer = JSONRPCServer(None, None)
server.set_notification_handler = mock.MagicMock()
server.set_request_handler = mock.MagicMock()
sp: ServiceProvider = ServiceProvider(server, {}, PG_PROVIDER_NAME,
utils.get_mock_logger())
# If: I register a scripting service
ss: ScriptingService = ScriptingService()
ss.register(sp)
# Then:
# ... The service should have registered its request handlers
server.set_request_handler.assert_called()
server.set_notification_handler.assert_not_called()
# ... The service provider should have been stored
self.assertIs(ss._service_provider, sp)
def test_register(self):
# Setup:
# ... Create a mock service provider
server: JSONRPCServer = JSONRPCServer(None, None)
server.set_notification_handler = MagicMock()
server.set_request_handler = MagicMock()
sp: ServiceProvider = ServiceProvider(server, {}, PG_PROVIDER_NAME,
utils.get_mock_logger())
# If: I register a workspace service
ws: WorkspaceService = WorkspaceService()
ws.register(sp)
# Then:
# ... The notifications should have been registered
server.set_notification_handler.assert_called()
server.set_request_handler.assert_not_called()
# ... The service provider should have been stored
self.assertIs(ws._service_provider, sp)
def test_register(self):
# Setup:
# ... Create a mock service provider
server: JSONRPCServer = JSONRPCServer(None, None)
server.set_notification_handler = mock.MagicMock()
server.set_request_handler = mock.MagicMock()
sp: ServiceProvider = ServiceProvider(server, {},
constants.PG_PROVIDER_NAME,
utils.get_mock_logger())
# If: I register a OE service
oe = ObjectExplorerService()
oe.register(sp)
# Then:
# ... The service should have registered its request handlers
server.set_request_handler.assert_called()
server.set_notification_handler.assert_not_called()
# ... The service provider should have been stored
self.assertIs(oe._service_provider, sp)
def _create_server(input_stream, output_stream, server_logger, provider):
# Create the server, but don't start it yet
rpc_server = JSONRPCServer(input_stream, output_stream, server_logger)
# Create the service provider and add the providers to it
services = {
constants.ADMIN_SERVICE_NAME: AdminService,
constants.CAPABILITIES_SERVICE_NAME: CapabilitiesService,
constants.CONNECTION_SERVICE_NAME: ConnectionService,
constants.DISASTER_RECOVERY_SERVICE_NAME: DisasterRecoveryService,
constants.LANGUAGE_SERVICE_NAME: LanguageService,
constants.METADATA_SERVICE_NAME: MetadataService,
constants.OBJECT_EXPLORER_NAME: ObjectExplorerService,
constants.QUERY_EXECUTION_SERVICE_NAME: QueryExecutionService,
constants.SCRIPTING_SERVICE_NAME: ScriptingService,
constants.WORKSPACE_SERVICE_NAME: WorkspaceService,
constants.EDIT_DATA_SERVICE_NAME: EditDataService,
constants.TASK_SERVICE_NAME: TaskService
}
service_box = ServiceProvider(rpc_server, services, provider,
server_logger)
service_box.initialize()
return rpc_server