def test_track_screen_view(self, mok_track_unstruct):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track_unstruct.side_effect = mocked_track_unstruct
t = Tracker(e)
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evTstamp = 1399021242030
t.track_screen_view("screenName",
"screenId",
context=[ctx],
tstamp=evTstamp)
expected = {
"schema": SCREEN_VIEW_SCHEMA,
"data": {
"name": "screenName",
"id": "screenId"
}
}
callArgs = mok_track_unstruct.call_args_list[0][0]
self.assertEqual(len(callArgs), 4)
self.assertDictEqual(callArgs[0].to_json(), expected)
self.assertIs(callArgs[1][0], ctx)
self.assertEqual(callArgs[2], evTstamp)
def test_complete_payload_co(self, mok_uuid, mok_track):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_uuid.side_effect = mocked_uuid
mok_track.side_effect = mocked_track
t = Tracker(e, encode_base64=False)
p = Payload()
geo_ctx = SelfDescribingJson(geoSchema, geoData)
mov_ctx = SelfDescribingJson(movSchema, movData)
ctx_array = [geo_ctx, mov_ctx]
t.complete_payload(p, ctx_array, None, None)
self.assertEqual(mok_track.call_count, 1)
trackArgsTuple = mok_track.call_args_list[0][0]
self.assertEqual(len(trackArgsTuple), 1)
passed_nv_pairs = trackArgsTuple[0].nv_pairs
expected_co = {
"schema":
CONTEXT_SCHEMA,
"data": [{
"schema": geoSchema,
"data": geoData
}, {
"schema": movSchema,
"data": movData
}]
}
self.assertIn("co", passed_nv_pairs)
self.assertDictEqual(json.loads(passed_nv_pairs["co"]),
expected_co)
def test_complete_payload_tstamp_ttm(self, mok_uuid, mok_track):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_uuid.side_effect = mocked_uuid
mok_track.side_effect = mocked_track
t = Tracker(e)
p = Payload()
time_in_millis = 100010001000
t.complete_payload(p, None, time_in_millis, None)
self.assertEqual(mok_track.call_count, 1)
trackArgsTuple = mok_track.call_args_list[0][0]
self.assertEqual(len(trackArgsTuple), 1)
passed_nv_pairs = trackArgsTuple[0].nv_pairs
expected = {
"eid": _TEST_UUID,
"dtm": 1618790401000,
"ttm": time_in_millis,
"tv": TRACKER_VERSION,
"p": "pc"
}
self.assertDictEqual(passed_nv_pairs, expected)
def test_track_page_view(self, mok_complete_payload):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_complete_payload.side_effect = mocked_complete_payload
t = Tracker(e)
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evTstamp = 1399021242030
t.track_page_view("example.com",
"Example",
"docs.snowplowanalytics.com",
context=[ctx],
tstamp=evTstamp)
self.assertEqual(mok_complete_payload.call_count, 1)
completeArgsList = mok_complete_payload.call_args_list[0][0]
self.assertEqual(len(completeArgsList), 4)
actualPayloadArg = completeArgsList[0]
actualContextArg = completeArgsList[1]
actualTstampArg = completeArgsList[2]
actualPairs = actualPayloadArg.nv_pairs
expectedPairs = {
"e": "pv",
"url": "example.com",
"page": "Example",
"refr": "docs.snowplowanalytics.com"
}
self.assertDictEqual(actualPairs, expectedPairs)
self.assertIs(actualContextArg[0], ctx)
self.assertEqual(actualTstampArg, evTstamp)
def test_complete_payload_event_subject(self, mok_uuid, mok_track):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_uuid.side_effect = mocked_uuid
mok_track.side_effect = mocked_track
t = Tracker(e)
p = Payload()
evSubject = Subject().set_lang('EN').set_user_id("tester")
t.complete_payload(p, None, None, evSubject)
self.assertEqual(mok_track.call_count, 1)
trackArgsTuple = mok_track.call_args_list[0][0]
self.assertEqual(len(trackArgsTuple), 1)
passed_nv_pairs = trackArgsTuple[0].nv_pairs
expected = {
"eid": _TEST_UUID,
"dtm": 1618790401000,
"tv": TRACKER_VERSION,
"p": "pc",
"lang": "EN",
"uid": "tester"
}
self.assertDictEqual(passed_nv_pairs, expected)
def test_track_link_click(self, mok_track_unstruct):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track_unstruct.side_effect = mocked_track_unstruct
t = Tracker(e)
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evTstamp = 1399021242030
t.track_link_click("example.com",
"elemId", ["elemClass1", "elemClass2"],
"_blank",
"elemContent",
context=[ctx],
tstamp=evTstamp)
expected = {
"schema": LINK_CLICK_SCHEMA,
"data": {
"targetUrl": "example.com",
"elementId": "elemId",
"elementClasses": ["elemClass1", "elemClass2"],
"elementTarget": "_blank",
"elementContent": "elemContent"
}
}
callArgs = mok_track_unstruct.call_args_list[0][0]
self.assertEqual(len(callArgs), 4)
self.assertDictEqual(callArgs[0].to_json(), expected)
self.assertIs(callArgs[1][0], ctx)
self.assertEqual(callArgs[2], evTstamp)
def test_track_site_search(self, mok_track_unstruct):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track_unstruct.side_effect = mocked_track_unstruct
t = Tracker(e)
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evTstamp = 1399021242030
t.track_site_search(["track", "search"], {"new": True},
100,
10,
context=[ctx],
tstamp=evTstamp)
expected = {
"schema": SITE_SEARCH_SCHEMA,
"data": {
"terms": ["track", "search"],
"filters": {
"new": True
},
"totalResults": 100,
"pageResults": 10
}
}
callArgs = mok_track_unstruct.call_args_list[0][0]
self.assertEqual(len(callArgs), 4)
self.assertDictEqual(callArgs[0].to_json(), expected)
self.assertIs(callArgs[1][0], ctx)
self.assertEqual(callArgs[2], evTstamp)
def test_alias_contract(self):
e1 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="get")
t = Tracker(e1, namespace="cloudfront", encode_base64=False, app_id="AF003")
try:
t.track_self_describing_event("not-SelfDescribingJson")
except Exception as e:
self.assertIsInstance(e, ContractNotRespected)
def test_track_form_change_optional_none(self, mok_track_unstruct):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track_unstruct.side_effect = mocked_track_unstruct
t = Tracker(e)
t.track_form_change("testFormId", "testElemId", "INPUT",
"testValue")
expected = {
"schema": FORM_CHANGE_SCHEMA,
"data": {
"formId": "testFormId",
"elementId": "testElemId",
"nodeName": "INPUT",
"value": "testValue",
}
}
callArgs = mok_track_unstruct.call_args_list[0][0]
self.assertEqual(len(callArgs), 4)
self.assertDictEqual(callArgs[0].to_json(), expected)
self.assertTrue(callArgs[1] is None)
self.assertTrue(callArgs[2] is None)
def test_alias_contract(self):
e1 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="get")
t = Tracker(e1, namespace="cloudfront", encode_base64=False, app_id="AF003")
try:
t.track_self_describing_event("not-SelfDescribingJson")
except Exception as e:
self.assertIsInstance(e, ContractNotRespected)
def test_add_emitter(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e1 = mokEmitter()
e2 = mokEmitter()
t = Tracker(e1)
t.add_emitter(e2)
self.assertEqual(t.emitters, [e1, e2])
def test_set_subject(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
t = Tracker(e)
new_subject = Subject()
self.assertIsNot(t.subject, new_subject)
t.set_subject(new_subject)
self.assertIs(t.subject, new_subject)
def test_add_emitter(self):
e1 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="get")
e2 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="post")
t = Tracker(e1,
namespace="cloudfront",
encode_base64=False,
app_id="AF003")
t.add_emitter(e2)
self.assertEquals(t.emitters, [e1, e2])
def test_alias_of_track_unstruct_event(self, mok_track):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track.side_effect = mocked_track
t = Tracker(e)
evJson = SelfDescribingJson("test.schema", {"n": "v"})
# call the alias
t.track_self_describing_event(evJson)
self.assertEqual(mok_track.call_count, 1)
def test_flush_async(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e1 = mokEmitter()
e2 = mokEmitter()
t = Tracker([e1, e2])
t.flush(is_async=True)
self.assertEqual(e1.flush.call_count, 1)
e1.sync_flush.assert_not_called()
self.assertEqual(e2.flush.call_count, 1)
e2.sync_flush.assert_not_called()
def test_flush_timer(self):
e1 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="post", buffer_size=10)
t = Tracker(e1, namespace="cloudfront", encode_base64=False, app_id="AF003")
e1.set_flush_timer(3)
t.track_page_view("http://snowplowanalytics.com/blog/2016/09/22/introducing-sauna-a-decisioning-and-response-platform/")
t.track_page_view("http://snowplowanalytics.com/blog/2016/03/17/2015-2016-winternship-wrapup/")
t.track_page_view("http://snowplowanalytics.com/blog/2016/07/31/iglu-r5-scinde-dawk-released/")
self.assertEqual(len(e1.buffer), 3)
time.sleep(4)
self.assertEqual(len(e1.buffer), 0)
t.track_page_view("http://snowplowanalytics.com/blog/2016/03/03/guide-to-debugging-bad-data-in-elasticsearch-kibana/")
t.track_page_view("http://snowplowanalytics.com/blog/2016/03/17/2015-2016-winternship-wrapup/")
self.assertEqual(len(e1.buffer), 2)
def test_track(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e1 = mokEmitter()
e2 = mokEmitter()
e3 = mokEmitter()
t = Tracker([e1, e2, e3])
p = Payload({"test": "track"})
t.track(p)
e1.input.assert_called_once_with({"test": "track"})
e2.input.assert_called_once_with({"test": "track"})
e3.input.assert_called_once_with({"test": "track"})
def test_initialisation_emitter_list(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e1 = mokEmitter()
e2 = mokEmitter()
t = Tracker([e1, e2])
self.assertEqual(t.emitters, [e1, e2])
def test_initialization_with_subject(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
s = Subject()
t = Tracker(e, subject=s)
self.assertIs(t.subject, s)
def test_check_form_element_nodename_invalid(self):
elem = {
"name": "elemName",
"value": "elemValue",
"nodeName": "invalid"
}
self.assertFalse(Tracker.check_form_element(elem))
def test_flush_timer(self):
e1 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="post", buffer_size=10)
t = Tracker(e1, namespace="cloudfront", encode_base64=False, app_id="AF003")
e1.set_flush_timer(3)
t.track_page_view("http://snowplowanalytics.com/blog/2016/09/22/introducing-sauna-a-decisioning-and-response-platform/")
t.track_page_view("http://snowplowanalytics.com/blog/2016/03/17/2015-2016-winternship-wrapup/")
t.track_page_view("http://snowplowanalytics.com/blog/2016/07/31/iglu-r5-scinde-dawk-released/")
self.assertEqual(len(e1.buffer), 3)
time.sleep(4)
self.assertEqual(len(e1.buffer), 0)
t.track_page_view("http://snowplowanalytics.com/blog/2016/03/03/guide-to-debugging-bad-data-in-elasticsearch-kibana/")
t.track_page_view("http://snowplowanalytics.com/blog/2016/03/17/2015-2016-winternship-wrapup/")
self.assertEqual(len(e1.buffer), 2)
def test_check_form_element_type_valid(self):
elem = {
"name": "elemName",
"value": "elemValue",
"nodeName": "TEXTAREA",
"type": "button"
}
self.assertTrue(Tracker.check_form_element(elem))
def test_initialisation(self):
t = Tracker([Emitter("d3rkrsqld9gmqf.cloudfront.net")],
namespace="cloudfront",
encode_base64=False,
app_id="AF003")
self.assertEquals(t.standard_nv_pairs["tna"], "cloudfront")
self.assertEquals(t.standard_nv_pairs["aid"], "AF003")
self.assertEquals(t.encode_base64, False)
def test_track_unstruct_event_encode(self, mok_complete_payload):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_complete_payload.side_effect = mocked_complete_payload
t = Tracker(e, encode_base64=True)
evJson = SelfDescribingJson("test.sde.schema", {"n": "v"})
t.track_unstruct_event(evJson)
self.assertEqual(mok_complete_payload.call_count, 1)
completeArgsList = mok_complete_payload.call_args_list[0][0]
self.assertEqual(len(completeArgsList), 4)
actualPayloadArg = completeArgsList[0]
actualPairs = actualPayloadArg.nv_pairs
self.assertTrue("ue_px" in actualPairs.keys())
def test_initialisation_default_optional(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
t = Tracker(e)
self.assertEqual(t.emitters, [e])
self.assertTrue(t.standard_nv_pairs["tna"] is None)
self.assertTrue(t.standard_nv_pairs["aid"] is None)
self.assertEqual(t.encode_base64, True)
def test_track_ecommerce_transaction_no_items(self, mok_complete_payload):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_complete_payload.side_effect = mocked_complete_payload
t = Tracker(e)
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evTstamp = 1399021242030
t.track_ecommerce_transaction("1234",
10,
"transAffiliation",
2.5,
1.5,
"transCity",
"transState",
"transCountry",
"transCurrency",
context=[ctx],
tstamp=evTstamp)
self.assertEqual(mok_complete_payload.call_count, 1)
completeArgsList = mok_complete_payload.call_args_list[0][0]
self.assertEqual(len(completeArgsList), 4)
actualPayloadArg = completeArgsList[0]
actualContextArg = completeArgsList[1]
actualTstampArg = completeArgsList[2]
actualPairs = actualPayloadArg.nv_pairs
expectedPairs = {
"e": "tr",
"tr_id": "1234",
"tr_tt": 10,
"tr_af": "transAffiliation",
"tr_tx": 2.5,
"tr_sh": 1.5,
"tr_ci": "transCity",
"tr_st": "transState",
"tr_co": "transCountry",
"tr_cu": "transCurrency"
}
self.assertDictEqual(actualPairs, expectedPairs)
self.assertIs(actualContextArg[0], ctx)
self.assertEqual(actualTstampArg, evTstamp)
def test_track_form_submit_empty_elems(self, mok_track_unstruct):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track_unstruct.side_effect = mocked_track_unstruct
t = Tracker(e)
t.track_form_submit("testFormId", elements=[])
expected = {
"schema": FORM_SUBMIT_SCHEMA,
"data": {
"formId": "testFormId"
}
}
callArgs = mok_track_unstruct.call_args_list[0][0]
self.assertEqual(len(callArgs), 4)
self.assertDictEqual(callArgs[0].to_json(), expected)
def test_initialisation(self):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
t = Tracker([e],
namespace="cloudfront",
encode_base64=False,
app_id="AF003")
self.assertEqual(t.standard_nv_pairs["tna"], "cloudfront")
self.assertEqual(t.standard_nv_pairs["aid"], "AF003")
self.assertEqual(t.encode_base64, False)
def test_track_ecommerce_transaction_item(self, mok_complete_payload):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_complete_payload.side_effect = mocked_complete_payload
t = Tracker(e)
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evTstamp = 1399021242030
t.track_ecommerce_transaction_item("1234",
"sku1234",
3.14,
1,
"itemName",
"itemCategory",
"itemCurrency",
context=[ctx],
tstamp=evTstamp)
self.assertEqual(mok_complete_payload.call_count, 1)
completeArgsList = mok_complete_payload.call_args_list[0][0]
self.assertEqual(len(completeArgsList), 4)
actualPayloadArg = completeArgsList[0]
actualContextArg = completeArgsList[1]
actualTstampArg = completeArgsList[2]
actualPairs = actualPayloadArg.nv_pairs
expectedPairs = {
"e": "ti",
"ti_id": "1234",
"ti_sk": "sku1234",
"ti_nm": "itemName",
"ti_ca": "itemCategory",
"ti_pr": 3.14,
"ti_qu": 1,
"ti_cu": "itemCurrency"
}
self.assertDictEqual(actualPairs, expectedPairs)
self.assertIs(actualContextArg[0], ctx)
self.assertEqual(actualTstampArg, evTstamp)
def test_track_unstruct_event_all_args(self, mok_complete_payload):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_complete_payload.side_effect = mocked_complete_payload
t = Tracker(e, encode_base64=False)
evJson = SelfDescribingJson("test.schema", {"n": "v"})
ctx = SelfDescribingJson("test.context.schema", {"user": "******"})
evContext = [ctx]
evTstamp = 1399021242030
t.track_unstruct_event(evJson, evContext, evTstamp)
self.assertEqual(mok_complete_payload.call_count, 1)
completeArgsList = mok_complete_payload.call_args_list[0][0]
self.assertEqual(len(completeArgsList), 4)
# payload
actualPayloadArg = completeArgsList[0]
actualPairs = actualPayloadArg.nv_pairs
actualUePr = json.loads(actualPairs["ue_pr"])
# context
actualContextArg = completeArgsList[1]
# tstamp
actualTstampArg = completeArgsList[2]
expectedUePr = {
"data": {
"data": {
"n": "v"
},
"schema": "test.schema"
},
"schema": UNSTRUCT_SCHEMA
}
self.assertDictEqual(actualUePr, expectedUePr)
self.assertEqual(actualPairs["e"], "ue")
self.assertIs(actualContextArg[0], ctx)
self.assertEqual(actualTstampArg, evTstamp)
def test_complete_payload_cx(self, mok_uuid, mok_track):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_uuid.side_effect = mocked_uuid
mok_track.side_effect = mocked_track
t = Tracker(e, encode_base64=True)
p = Payload()
geo_ctx = SelfDescribingJson(geoSchema, geoData)
mov_ctx = SelfDescribingJson(movSchema, movData)
ctx_array = [geo_ctx, mov_ctx]
t.complete_payload(p, ctx_array, None, None)
self.assertEqual(mok_track.call_count, 1)
trackArgsTuple = mok_track.call_args_list[0][0]
self.assertEqual(len(trackArgsTuple), 1)
passed_nv_pairs = trackArgsTuple[0].nv_pairs
self.assertIn("cx", passed_nv_pairs)
def test_track_site_search_optional_none(self, mok_track_unstruct):
mokEmitter = self.create_patch('snowplow_tracker.Emitter')
e = mokEmitter()
with ContractsDisabled():
mok_track_unstruct.side_effect = mocked_track_unstruct
t = Tracker(e)
t.track_site_search(["track", "search"])
expected = {
"schema": SITE_SEARCH_SCHEMA,
"data": {
"terms": ["track", "search"]
}
}
callArgs = mok_track_unstruct.call_args_list[0][0]
self.assertEqual(len(callArgs), 4)
self.assertDictEqual(callArgs[0].to_json(), expected)
self.assertTrue(callArgs[1] is None)
self.assertTrue(callArgs[2] is None)
def test_get_timestamp(self):
dtm = Tracker.get_timestamp()
self.assertEquals(dtm, 1000) # 1970-01-01 00:00:01 in ms
def test_get_uuid(self):
eid = Tracker.get_uuid()
self.assertIsNotNone(re.match('[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z', eid))
def test_set_timestamp_2(self):
dtm = Tracker.get_timestamp(1399021242240.0303)
self.assertEquals(dtm, 1399021242240)
def test_add_emitter(self):
e1 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="get")
e2 = Emitter("d3rkrsqld9gmqf.cloudfront.net", method="post")
t = Tracker(e1, namespace="cloudfront", encode_base64= False, app_id="AF003")
t.add_emitter(e2)
self.assertEquals(t.emitters, [e1, e2])
def test_set_timestamp_1(self):
dtm = Tracker.get_timestamp(1399021242030)
self.assertEquals(dtm, 1399021242030)
def test_get_transaction_id(self):
tid = Tracker.get_transaction_id()
self.assertTrue(tid >= 100000 and tid <= 999999)
