def test_create_model_instance(self):
ps = PolicyService(self.saved_model)
model_instance = ps.create_model_instance(self.page)
assert isinstance(model_instance, ModelInstance)
assert isinstance(model_instance.agent, MockAgent)
assert model_instance.config.client_env.bandwidth == self.client_environment.bandwidth
assert model_instance.config.client_env.latency == self.client_environment.latency
assert model_instance.config.env_config.push_groups == self.push_groups
def test_create_push_policy(self):
ps = PolicyService(self.saved_model)
policy = ps.create_policy(self.page)
assert policy
assert isinstance(policy, policy_service_pb2.Policy)
push_pairs = convert_push_groups_to_push_pairs(self.push_groups)
push_pairs = [(s.url, p.url) for (s, p) in push_pairs]
p = Policy.from_dict(json.loads(policy.policy))
for (source, push_res) in p.push:
for push in push_res:
assert (source.url, push.url) in push_pairs
def test_client(self, capsys):
server = Server(self.serve_config)
server.set_policy_service(PolicyService(self.saved_model))
try:
server.start()
with tempfile.NamedTemporaryFile() as manifest_file:
config = get_env_config()
config.save_file(manifest_file.name)
query([
"--manifest",
manifest_file.name,
"-l",
"10",
"-b",
"24000",
"--host",
str(self.serve_config.host),
"--port",
str(self.serve_config.port),
])
policy = json.loads(capsys.readouterr().out)
assert policy
assert len(policy) > 0
finally:
server.stop()
def test_start_server(self, mock_grpc_server):
server = Server(self.serve_config)
server.set_policy_service(PolicyService(self.saved_model))
server.start()
server.grpc_server.start.assert_called_once()
server.grpc_server.add_insecure_port.assert_called_once()
assert ":{}".format(
self.serve_config.port
) in server.grpc_server.add_insecure_port.call_args_list[0][0][0]
assert server.server_started
def test_get_policy(self):
server = Server(self.serve_config)
policy_service = PolicyService(self.saved_model)
server.set_policy_service(policy_service)
try:
server.start()
time.sleep(0.5)
# create the client
address = "{}:{}".format(self.serve_config.host,
self.serve_config.port)
channel = grpc.insecure_channel(address)
client_stub = Client(channel)
policy = client_stub.get_policy(
url="https://www.example.com",
client_env=client.get_random_client_environment(),
manifest=self.env_config,
)
assert policy is not None
assert len(list(policy.push)) + len(list(policy.preload)) > 0
finally:
server.stop()
def test_server_serves_policy(self):
# configure the server
server = Server(self.serve_config)
policy_service = PolicyService(self.saved_model)
server.set_policy_service(policy_service)
try:
# start the server
server.start()
# create the client
address = "{}:{}".format(self.serve_config.host,
self.serve_config.port)
channel = grpc.insecure_channel(address)
stub = policy_service_pb2_grpc.PolicyServiceStub(channel)
# query for the policy for some page
page = get_page("https://example.com")
policy = stub.GetPolicy(page)
# check whether we got a reasonable return value
# we'll check for correctness in the policy_service unit tests
assert policy
assert isinstance(policy, policy_service_pb2.Policy)
finally:
server.stop()
def test_set_policy_service(self, mock_grpc_server):
server = Server(self.serve_config)
server.set_policy_service(PolicyService(self.saved_model))
server.grpc_server.add_generic_rpc_handlers.assert_called_once()
def test_get_policy_returns_cached(self):
ps = PolicyService(self.saved_model)
first_policy = ps.GetPolicy(self.page, MockGRPCServicerContext())
second_policy = ps.GetPolicy(self.page, MockGRPCServicerContext())
def test_get_policy(self):
ps = PolicyService(self.saved_model)
policy = ps.GetPolicy(self.page, MockGRPCServicerContext())
assert policy
assert isinstance(policy, policy_service_pb2.Policy)
def test_init(self):
ps = PolicyService(self.saved_model)
assert ps
assert isinstance(ps, PolicyService)
assert ps.saved_model is self.saved_model
assert not ps.policies