Make optional timestamp argument set 'true timestamp' rather than 'device created timestamp' (closes #251)

Author: adatzer

snowplow_tracker/test/integration/test_integration.py

@@ -33,7 +33,6 @@
 from freezegun import freeze_time
 
 from snowplow_tracker import tracker, _version, emitters, subject
-from snowplow_tracker.timestamp import DeviceTimestamp, TrueTimestamp
 from snowplow_tracker.self_describing_json import SelfDescribingJson
 from snowplow_tracker.redis import redis_emitter, redis_worker
 
@@ -121,7 +120,7 @@ def test_integration_ecommerce_transaction(self):
         for key in expected_fields:
             self.assertEqual(from_querystring(key, querystrings[-1]), expected_fields[key])
 
-        self.assertEqual(from_querystring("dtm", querystrings[-3]), from_querystring("dtm", querystrings[-2]))
+        self.assertEqual(from_querystring("ttm", querystrings[-3]), from_querystring("ttm", querystrings[-2]))
 
     def test_integration_screen_view(self):
         t = tracker.Tracker([default_emitter], default_subject, encode_base64=False)
@@ -328,30 +327,26 @@ def test_post_batched(self):
         self.assertEqual(querystrings[-1]["data"][0]["se_ac"], "A")
         self.assertEqual(querystrings[-1]["data"][1]["se_ac"], "B")
 
+    @freeze_time("2021-04-19 00:00:01")  # unix: 1618790401000
     def test_timestamps(self):
-        emitter = emitters.Emitter("localhost", protocol="http", port=80, method='post', buffer_size=4)
+        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):
-            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))
+            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": "1358133694000", "ttm": None, "stm": "1358133756000"},
-            {"dtm": "1358933694000", "ttm": None, "stm": "1358133756000"},
-            {"dtm": "1458133694000", "ttm": None, "stm": "1358133756000"},
-            {"dtm": None, "ttm": "1458033694000", "stm": "1358133756000"},
+            {"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"])
-            self.assertEqual(request["data"][i].get("page"), "stamp" + str(i))
 
     def test_bytelimit(self):
         post_emitter = emitters.Emitter("localhost", protocol="http", port=80, method='post', buffer_size=5, byte_limit=420)

snowplow_tracker/test/unit/test_tracker.py

@@ -39,7 +39,6 @@
 from snowplow_tracker.subject import Subject
 from snowplow_tracker.payload import Payload
 from snowplow_tracker.self_describing_json import SelfDescribingJson
-from snowplow_tracker.timestamp import DeviceTimestamp, TrueTimestamp
 
 UNSTRUCT_SCHEMA = "iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0"
 CONTEXT_SCHEMA = "iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-1"
@@ -137,22 +136,22 @@ def test_get_uuid(self):
 
     @freeze_time("1970-01-01 00:00:01")
     def test_get_timestamp(self):
-        dtm = Tracker.get_timestamp()
-        self.assertEqual(dtm, 1000)   # 1970-01-01 00:00:01 in ms
+        tstamp = Tracker.get_timestamp()
+        self.assertEqual(tstamp, 1000)   # 1970-01-01 00:00:01 in ms
 
     def test_get_timestamp_1(self):
-        dtm = Tracker.get_timestamp(1399021242030)
-        self.assertEqual(dtm, 1399021242030)
+        tstamp = Tracker.get_timestamp(1399021242030)
+        self.assertEqual(tstamp, 1399021242030)
 
     def test_get_timestamp_2(self):
-        dtm = Tracker.get_timestamp(1399021242240.0303)
-        self.assertEqual(dtm, 1399021242240)
+        tstamp = Tracker.get_timestamp(1399021242240.0303)
+        self.assertEqual(tstamp, 1399021242240)
 
     @freeze_time("1970-01-01 00:00:01")
     def test_get_timestamp_3(self):
         with ContractsDisabled():
-            dtm = Tracker.get_timestamp("1399021242030")   # test wrong arg type
-            self.assertEqual(dtm, 1000)                    # 1970-01-01 00:00:01 in ms
+            tstamp = Tracker.get_timestamp("1399021242030")   # test wrong arg type
+            self.assertEqual(tstamp, 1000)                    # 1970-01-01 00:00:01 in ms
 
     @mock.patch('snowplow_tracker.Tracker.track')
     def test_alias_of_track_unstruct_event(self, mok_track):
@@ -326,8 +325,8 @@ def test_complete_payload_tstamp_int(self, mok_uuid, mok_track):
 
             t = Tracker(e)
             p = Payload()
-            evTstamp = 1000
-            t.complete_payload(p, None, evTstamp, None)
+            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]
@@ -336,7 +335,8 @@ def test_complete_payload_tstamp_int(self, mok_uuid, mok_track):
 
             expected = {
                 "eid": _TEST_UUID,
-                "dtm": evTstamp,
+                "dtm": 1618790401000,
+                "ttm": time_in_millis,
                 "tv": TRACKER_VERSION,
                 "p": "pc"
             }
@@ -355,9 +355,8 @@ def test_complete_payload_tstamp_dtm(self, mok_uuid, mok_track):
 
             t = Tracker(e)
             p = Payload()
-            _time = 1000
-            evTstamp = DeviceTimestamp(_time)
-            t.complete_payload(p, None, evTstamp, None)
+            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]
@@ -366,7 +365,8 @@ def test_complete_payload_tstamp_dtm(self, mok_uuid, mok_track):
 
             expected = {
                 "eid": _TEST_UUID,
-                "dtm": _time,
+                "dtm": 1618790401000,
+                "ttm": time_in_millis,
                 "tv": TRACKER_VERSION,
                 "p": "pc"
             }
@@ -385,9 +385,8 @@ def test_complete_payload_tstamp_ttm(self, mok_uuid, mok_track):
 
             t = Tracker(e)
             p = Payload()
-            _time = 1000
-            evTstamp = TrueTimestamp(_time)
-            t.complete_payload(p, None, evTstamp, None)
+            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]
@@ -396,7 +395,8 @@ def test_complete_payload_tstamp_ttm(self, mok_uuid, mok_track):
 
             expected = {
                 "eid": _TEST_UUID,
-                "ttm": _time,
+                "dtm": 1618790401000,
+                "ttm": time_in_millis,
                 "tv": TRACKER_VERSION,
                 "p": "pc"
             }