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 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 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):
# 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 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()
def setUp(self):
self._time = grpc_testing.strict_real_time()
