Access keys fixes

Nonexisting unit tests... are a bad idea.
Sanity testing showed several of the access key
functions were horribly broken.

Also the tests were slightly misleading in their mocking
of the ACCESS_KEY_ID. Namely, the user-supplied NAME was
being used where in practice it would not actually work.

Author: BlackVegetable

keen/__init__.py

@@ -576,7 +576,7 @@ def update_access_key_permissions(access_key_id, permissions):
     _initialize_client_from_environment()
     return _client.update_access_key_permissions(access_key_id, permissions)
 
-def update_access_key_options(self, access_key_id, options):
+def update_access_key_options(access_key_id, options):
     """
     Replaces all of the options on the access key but does not change
     non-option properties such as permissions or the key's name.

keen/api.py

@@ -333,7 +333,7 @@ def _update_access_key_pair(self, access_key_id, key, val):
         current_access_key = self.get_access_key(access_key_id)
 
         # Copy and only change the single parameter.
-        payload_dict = _build_access_key_dict(current_access_key)
+        payload_dict = KeenApi._build_access_key_dict(current_access_key)
         payload_dict[key] = val
 
         # Now just treat it like a full update.
@@ -362,13 +362,13 @@ def add_access_key_permissions(self, access_key_id, permissions):
         current_access_key = self.get_access_key(access_key_id)
 
         # Copy and only change the single parameter.
-        payload_dict = _build_access_key_dict(current_access_key)
+        payload_dict = KeenApi._build_access_key_dict(current_access_key)
 
         # Turn into sets to avoid duplicates.
-        old_permissions = set(payload_dict["permissions"])
+        old_permissions = set(payload_dict["permitted"])
         new_permissions = set(permissions)
         combined_permissions = old_permissions.union(new_permissions)
-        payload_dict["permissions"] = list(combined_permissions)
+        payload_dict["permitted"] = list(combined_permissions)
 
         # Now just treat it like a full update.
         return self.update_access_key_full(access_key_id, **payload_dict)
@@ -389,13 +389,13 @@ def remove_access_key_permissions(self, access_key_id, permissions):
         current_access_key = self.get_access_key(access_key_id)
 
         # Copy and only change the single parameter.
-        payload_dict = _build_access_key_dict(current_access_key)
+        payload_dict = KeenApi._build_access_key_dict(current_access_key)
 
         # Turn into sets to avoid duplicates.
-        old_permissions = set(payload_dict["permissions"])
+        old_permissions = set(payload_dict["permitted"])
         removal_permissions = set(permissions)
-        reduced_permissions = old_permissions.difference_update(removal_permissions)
-        payload_dict["permissions"] = list(reduced_permissions)
+        reduced_permissions = old_permissions.difference(removal_permissions)
+        payload_dict["permitted"] = list(reduced_permissions)
 
         # Now just treat it like a full update.
         return self.update_access_key_full(access_key_id, **payload_dict)
@@ -411,7 +411,7 @@ def update_access_key_permissions(self, access_key_id, permissions):
         :param access_key_id: the 'key' value of the access key to change the permissions of
         :param permissions: the new list of permissions for this key
         """
-        return self._update_access_key_pair(access_key_id, "permissions", permission)
+        return self._update_access_key_pair(access_key_id, "permitted", permissions)
 
     @requires_key(KeenKeys.MASTER)
     def update_access_key_options(self, access_key_id, options):

keen/tests/access_key_tests.py

@@ -10,6 +10,7 @@
 class AccessKeyTests(BaseTestCase):
 
     ACCESS_KEY_NAME = "Bob_Key"
+    ACCESS_KEY_ID = "320104AEFFC569EEE60BCAC9BB064DFF9897E391AB8C59608AC0869AFD291B4E"
     ACCESS_KEY_RESPONSE = MockedResponse(
         status_code=201,
         json_response={'name': "Bob_Key",
@@ -73,24 +74,24 @@ def test_list_access_keys(self, get):
     @patch("requests.Session.get")
     def test_get_access_key(self, get):
         get.return_value = self.ACCESS_KEY_RESPONSE
-        resp = keen.get_access_key(self.ACCESS_KEY_NAME)
-        self.assertEqual("{0}/{1}".format(self.keys_uri_prefix, self.ACCESS_KEY_NAME), get.call_args[0][0])
+        resp = keen.get_access_key(self.ACCESS_KEY_ID)
+        self.assertEqual("{0}/{1}".format(self.keys_uri_prefix, self.ACCESS_KEY_ID), get.call_args[0][0])
         self._assert_proper_permissions(get, keen.master_key)
         self.assertEqual(resp, self.ACCESS_KEY_RESPONSE.json())
 
     @patch("requests.Session.post")
     def test_revoke_access_key(self, post):
         post.return_value = self.NO_CONTENT_RESPONSE
-        resp = keen.revoke_access_key(self.ACCESS_KEY_NAME)
-        self.assertEqual("{0}/{1}/revoke".format(self.keys_uri_prefix, self.ACCESS_KEY_NAME), post.call_args[0][0])
+        resp = keen.revoke_access_key(self.ACCESS_KEY_ID)
+        self.assertEqual("{0}/{1}/revoke".format(self.keys_uri_prefix, self.ACCESS_KEY_ID), post.call_args[0][0])
         self._assert_proper_permissions(post, keen.master_key)
         self.assertEqual(resp, self.NO_CONTENT_RESPONSE.json())
 
     @patch("requests.Session.post")
     def test_unrevoke_access_key(self, post):
         post.return_value = self.NO_CONTENT_RESPONSE
-        resp = keen.unrevoke_access_key(self.ACCESS_KEY_NAME)
-        self.assertEqual("{0}/{1}/unrevoke".format(self.keys_uri_prefix, self.ACCESS_KEY_NAME), post.call_args[0][0])
+        resp = keen.unrevoke_access_key(self.ACCESS_KEY_ID)
+        self.assertEqual("{0}/{1}/unrevoke".format(self.keys_uri_prefix, self.ACCESS_KEY_ID), post.call_args[0][0])
         self._assert_proper_permissions(post, keen.master_key)
         self.assertEqual(resp, self.NO_CONTENT_RESPONSE.json())
 
@@ -101,11 +102,24 @@ def test_update_access_key_full(self, post):
         # well.
         post.return_value = self.UPDATED_ACCESS_KEY_RESPONSE
         options_dict = {"queries": self.UPDATED_ACCESS_KEY_RESPONSE.json_response["options"]["queries"]}
-        resp = keen.update_access_key_full(self.ACCESS_KEY_NAME,
+        resp = keen.update_access_key_full(self.ACCESS_KEY_ID,
                                            name=self.UPDATED_ACCESS_KEY_RESPONSE.json_response["name"],
                                            is_active=self.UPDATED_ACCESS_KEY_RESPONSE.json_response["is_active"],
                                            permitted=self.UPDATED_ACCESS_KEY_RESPONSE.json_response["permitted"],
                                            options=options_dict)
-        self.assertEqual("{0}/{1}".format(self.keys_uri_prefix, self.ACCESS_KEY_NAME), post.call_args[0][0])
+        self.assertEqual("{0}/{1}".format(self.keys_uri_prefix, self.ACCESS_KEY_ID), post.call_args[0][0])
         self._assert_proper_permissions(post, keen.master_key)
         self.assertEqual(resp, self.UPDATED_ACCESS_KEY_RESPONSE.json())
+
+    @patch("requests.Session.get")
+    @patch("requests.Session.post")
+    def test_sanity_of_update_functions(self, post, get):
+        post.return_value = self.UPDATED_ACCESS_KEY_RESPONSE
+        get.return_value = self.UPDATED_ACCESS_KEY_RESPONSE
+        # Ensure at the very least that the other access key functions don't crash when run.
+        keen.update_access_key_name(self.ACCESS_KEY_ID, name="Marzipan")
+        keen.add_access_key_permissions(self.ACCESS_KEY_ID, ["writes"])
+        keen.remove_access_key_permissions(self.ACCESS_KEY_ID, ["writes"])
+        keen.update_access_key_permissions(self.ACCESS_KEY_ID, ["writes", "cached_queries"])
+        keen.update_access_key_options(self.ACCESS_KEY_ID, options={})
+        self.assertTrue(True) # Best test assertion ever.