def test_get_offers_does_remote_request_if_hybrid_request_and_decisioning_engine_not_ready(
self):
get_offers_opts = {
"request": TARGET_REQUEST_DICT,
"session_id": "dummy_session",
"decisioning_method": DecisioningMethod.HYBRID.value
}
get_offers_opts["request"]["prefetch"] = {
"mboxes": [{
"name": "mbox-feature-flags",
"index": 1
}]
}
get_offers_opts["request"] = create_delivery_request(
get_offers_opts["request"])
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.SERVER_SIDE.value
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(DELIVERY_RESPONSE)) \
as mock_delivery_api:
client = TargetClient.create(client_opts)
result = client.get_offers(get_offers_opts)
self.assertEqual(mock_delivery_api.call_count, 1)
self.assertEqual(result["response"].status, OK)
self.assertIsNotNone(result["response"].prefetch)
self.assertEqual(result["meta"]["decisioning_method"],
DecisioningMethod.SERVER_SIDE.value)
self.assertEqual(result["meta"]["remote_mboxes"], [])
self.assertEqual(result["meta"]["remote_views"], [])
def test_get_offers_server_side(self):
expected_result = deepcopy(EXPECTED_PREFETCH_RESULT)
expected_result["response"]["edgeHost"] = "mboxedge28.tt.omtrdc.net"
expected_result["target_location_hint_cookie"] = {
"name": "mboxEdgeCluster",
"value": "28",
"maxAge": 1860
}
expected_result["meta"] = {
"decisioning_method": DecisioningMethod.SERVER_SIDE.value
}
get_offers_opts = {
"request": PREFETCH_REQUEST,
"session_id": "dummy_session"
}
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.SERVER_SIDE.value
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(DELIVERY_API_RESPONSE)):
client = TargetClient.create(client_opts)
result = client.get_offers(get_offers_opts)
result_dict = to_dict(result)
expect_to_match_object(result_dict, expected_result)
def test_get_offers_on_device_decisioning_emits_notifications(self):
get_offers_opts = {
"request": EXECUTE_REQUEST,
"session_id": "dummy_session"
}
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value
client_opts["target_location_hint"] = "28"
# send_notifications call
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response({})) \
as mock_delivery_api:
with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider:
artifact_instance = mock_artifact_provider.return_value
artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE))
artifact_instance.request.return_value = artifact_response
client = TargetClient.create(client_opts)
self.assertEqual(mock_artifact_provider.call_count, 1)
result = client.get_offers(get_offers_opts)
self.assertIsNotNone(result.get("response"))
self.assertEqual(result.get("response").status, OK)
self.assertIsNotNone(result.get("response").execute)
time.sleep(1) # notifications sent async
self.assertEqual(mock_delivery_api.call_count, 1)
notification_request = to_dict(mock_delivery_api.call_args[0][2])
expect_to_match_object(notification_request, EXPECTED_NOTIFICATION_REQUEST)
def test_get_offers_hybrid_does_remote_request_if_necessary(self):
get_offers_opts = {
"request": TARGET_REQUEST_DICT,
"session_id": "dummy_session"
}
get_offers_opts["request"]["prefetch"] = {
"mboxes": [{
"name": "mbox-feature-flags",
"index": 1
}, {
"name": "remote-only-mbox-a",
"index": 2
}, {
"name": "remote-only-mbox-b",
"index": 2
}]
}
get_offers_opts["request"] = create_delivery_request(
get_offers_opts["request"])
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.HYBRID.value
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(DELIVERY_RESPONSE)) \
as mock_delivery_api:
with patch(
"target_decisioning_engine.artifact_provider.urllib3.PoolManager"
) as mock_artifact_provider:
artifact_instance = mock_artifact_provider.return_value
artifact_response = HTTPResponse(
status=OK, body=json.dumps(FEATURE_FLAG_ARTIFACT))
artifact_instance.request.return_value = artifact_response
client = TargetClient.create(client_opts)
self.assertEqual(mock_artifact_provider.call_count, 1)
result = client.get_offers(get_offers_opts)
self.assertEqual(mock_delivery_api.call_count, 1)
self.assertEqual(result["response"].status, OK)
self.assertIsNotNone(result["response"].prefetch)
self.assertEqual(result["meta"]["decisioning_method"],
DecisioningMethod.HYBRID.value)
self.assertSetEqual(
set(result["meta"]["remote_mboxes"]),
set(["remote-only-mbox-a", "remote-only-mbox-b"]))
self.assertEqual(result["meta"]["remote_views"], [])
def test_create_decisioning_method_on_device(self):
client_ready_mock = Mock()
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value
client_opts["events"] = {
"client_ready": client_ready_mock
}
with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_pool_manager:
instance = mock_pool_manager.return_value
mock_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_BLANK))
instance.request.return_value = mock_response
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)):
client = TargetClient.create(client_opts)
self.assertIsNotNone(client.decisioning_engine)
self.assertTrue(callable(client.decisioning_engine.get_offers))
self.assertEqual(client_ready_mock.call_count, 1)
def test_get_offers_valid_on_device_decisioning_response(self):
get_offers_opts = {
"request": PREFETCH_REQUEST,
"session_id": "dummy_session"
}
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value
client_opts["target_location_hint"] = "28"
with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider:
artifact_instance = mock_artifact_provider.return_value
artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE))
artifact_instance.request.return_value = artifact_response
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)):
client = TargetClient.create(client_opts)
result = client.get_offers(get_offers_opts)
result_dict = to_dict(result)
expect_to_match_object(result_dict, EXPECTED_PREFETCH_RESULT)
def test_client_preemptively_fetches_target_location_hint(self):
get_offers_opts = {
"request": TARGET_REQUEST,
"session_id": "dummy_session"
}
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value
with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_artifact_provider:
artifact_instance = mock_artifact_provider.return_value
artifact_response = HTTPResponse(status=OK, body=json.dumps(ARTIFACT_AB_SIMPLE))
artifact_instance.request.return_value = artifact_response
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)):
client = TargetClient.create(client_opts)
result = client.get_offers(get_offers_opts) # on-device
self.assertEqual(result.get("target_location_hint_cookie"), {
"name": "mboxEdgeCluster",
"value": "28",
"maxAge": 1860
})
def test_get_offers_artifact_retrieval_failed(self):
client_ready_mock = Mock()
artifact_failed_mock = Mock()
artifact_success_mock = Mock()
client_opts = dict(CONFIG)
client_opts["decisioning_method"] = DecisioningMethod.ON_DEVICE.value
client_opts["events"] = {
"client_ready": client_ready_mock,
"artifact_download_failed": artifact_failed_mock,
"artifact_download_succeeded": artifact_success_mock
}
with patch("target_decisioning_engine.artifact_provider.urllib3.PoolManager") as mock_pool_manager:
instance = mock_pool_manager.return_value
mock_response = HTTPResponse(status=403)
instance.request.return_value = mock_response
with patch.object(DeliveryApi, "execute", return_value=create_delivery_response(LOCATION_HINT_RESPONSE)):
client = TargetClient.create(client_opts)
self.assertEqual(client_ready_mock.call_count, 0)
self.assertEqual(artifact_success_mock.call_count, 0)
self.assertEqual(artifact_failed_mock.call_count, 1)
self.assertEqual(artifact_failed_mock.call_args[0][0].get("type"), "artifact_download_failed")
self.assertIsNotNone(artifact_failed_mock.call_args[0][0].get("artifact_location"))
self.assertIsNotNone(artifact_failed_mock.call_args[0][0].get("error"))
get_offers_opts = {
"request": TARGET_REQUEST,
"session_id": "dummy_session"
}
with self.assertRaises(Exception) as err:
client.get_offers(get_offers_opts)
self.assertEqual(str(err.exception), DECISIONING_ENGINE_NOT_READY)