def setUp(self): servicers = { api_pb2.DESCRIPTOR.services_by_name['Suggestion']: EnasService( ) } self.test_server = grpc_testing.server_from_dictionary( servicers, grpc_testing.strict_real_time())
def setUp(self): servicers = { api_pb2.DESCRIPTOR.services_by_name['EarlyStopping']: MedianStopService() } self.test_server = grpc_testing.server_from_dictionary( servicers, grpc_testing.strict_real_time())
def _create_mock_client(): # Create a stub instance (using a test channel) in order to derive a mock # from it with autospec enabled. Mocking TensorBoardWriterServiceStub itself # doesn't work with autospec because grpc constructs stubs via metaclassing. test_channel = grpc_testing.channel(service_descriptors=[], time=grpc_testing.strict_real_time()) stub = data_provider_pb2_grpc.TensorBoardDataProviderStub(test_channel) return mock.create_autospec(stub)
def greeter_server(self, greeter_service): descriptors_to_servicers = { greeter_service: helloworld.GreeterServicer() } return grpc_testing.server_from_dictionary( descriptors_to_servicers, grpc_testing.strict_real_time() )
def get_grpc_service_for_predict(get_fake_model): _real_time = grpc_testing.strict_real_time() servicer = PredictionServiceServicer(models={'test': get_fake_model}) descriptors_to_servicers = {PREDICT_SERVICE: servicer} _real_time_server = grpc_testing.server_from_dictionary( descriptors_to_servicers, _real_time) return _real_time_server
def get_grpc_service_for_model_status(get_fake_model): _real_time = grpc_testing.strict_real_time() servicer = ModelServiceServicer(models={'test': get_fake_model}) descriptors_to_servicers = {MODEL_SERVICE: servicer} _real_time_server = grpc_testing.server_from_dictionary( descriptors_to_servicers, _real_time) return _real_time_server
def setup_test_server(): servicers = { groundstation_pb2.DESCRIPTOR.services_by_name['GroundStationService']: GroundStationServiceServicer() } return grpc_testing.server_from_dictionary(servicers, grpc_testing.strict_real_time())
def setUp(self): self._client_execution_thread_pool = logging_pool.pool(1) self._fake_time = grpc_testing.strict_fake_time(time.time()) self._real_time = grpc_testing.strict_real_time() self._fake_time_channel = grpc_testing.channel( rekcurd_pb2.DESCRIPTOR.services_by_name.values(), self._fake_time) self._real_time_channel = grpc_testing.channel( rekcurd_pb2.DESCRIPTOR.services_by_name.values(), self._real_time)
def setUp(self): service_descriptors = [ groundstation_pb2.DESCRIPTOR. services_by_name['GroundStationService'] ] self.test_channel = grpc_testing.channel( service_descriptors, grpc_testing.strict_real_time()) self.tb = gr.top_block()
def setup(self) -> None: self._real_time = grpc_testing.strict_real_time() self._real_time_channel = grpc_testing.channel( milvus_pb2.DESCRIPTOR.services_by_name.values(), self._real_time) self._servicer = milvus_pb2.DESCRIPTOR.services_by_name[ 'MilvusService'] self._milvus = Milvus(channel=self._real_time_channel, try_connect=False, pre_ping=False)
def setUp(self): self._real_time = grpc_testing.strict_real_time() self._fake_time = grpc_testing.strict_fake_time(time.time()) service = CalculatorService() descriptors_to_services = {target_service: service} self._real_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._real_time) self._fake_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._fake_time)
def fixture_processor_servicer(): processor_service = _ProcessorServicer(config={}, pr=ExampleTestProcessor(), address='', health_servicer=None) yield grpc_testing.server_from_dictionary( { processing_pb2.DESCRIPTOR.services_by_name['Processor']: processor_service }, grpc_testing.strict_real_time())
def mock_server(): """Constructor to initialise the test grpc servicer""" servicers = { alarm_pb2.DESCRIPTOR.services_by_name['AlarmStore']: AlarmStoreServicer(TEST_DATABASE, False) } return grpc_testing.server_from_dictionary(servicers, grpc_testing.strict_real_time())
def _create_mock_api_client(): # Create a stub instance (using a test channel) in order to derive a mock # from it with autospec enabled. Mocking TensorBoardExporterServiceStub # itself doesn't work with autospec because grpc constructs stubs via # metaclassing. test_channel = grpc_testing.channel(service_descriptors=[], time=grpc_testing.strict_real_time()) stub = export_service_pb2_grpc.TensorBoardExporterServiceStub(test_channel) mock_api_client = mock.create_autospec(stub) return mock_api_client
def setUp(self): self._real_time = grpc_testing.strict_real_time() self._fake_time = grpc_testing.strict_fake_time(time.time()) self.mock_cowsay_client = Mock() # noinspection PyTypeChecker service = QuoteService(self.mock_cowsay_client, 'key') descriptors_to_services = {target_service: service} self._real_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._real_time) self._fake_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._fake_time)
def setUp(self): self._real_time = grpc_testing.strict_real_time() self._fake_time = grpc_testing.strict_fake_time(time.time()) servicer = _server_application.FirstServiceServicer() descriptors_to_servicers = { _application_testing_common.FIRST_SERVICE: servicer } self._real_time_server = grpc_testing.server_from_dictionary( descriptors_to_servicers, self._real_time) self._fake_time_server = grpc_testing.server_from_dictionary( descriptors_to_servicers, self._fake_time)
def setUp(self): self._real_time = grpc_testing.strict_real_time() self._fake_time = grpc_testing.strict_fake_time(time.time()) service = main.ArbitrageServiceServicer() descriptors_to_servicers = {ARBITRAGE_SERVICE: service} self._real_time_server = grpc_testing.server_from_dictionary( descriptors_to_servicers, self._real_time) self._fake_time_server = grpc_testing.server_from_dictionary( descriptors_to_servicers, self._fake_time)
def get_test_server(self): if not self._test_server: servicers = {} for svc in self.app.services: if isinstance(svc, Service): servicers[svc.descriptor] = svc.make_servicer_class() self._test_server = grpc_testing.server_from_dictionary( servicers, grpc_testing.strict_real_time() ) return self._test_server
def setUp(self): # In this test the client-side application under test executes in # a separate thread while we retain use of the test thread to "play # server". self._client_execution_thread_pool = logging_pool.pool(1) self._fake_time = grpc_testing.strict_fake_time(time.time()) self._real_time = grpc_testing.strict_real_time() self._fake_time_channel = grpc_testing.channel( services_pb2.DESCRIPTOR.services_by_name.values(), self._fake_time) self._real_time_channel = grpc_testing.channel( services_pb2.DESCRIPTOR.services_by_name.values(), self._real_time)
def _create_mock_client(): # Create a stub instance (using a test channel) in order to derive a mock # from it with autospec enabled. Mocking TensorBoardWriterServiceStub itself # doesn't work with autospec because grpc constructs stubs via metaclassing. test_channel = grpc_testing.channel(service_descriptors=[], time=grpc_testing.strict_real_time()) stub = write_service_pb2_grpc.TensorBoardWriterServiceStub(test_channel) mock_client = mock.create_autospec(stub) fake_exp_response = write_service_pb2.CreateExperimentResponse( experiment_id="123", url="should not be used!") mock_client.CreateExperiment.return_value = fake_exp_response return mock_client
def setUp(self): self._on_receiving_result = MagicMock() self._servicer = DeviceReportServicer(self._on_receiving_result) servicers = { DESCRIPTOR.services_by_name['DeviceReport']: self._servicer } self._test_server = server_from_dictionary(servicers, strict_real_time()) port_learns = [('name', '1', '00:0X:00:00:00:01', 101), ('name', '2', '00:0Y:00:00:00:02', 102), ('name', '3', '00:0Z:00:00:00:03', 103)] for port_learn in port_learns: self._servicer.process_port_learn(*port_learn)
def setUp(self): app.load_config_file("./test/test-settings.yml") app.data_server = DataServer(app.config) app.system_logger = JsonSystemLogger(config=app.config) app.service_logger = JsonServiceLogger(config=app.config) self._real_time = grpc_testing.strict_real_time() self._fake_time = grpc_testing.strict_fake_time(time.time()) servicer = RekcurdWorkerServicer(RekcurdPack(app, None)) descriptors_to_services = {target_service: servicer} self._real_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._real_time) self._fake_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._fake_time)
def setUp(self): self._client_execution_thread_pool = logging_pool.pool(1) # Builds a testing channel self._fake_channel = grpc_testing.channel( DESCRIPTOR.services_by_name.values(), grpc_testing.strict_real_time()) self._build_channel_patcher = patch( 'fedlearner_webconsole.rpc.client._build_channel') self._mock_build_channel = self._build_channel_patcher.start() self._mock_build_channel.return_value = self._fake_channel self._client = RpcClient(self._project_config, self._participant) self._mock_build_channel.assert_called_once_with( self._TEST_URL, self._TEST_AUTHORITY)
def setUp(self): # Mock load Kubernetes config. patcher = patch( 'pkg.earlystopping.v1beta1.medianstop.service.config.load_kube_config' ) self.mock_sum = patcher.start() self.addCleanup(patcher.stop) servicers = { api_pb2.DESCRIPTOR.services_by_name['EarlyStopping']: MedianStopService() } self.test_server = grpc_testing.server_from_dictionary( servicers, grpc_testing.strict_real_time())
def setUp(self): servicers = { DESCRIPTOR.services_by_name['StatisticsProcesser']: Calculator() } self.test_server = grpc_testing.server_from_dictionary( servicers, grpc_testing.strict_real_time()) self.default_config = toml.load('server/server.toml')['statistics'] with open('server/test/test.csv', 'r') as file: self.document = file.read().encode() with open('server/test/result.csv', 'r') as file: self.result = self.default_config['summary_header'] + file.read() self.result = self.result.encode() with open('server/test/result_full.csv', 'r') as file: self.result_full = self.default_config[ 'summary_header'] + file.read() self.result_full = self.result_full.encode()
def setUp(self): def gen_eval(): for d in eval_result_details: yield d return eval_result app.load_config_file("./test/test-settings.yml") app.data_server = DataServer(app.config) app.system_logger = JsonSystemLogger(config=app.config) app.service_logger = JsonServiceLogger(config=app.config) app.evaluate = Mock(return_value=gen_eval()) self._real_time = grpc_testing.strict_real_time() self._fake_time = grpc_testing.strict_fake_time(time.time()) servicer = RekcurdDashboardServicer(RekcurdPack(app, None)) descriptors_to_services = {target_service: servicer} self._real_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._real_time) self._fake_time_server = grpc_testing.server_from_dictionary( descriptors_to_services, self._fake_time)
def test_create_with_mock_server(self): thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1) fake_channel = grpc_testing.channel( key_value_pb2.DESCRIPTOR.services_by_name.values(), grpc_testing.strict_real_time()) # Offload the request to another thread so we can use this thread to # fake the server-side results. result_future = thread_pool.submit( grpc_kv_client.create, "localhost:1234", "golden-retriever", "pancakes", channel=fake_channel) # Fake the server-side results. invocation_metadata, request, rpc = (fake_channel.take_unary_unary( _get_method("CreateRecord"))) rpc.send_initial_metadata(()) rpc.terminate( key_value_pb2.Record(name="golden-retriever", value="pancakes"), (), grpc.StatusCode.OK, "") # Ensure the client had the correct response. result = result_future.result() self.assertIsNone(result)
def setUp(self): super(WstlTest, self).setUp() self.config = tools.default_config() self.config.TerminalInteractiveShell.simple_prompt = True self.shell = interactiveshell.TerminalInteractiveShell.instance( config=self.config) self._time = grpc_testing.strict_real_time() self._channel = grpc_testing.channel( wstlservice_pb2.DESCRIPTOR.services_by_name.values(), self._time) self.sample_hl7v2 = json.dumps(""" {'ADT_A01': {'ACC': None, 'AL1': [{'0': 'AL1', '1': '0', '2': {'1': 'AA'}, '3': {'1': 'Z88.0', '2': 'Personal history of allergy to penicillin', '3': 'ZAL'}, '4': {'1': 'SEVERE'}, '5': ['Shortness of breath'], '6': None}], 'ARV_1': None, 'ARV_2': None, 'DB1': None, 'DRG': None}}""")
def fixture_events_server(): events_service = EventsServicer() yield grpc_testing.server_from_dictionary( {events_pb2.DESCRIPTOR.services_by_name['Events']: events_service}, grpc_testing.strict_real_time())
def setUp(self): self._time = grpc_testing.strict_real_time()