SAC-30196: remove key from version functions (#192)

* remove key from version state functions

* bump to version 6.7.0 and update changelog

-----------------------------

Co-authored-by: Ben Allred <ben.allred@qlik.com>

---------

Co-authored-by: Leslie VanDeMark <lvandemark@talend.com>

Author: skuttleman

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## 6.7.0
+  * Remove `key` from set_version, get_version, and clear_version state functions [#192](https://github.com/singer-io/singer-python/pull/192)
+
 ## 6.6.0
   * Export singer.state functions from singer
   * Rename singer.state.write_bookmark to singer.state.set_bookmark

setup.py

@@ -4,7 +4,7 @@
 import subprocess
 
 setup(name="singer-python",
-      version='6.6.0',
+      version='6.7.0',
       description="Singer.io utility library",
       author="Stitch",
       classifiers=['Programming Language :: Python :: 3 :: Only'],

singer/state.py

@@ -46,15 +46,15 @@ def set_currently_syncing(state, tap_stream_id):
 def get_currently_syncing(state, default=None):
     return state.get('currently_syncing', default)
 
-def set_version(state, tap_stream_id, key, val):
+def set_version(state, tap_stream_id, val):
     state = ensure_state_path(state, ['activate_versions', tap_stream_id])
-    state['activate_versions'][tap_stream_id][key] = val
+    state['activate_versions'][tap_stream_id] = val
     return state
 
-def clear_version(state, tap_stream_id, key):
+def clear_version(state, tap_stream_id):
     state = ensure_state_path(state, ['activate_versions', tap_stream_id])
-    state['activate_versions'][tap_stream_id].pop(key, None)
+    state['activate_versions'].pop(tap_stream_id, None)
     return state
 
-def get_version(state, tap_stream_id, key, default=None):
-    return state.get('activate_versions', {}).get(tap_stream_id, {}).get(key, default)
+def get_version(state, tap_stream_id, default=None):
+    return state.get('activate_versions', {}).get(tap_stream_id, default)

tests/test_state.py

@@ -207,81 +207,65 @@ def test_empty_state(self):
         empty_state = {}
 
         # Case with no value to fall back on
-        self.assertIsNone(st.get_version(empty_state, 'some_stream', 'my_key'))
+        self.assertIsNone(st.get_version(empty_state, 'some_stream'))
 
         # Case with a given default
-        self.assertEqual(st.get_version(empty_state, 'some_stream', 'my_key', 'default_value'),
+        self.assertEqual(st.get_version(empty_state, 'some_stream', 'default_value'),
                          'default_value')
 
     def test_empty_activate_versions(self):
         empty_versions = {'activate_versions':{}}
 
         # Case with no value to fall back on
-        self.assertIsNone(st.get_version(empty_versions, 'some_stream', 'my_key'))
+        self.assertIsNone(st.get_version(empty_versions, 'some_stream'))
 
         # Case with a given default
-        self.assertEqual(st.get_version(empty_versions, 'some_stream', 'my_key', 'default_value'),
+        self.assertEqual(st.get_version(empty_versions, 'some_stream', 'default_value'),
                          'default_value')
 
     def test_non_empty_state(self):
         stream_id_1 = 'customers'
-        version_key_1 = 'version'
         version_val_1 = 123456789
 
         non_empty_state = {
             'activate_versions' : {
-                stream_id_1 : {
-                    version_key_1 : version_val_1
-                }
+                stream_id_1 : version_val_1
             }
         }
 
         #
         # Cases with no value to fall back on
         #
 
-        # Bad stream, bad key
-        self.assertIsNone(st.get_version(non_empty_state, 'some_stream', 'my_key'))
-
-        # Good stream, bad key
-        self.assertIsNone(st.get_version(non_empty_state, stream_id_1, 'my_key'))
+        # Bad stream
+        self.assertIsNone(st.get_version(non_empty_state, 'some_stream'))
 
-        # Good stream, good key
-        self.assertEqual(st.get_version(non_empty_state, stream_id_1, version_key_1),
+        # Good stream
+        self.assertEqual(st.get_version(non_empty_state, stream_id_1),
                          version_val_1)
 
         #
         # Cases with a given default
         #
 
-        # Bad stream, bad key
-        self.assertEqual(st.get_version(non_empty_state, 'some_stream', 'my_key', 'default_value'),
-                         'default_value')
-
-        # Bad stream, good key
-        self.assertEqual(st.get_version(non_empty_state, 'some_stream', version_key_1, 'default_value'),
-                         'default_value')
-
-        # Good stream, bad key
-        self.assertEqual(st.get_version(non_empty_state, stream_id_1, 'my_key', 'default_value'),
+        # Bad stream
+        self.assertEqual(st.get_version(non_empty_state, 'some_stream', 'default_value'),
                          'default_value')
 
-        # Good stream, good key
-        self.assertEqual(st.get_version(non_empty_state, stream_id_1, version_key_1, 'default_value'),
+        # Good stream
+        self.assertEqual(st.get_version(non_empty_state, stream_id_1, 'default_value'),
                          version_val_1)
 
     def test_set_version(self):
         stream_id_1 = 'customers'
-        version_key_1 = 'datetime'
         version_val_1 = 123456789
 
-        result = st.set_version({'activate_versions': {stream_id_1: {version_key_1: 'old-value'}}}, stream_id_1, version_key_1, version_val_1)
-        self.assertEqual(result, {'activate_versions': {stream_id_1: {version_key_1: version_val_1}}})
+        result = st.set_version({'activate_versions': {stream_id_1: 'old-value'}}, stream_id_1, version_val_1)
+        self.assertEqual(result, {'activate_versions': {stream_id_1: version_val_1}})
 
     def test_clear_version(self):
         stream_id_1 = 'customers'
-        version_key_1 = 'datetime'
         version_val_1 = 123456789
 
-        result = st.clear_version({'activate_versions': {stream_id_1: {version_key_1: version_val_1}}}, stream_id_1, version_key_1)
-        self.assertEqual(result, {'activate_versions': {stream_id_1: {}}})
+        result = st.clear_version({'activate_versions': {stream_id_1: version_val_1}}, stream_id_1)
+        self.assertEqual(result, {'activate_versions': {}})