def test_integration_redis_default(self): r = redis.StrictRedis() t = tracker.Tracker(emitters.RedisEmitter(), default_subject) t.track_page_view("http://www.example.com") event_string = r.rpop("snowplow") event_dict = json.loads(event_string.decode("utf-8")) self.assertEquals(event_dict["e"], "pv")
def test_integration_context_base64(self): t = tracker.Tracker(default_emitter, default_subject, encode_base64=True) with HTTMock(pass_response_content): t.track_page_view("localhost", "local host", None, [{ "schema": "iglu:com.example/user/jsonschema/2-0-3", "data": { "user_type": "tester" } }]) envelope_string = unquote_plus(from_querystring( "cx", querystrings[-1])) envelope = json.loads( (base64.urlsafe_b64decode(bytearray(envelope_string, "utf-8"))).decode("utf-8")) self.assertEquals( envelope, { "schema": "iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-0", "data": [{ "schema": "iglu:com.example/user/jsonschema/2-0-3", "data": { "user_type": "tester" } }] })
def test_integration_standard_nv_pairs(self): s = subject.Subject() s.set_platform("mob") s.set_user_id("user12345") s.set_screen_resolution(100, 200) s.set_color_depth(24) s.set_timezone("Europe London") s.set_lang("en") t = tracker.Tracker(emitters.Emitter("localhost"), s, "cf", app_id="angry-birds-android") with HTTMock(pass_response_content): t.track_page_view("localhost", "local host") expected_fields = { "tna": "cf", "res": "100x200", "lang": "en", "aid": "angry-birds-android", "cd": "24", "tz": "Europe+London", "p": "mob", "tv": "py-" + _version.__version__ } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key])
def test_unicode_get(self): t = tracker.Tracker([default_emitter], default_subject, encode_base64=False) unicode_a = u'\u0107' unicode_b = u'test.\u0107om' test_ctx = SelfDescribingJson('iglu:a.b/c/jsonschema/1-0-0', {'test': unicode_a}) with HTTMock(pass_response_content): t.track_page_view(unicode_b, context=[test_ctx]) t.track_screen_view(unicode_b, context=[test_ctx]) url_string = unquote_plus(from_querystring("url", querystrings[-2])) try: self.assertEqual(url_string.decode('utf-8'), unicode_b) except AttributeError: # in python 3: str type contains unicode (so no 'decode') self.assertEqual(url_string, unicode_b) context_string = unquote_plus(from_querystring("co", querystrings[-1])) actual_a = json.loads(context_string)['data'][0]['data']['test'] self.assertEqual(actual_a, unicode_a) uepr_string = unquote_plus(from_querystring("ue_pr", querystrings[-1])) actual_b = json.loads(uepr_string)['data']['data']['name'] self.assertEqual(actual_b, unicode_b)
def test_integration_screen_view(self): t = tracker.Tracker([default_emitter], default_subject, encode_base64=False) with HTTMock(pass_response_content): t.track_screen_view("Game HUD 2", id_="534") expected_fields = {"e": "ue"} for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key]) envelope_string = from_querystring("ue_pr", querystrings[-1]) envelope = json.loads(unquote_plus(envelope_string)) self.assertEquals( envelope, { "schema": "iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0", "data": { "schema": "iglu:com.snowplowanalytics.snowplow/screen_view/jsonschema/1-0-0", "data": { "name": "Game HUD 2", "id": "534" } } })
def test_integration_unstruct_event_non_base64(self): t = tracker.Tracker([default_emitter], default_subject, encode_base64=False) with HTTMock(pass_response_content): t.track_unstruct_event( SelfDescribingJson( "iglu:com.acme/viewed_product/jsonschema/2-0-2", { "product_id": "ASO01043", "price$flt": 49.95, "walrus$tms": 1000 })) expected_fields = {"e": "ue"} for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key]) envelope_string = from_querystring("ue_pr", querystrings[-1]) envelope = json.loads(unquote_plus(envelope_string)) self.assertEquals( envelope, { "schema": "iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0", "data": { "schema": "iglu:com.acme/viewed_product/jsonschema/2-0-2", "data": { "product_id": "ASO01043", "price$flt": 49.95, "walrus$tms": 1000 } } })
def test_integration_context_base64(self): t = tracker.Tracker([default_emitter], default_subject, encode_base64=True) with HTTMock(pass_response_content): t.track_unstruct_event( SelfDescribingJson( "iglu:com.acme/viewed_product/jsonschema/2-0-2", { "product_id": "ASO01043", "price$flt": 49.95, "walrus$tms": 1000 }), context=[ SelfDescribingJson( "iglu:com.example/user/jsonschema/2-0-3", {"user_type": "tester"}) ]) envelope_string = unquote_plus(from_querystring( "cx", querystrings[-1])) envelope = json.loads( (base64.urlsafe_b64decode(bytearray(envelope_string, "utf-8"))).decode("utf-8")) self.assertEquals( envelope, { "schema": "iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-1", "data": [{ "schema": "iglu:com.example/user/jsonschema/2-0-3", "data": { "user_type": "tester" } }] })
def test_integration_unstruct_event_base64(self): t = tracker.Tracker(default_emitter, default_subject, encode_base64=True) with HTTMock(pass_response_content): t.track_unstruct_event({ "schema": "iglu:com.acme/viewed_product/jsonschema/2-0-2", "data": { "product_id": "ASO01043", "price$flt": 49.95, "walrus$tms": 1000 } }) expected_fields = {"e": "ue"} for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key]) envelope_string = unquote_plus( from_querystring("ue_px", querystrings[-1])) envelope = json.loads( (base64.urlsafe_b64decode(bytearray(envelope_string, "utf-8"))).decode("utf-8")) self.assertEquals( envelope, { "schema": "iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0", "data": { "schema": "iglu:com.acme/viewed_product/jsonschema/2-0-2", "data": { "product_id": "ASO01043", "price$flt": 49.95, "walrus$tms": 1000 } } })
def test_integration_redis_custom(self): r = redis.StrictRedis(db=1) t = tracker.Tracker([emitters.RedisEmitter(rdb=r, key="custom_key")], default_subject) t.track_page_view("http://www.example.com") event_string = r.rpop("custom_key") event_dict = json.loads(event_string.decode("utf-8")) self.assertEquals(event_dict["e"], "pv")
def test_integration_screen_view(self): t = tracker.Tracker(default_emitter, default_subject) with HTTMock(pass_response_content): t.track_screen_view("Game HUD 2", "Hello!") expected_fields = {"e": "ue"} for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key])
def test_timestamps(self): emitter = emitters.Emitter("localhost", protocol="http", port=80, method='post', buffer_size=4) t = tracker.Tracker([emitter], default_subject) with HTTMock(pass_post_response_content): with freeze_time("2013-01-14 03:21:34"): t.track_page_view("localhost", "stamp0", None, tstamp=None) t.track_page_view("localhost", "stamp1", None, tstamp=1358933694000) with freeze_time("2013-01-14 03:22:36"): t.track_page_view("localhost", "stamp2", None, tstamp=DeviceTimestamp(1458133694000)) t.track_page_view("localhost", "stamp3", None, tstamp=TrueTimestamp(1458033694000)) expected_timestamps = [ { "dtm": "1358133694000", "ttm": None, "stm": "1358133756000" }, { "dtm": "1358933694000", "ttm": None, "stm": "1358133756000" }, { "dtm": "1458133694000", "ttm": None, "stm": "1358133756000" }, { "dtm": None, "ttm": "1458033694000", "stm": "1358133756000" }, ] request = querystrings[-1] for i, event in enumerate(expected_timestamps): self.assertEquals(request["data"][i].get("dtm"), expected_timestamps[i]["dtm"]) self.assertEquals(request["data"][i].get("ttm"), expected_timestamps[i]["ttm"]) self.assertEquals(request["data"][i].get("stm"), expected_timestamps[i]["stm"]) self.assertEquals(request["data"][i].get("page"), "stamp" + str(i))
def test_integration_failure_callback(self): callback_success_queue = [] callback_failure_queue = [] callback_emitter = emitters.Emitter( "localhost", on_success=lambda x: callback_success_queue.append(x), on_failure=lambda x, y: callback_failure_queue.append(x)) t = tracker.Tracker(callback_emitter, default_subject) with HTTMock(fail_response_content): t.track_page_view("http://www.example.com") self.assertEquals(callback_success_queue, []) self.assertEquals(callback_failure_queue[0], 0)
def test_post_page_view(self): t = tracker.Tracker([post_emitter], default_subject) with HTTMock(pass_post_response_content): t.track_page_view("localhost", "local host", None) expected_fields = {"e": "pv", "page": "local host", "url": "localhost"} request = querystrings[-1] self.assertEquals( request["schema"], "iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4" ) for key in expected_fields: self.assertEquals(request["data"][0][key], expected_fields[key])
def test_integration_failure_callback(self): callback_success_queue = [] callback_failure_queue = [] callback_emitter = emitters.Emitter( "localhost", on_success=lambda x: callback_success_queue.append(x), on_failure=lambda x, y: callback_failure_queue.append(x)) t = tracker.Tracker([callback_emitter], default_subject) with HTTMock(fail_response_content): t.track_struct_event("Test", "A") self.assertEquals(callback_success_queue, []) self.assertEquals(callback_failure_queue[0], 0)
def test_post_batched(self): post_emitter = emitters.Emitter("localhost", protocol="http", port=80, method='post', buffer_size=2) t = tracker.Tracker(post_emitter, default_subject) with HTTMock(pass_post_response_content): t.track_struct_event("Test", "A") t.track_struct_event("Test", "B") self.assertEquals(querystrings[-1]["data"][0]["se_ac"], "A") self.assertEquals(querystrings[-1]["data"][1]["se_ac"], "B")
def test_integration_ecommerce_transaction(self): t = tracker.Tracker(default_emitter, default_subject) with HTTMock(pass_response_content): t.track_ecommerce_transaction("6a8078be", 35, city="London", currency="GBP", items=[{ "sku": "pbz0026", "price": 20, "quantity": 1 }, { "sku": "pbz0038", "price": 15, "quantity": 1 }]) expected_fields = { "e": "tr", "tr_id": "6a8078be", "tr_tt": "35", "tr_ci": "London", "tr_cu": "GBP" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-3]), expected_fields[key]) expected_fields = { "e": "ti", "ti_id": "6a8078be", "ti_sk": "pbz0026", "ti_pr": "20", "ti_cu": "GBP" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-2]), expected_fields[key]) expected_fields = { "e": "ti", "ti_id": "6a8078be", "ti_sk": "pbz0038", "ti_pr": "15", "ti_cu": "GBP" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key]) self.assertEquals(from_querystring("dtm", querystrings[-3]), from_querystring("dtm", querystrings[-2]))
def test_integration_redis_default(self): try: import redis r = redis.StrictRedis() t = tracker.Tracker([redis_emitter.RedisEmitter()], default_subject) t.track_page_view("http://www.example.com") event_string = r.rpop("snowplow") event_dict = json.loads(event_string.decode("utf-8")) self.assertEqual(event_dict["e"], "pv") except ImportError: with pytest.raises(RuntimeError): re = redis_emitter.RedisEmitter()
def test_integration_page_view(self): t = tracker.Tracker(default_emitter, default_subject) with HTTMock(pass_response_content): t.track_page_view("http://savethearctic.org", "Save The Arctic", "http://referrer.com") expected_fields = { "e": "pv", "page": "Save+The+Arctic", "url": "http%3A%2F%2Fsavethearctic.org", "refr": "http%3A%2F%2Freferrer.com" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key])
def test_bytelimit(self): post_emitter = emitters.Emitter("localhost", protocol="http", port=80, method='post', buffer_size=5, byte_limit=420) t = tracker.Tracker(post_emitter, default_subject) with HTTMock(pass_post_response_content): t.track_struct_event("Test", "A") # 140 bytes t.track_struct_event("Test", "A") # 280 bytes t.track_struct_event("Test", "A") # 420 bytes. Send t.track_struct_event("Test", "AA") # 141 self.assertEquals(len(querystrings[-1]["data"]), 3) self.assertEqual(post_emitter.bytes_queued, 141)
def test_integration_struct_event(self): t = tracker.Tracker(default_emitter, default_subject) with HTTMock(pass_response_content): t.track_struct_event("Ecomm", "add-to-basket", "dog-skateboarding-video", "hd", 13.99) expected_fields = { "se_ca": "Ecomm", "se_pr": "hd", "se_la": "dog-skateboarding-video", "se_va": "13.99", "se_ac": "add-to-basket", "e": "se" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key])
def test_integration_success_callback(self): callback_success_queue = [] callback_failure_queue = [] callback_emitter = emitters.Emitter( "localhost", on_success=lambda x: callback_success_queue.append(x), on_failure=lambda x, y: callback_failure_queue.append(x)) t = tracker.Tracker([callback_emitter], default_subject) with HTTMock(pass_response_content): t.track_page_view("http://www.example.com") expected = { "e": "pv", "url": "http://www.example.com", } self.assertEqual(len(callback_success_queue), 1) for k in expected.keys(): self.assertEqual(callback_success_queue[0][0][k], expected[k]) self.assertEqual(callback_failure_queue, [])
def test_integration_event_subject(self): s = subject.Subject() s.set_domain_user_id("4616bfb38f872d16") s.set_ip_address("255.255.255.255") t = tracker.Tracker([emitters.Emitter("localhost")], s, "cf", app_id="angry-birds-android") evSubject = subject.Subject().set_domain_user_id( "1111aaa11a111a11").set_lang("EN") with HTTMock(pass_response_content): t.track_page_view("localhost", "local host", event_subject=evSubject) expected_fields = {"duid": "1111aaa11a111a11", "lang": "EN"} for key in expected_fields: self.assertEqual(from_querystring(key, querystrings[-1]), expected_fields[key])
def test_timestamps(self): emitter = emitters.Emitter("localhost", protocol="http", port=80, method='post', buffer_size=3) t = tracker.Tracker([emitter], default_subject) with HTTMock(pass_post_response_content): t.track_page_view("localhost", "stamp0", None, tstamp=None) t.track_page_view("localhost", "stamp1", None, tstamp=1358933694000) t.track_page_view("localhost", "stamp2", None, tstamp=1358933694000.00) expected_timestamps = [{ "dtm": "1618790401000", "ttm": None, "stm": "1618790401000" }, { "dtm": "1618790401000", "ttm": "1358933694000", "stm": "1618790401000" }, { "dtm": "1618790401000", "ttm": "1358933694000", "stm": "1618790401000" }] request = querystrings[-1] for i, event in enumerate(expected_timestamps): self.assertEqual(request["data"][i].get("dtm"), expected_timestamps[i]["dtm"]) self.assertEqual(request["data"][i].get("ttm"), expected_timestamps[i]["ttm"]) self.assertEqual(request["data"][i].get("stm"), expected_timestamps[i]["stm"])
def test_integration_context_non_base64(self): t = tracker.Tracker([default_emitter], default_subject, encode_base64=False) with HTTMock(pass_response_content): t.track_page_view("localhost", "local host", None, [ SelfDescribingJson("iglu:com.example/user/jsonschema/2-0-3", {"user_type": "tester"}) ]) envelope_string = from_querystring("co", querystrings[-1]) envelope = json.loads(unquote_plus(envelope_string)) self.assertEquals( envelope, { "schema": "iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-1", "data": [{ "schema": "iglu:com.example/user/jsonschema/2-0-3", "data": { "user_type": "tester" } }] })
def test_integration_ecommerce_transaction_item(self): t = tracker.Tracker(default_emitter, default_subject) with HTTMock(pass_response_content): t.track_ecommerce_transaction_item("12345", "pbz0025", 7.99, 2, "black-tarot", "tarot", currency="GBP") expected_fields = { "ti_ca": "tarot", "ti_id": "12345", "ti_qu": "2", "ti_sk": "pbz0025", "e": "ti", "ti_nm": "black-tarot", "ti_pr": "7.99", "ti_cu": "GBP" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key])
def test_unicode_post(self): t = tracker.Tracker([post_emitter], default_subject, encode_base64=False) unicode_a = u'\u0107' unicode_b = u'test.\u0107om' test_ctx = SelfDescribingJson('iglu:a.b/c/jsonschema/1-0-0', {'test': unicode_a}) with HTTMock(pass_post_response_content): t.track_page_view(unicode_b, context=[test_ctx]) t.track_screen_view(unicode_b, context=[test_ctx]) pv_event = querystrings[-2] self.assertEqual(pv_event['data'][0]['url'], unicode_b) in_test_ctx = json.loads( pv_event['data'][0]['co'])['data'][0]['data']['test'] self.assertEqual(in_test_ctx, unicode_a) sv_event = querystrings[-1] in_uepr_name = json.loads( sv_event['data'][0]['ue_pr'])['data']['data']['name'] self.assertEqual(in_uepr_name, unicode_b)
def test_integration_identification_methods(self): s = subject.Subject() s.set_domain_user_id("4616bfb38f872d16") s.set_ip_address("255.255.255.255") s.set_useragent( "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.0; Trident/5.0)") s.set_network_user_id("fbc6c76c-bce5-43ce-8d5a-31c5") t = tracker.Tracker([emitters.Emitter("localhost")], s, "cf", app_id="angry-birds-android") with HTTMock(pass_response_content): t.track_page_view("localhost", "local host") expected_fields = { "duid": "4616bfb38f872d16", "ip": "255.255.255.255", "ua": "Mozilla%2F5.0+%28compatible%3B+MSIE+9.0%3B+Windows+NT+6.0%3B+Trident%2F5.0%29", "tnuid": "fbc6c76c-bce5-43ce-8d5a-31c5" } for key in expected_fields: self.assertEquals(from_querystring(key, querystrings[-1]), expected_fields[key])