keen 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea225965754dd52560665211c578bd3793bde5e2
-  data.tar.gz: 167256828b0989a4543a9c2ad8f6400dab0c565a
+  metadata.gz: 065f80ef6be231a709d26afe30ae76a8a1138812
+  data.tar.gz: d6a07538cff945becfa38fc12015f1e0244d9032
 SHA512:
-  metadata.gz: 272b9dab9b16c0cb8d6c9aa6e4a1caf40bff0e4e807619c3f884b814bbd0cf926d6cd6416a1dd337299b63c8ee99813649022f07a37d6347b75a60a0a98e3201
-  data.tar.gz: 1df6f05bb56a255fcc463b7bfe4420fc15e2c32bc38bb389d6ecdbd48f753cbf9a963d9c644e92121e8b36e6b4d4e2fd6abe3abbafff1ae675fece9f87f9cbef
+  metadata.gz: 40e792c1cd92e85b901b365ad3f27a146e964094cb25475a252b36f903760eb319055d620eb2ceee371ccb7fbb3bc7bfddb306c0b871b07b50d96e741f2f4a5e
+  data.tar.gz: 5b65635514c0be2d55107f3d1aa3a532a2d502f3b9599817daa691e9adcfb6f1e3ff8505e9ad74b6ee2d296fef8f099e4a67080e7717a0a0dbb577c602d44201

data/README.md

@@ -355,6 +355,8 @@ This is helpful for tracking email clickthroughs. See the [redirect documentatio
 
 #### Generating scoped keys
 
+Note, Scoped Keys are now *deprecated* in favor of [access keys](https://keen.io/docs/api/#access-keys?s=gh-gem).
+
 A [scoped key](https://keen.io/docs/security/#scoped-key?s=gh-gem) is a string, generated with your API Key, that represents some encrypted authentication and query options.
 Use them to control what data queries have access to.
 
@@ -369,6 +371,34 @@ scoped_key = Keen::ScopedKey.new("my-api-key", { "filters" => [{
 
 You can use the scoped key created in Ruby for API requests from any client. Scoped keys are commonly used in JavaScript, where credentials are visible and need to be protected.
 
+#### Access Keys
+
+You can use access keys to restrict the functionality of a key you use with the Keen API. Access keys can also enrich events that you send.
+
+[Read up](https://keen.io/docs/api/#access-keys?s=gh-gem) on the full key body options.
+
+Create a key that automatically adds information to each event published with that key:
+
+``` ruby
+key_body = {
+  "name" => "autofill foo",
+  "is_active" => true,
+  "permitted" => ["writes"],
+  "options" => {
+    "writes" => {
+      "autofill": {
+        "foo": "bar"
+      }
+    }
+  }
+}
+
+new_key = client.access_keys.create(key_body)
+autofill_write_key = new_key["key"]
+```
+
+You can `revoke` and `unrevoke` keys to disable or enable access. `all` will return all current keys for the project, while `get("key-value-here")` will return info for a single key. You can also `update` and `delete` keys.
+
 ### Additional options
 
 ##### HTTP Read Timeout
@@ -417,6 +447,11 @@ If you want some bot protection, check out the [Voight-Kampff](https://github.co
 
 ### Changelog
 
+##### 1.1.0
++ Add support for access keys
++ Move saved queries into the Keen namespace
++ Deprecate scoped keys in favor of access keys
+
 ##### 1.0.0
 + Remove support for ruby 1.9.3
 + Update a few dependencies

data/lib/keen.rb

@@ -1,7 +1,9 @@
 require 'logger'
 require 'forwardable'
 
+require 'keen/access_keys'
 require 'keen/client'
+require 'keen/saved_queries'
 require 'keen/scoped_key'
 
 module Keen
@@ -52,7 +54,8 @@ module Keen
                    :project_info,
                    :query_url,
                    :query,
-                   :saved_queries
+                   :saved_queries,
+                   :access_keys
 
     attr_writer :logger
 

data/lib/keen/access_keys.rb

@@ -0,0 +1,93 @@
+require 'multi_json'
+
+module Keen
+  class AccessKeys
+    def initialize(client)
+      @client = client
+    end
+
+    def get(key)
+      client.ensure_master_key!
+      path = "/#{key}"
+
+      response = access_keys_get(client.master_key, path)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def all()
+      client.ensure_master_key!
+
+      response = access_keys_get(client.master_key)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    # For information on the format of the key_body, see
+    # https://keen.io/docs/api/#access-keys
+    def create(key_body)
+      client.ensure_master_key!
+
+      path = ""
+      response = access_keys_post(client.master_key, path, key_body)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def update(key, key_body)
+      client.ensure_master_key!
+
+      path = "/#{key}"
+      response = access_keys_post(client.master_key, path, key_body)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def revoke(key)
+      client.ensure_master_key!
+
+      path = "/#{key}/revoke"
+      response = access_keys_post(client.master_key, path)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def unrevoke(key)
+      client.ensure_master_key!
+
+      path = "/#{key}/unrevoke"
+      response = access_keys_post(client.master_key, path)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def delete(key)
+      client.ensure_master_key!
+
+      response = Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).delete(
+        path: access_keys_base_url + "/#{key}",
+        headers: client.api_headers(client.master_key, "sync")
+      )
+
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def access_keys_base_url
+      client.ensure_project_id!
+      "/#{client.api_version}/projects/#{client.project_id}/keys"
+    end
+
+    private
+
+    attr_reader :client
+
+    def access_keys_get(api_key, path = "")
+      Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).get(
+        path: access_keys_base_url + path,
+        headers: client.api_headers(api_key, "sync")
+      )
+    end
+
+    def access_keys_post(api_key, path = "", body = "")
+      Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).post(
+        path: access_keys_base_url + path,
+        headers: client.api_headers(api_key, "sync"),
+        body: MultiJson.dump(body)
+      )
+    end
+  end
+end

data/lib/keen/client.rb

@@ -3,7 +3,6 @@ require 'keen/version'
 require 'keen/client/publishing_methods'
 require 'keen/client/querying_methods'
 require 'keen/client/maintenance_methods'
-require 'keen/client/saved_queries'
 require 'keen/version'
 require 'openssl'
 require 'multi_json'
@@ -62,7 +61,9 @@ module Keen
       @saved_queries ||= SavedQueries.new(self)
     end
 
-    private
+    def access_keys
+      @access_keys ||= AccessKeys.new(self)
+    end
 
     def process_response(status_code, response_body)
       case status_code.to_i
@@ -102,6 +103,8 @@ module Keen
       raise ConfigurationError, "Read Key must be set for this operation" unless self.read_key
     end
 
+    private
+
     def api_event_collection_resource_path(event_collection)
       encoded_collection_name = Addressable::URI.encode_component(event_collection.to_s)
       encoded_collection_name.gsub! '/', '%2F'

data/lib/keen/saved_queries.rb

@@ -0,0 +1,83 @@
+require 'keen/version'
+require "json"
+
+module Keen
+  class SavedQueries
+    def initialize(client)
+      @client = client
+    end
+
+    def all
+      client.ensure_master_key!
+
+      response = saved_query_response(client.master_key)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def get(saved_query_name, results = false)
+      saved_query_path = "/#{saved_query_name}"
+      if results
+        client.ensure_read_key!
+        saved_query_path += "/result"
+        # The results path should use the READ KEY
+        api_key = client.read_key
+      else
+        client.ensure_master_key!
+        api_key = client.master_key
+      end
+
+      response = saved_query_response(api_key, saved_query_path)
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    def create(saved_query_name, saved_query_body)
+      client.ensure_master_key!
+
+      response = Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).put(
+        path: "#{saved_query_base_url}/#{saved_query_name}",
+        headers: api_headers(client.master_key, "sync"),
+        body: saved_query_body
+      )
+      client.process_response(response.code.to_i, response.body)
+    end
+    alias_method :update, :create
+
+    def delete(saved_query_name)
+      client.ensure_master_key!
+
+      response = Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).delete(
+        path: "#{saved_query_base_url}/#{saved_query_name}",
+        headers: api_headers(client.master_key, "sync")
+      )
+      client.process_response(response.code.to_i, response.body)
+    end
+
+    private
+
+    attr_reader :client
+
+    def saved_query_response(api_key, path = "")
+      Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).get(
+        path: saved_query_base_url + path,
+        headers: api_headers(api_key, "sync")
+      )
+    end
+
+    def saved_query_base_url
+      client.ensure_project_id!
+      "/#{client.api_version}/projects/#{client.project_id}/queries/saved"
+    end
+
+    def api_headers(authorization, sync_type)
+      user_agent = "keen-gem, v#{Keen::VERSION}, #{sync_type}"
+      user_agent += ", #{RUBY_VERSION}, #{RUBY_PLATFORM}, #{RUBY_PATCHLEVEL}"
+      if defined?(RUBY_ENGINE)
+        user_agent += ", #{RUBY_ENGINE}"
+      end
+      { "Content-Type" => "application/json",
+        "User-Agent" => user_agent,
+        "Authorization" => authorization,
+        "Keen-Sdk" => "ruby-#{Keen::VERSION}" }
+    end
+  end
+end

data/lib/keen/scoped_key.rb

@@ -3,6 +3,7 @@ require 'keen/aes_helper'
 require 'keen/aes_helper_old'
 
 module Keen
+  # <b>DEPRECATED:</b> Please use <tt>access keys</tt> instead.
   class ScopedKey
 
     attr_accessor :api_key
@@ -26,6 +27,8 @@ module Keen
     end
 
     def encrypt!(iv = nil)
+      warn "[DEPRECATION] Scoped keys are deprecated. Please use `access_keys` instead."
+
       json_str = MultiJson.dump(self.data)
       if self.api_key.length == 64
         Keen::AESHelper.aes256_encrypt(self.api_key, json_str, iv)

data/lib/keen/version.rb

@@ -1,3 +1,3 @@
 module Keen
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/integration/access_keys_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Access Keys" do
+  let(:project_id) { ENV["KEEN_PROJECT_ID"] }
+  let(:master_key) { ENV["KEEN_MASTER_KEY"] }
+  let(:client) { Keen::Client.new(project_id: project_id, master_key: master_key) }
+
+  describe "#all" do
+    it "gets all access keys" do
+      expect(client.access_keys.all).to be_instance_of(Array)
+    end
+  end
+
+  describe "#create" do
+    it "creates a key" do
+      key_body = {
+        "name" => "integration test key",
+        "is_active" => true,
+        "permitted" => ["queries"],
+        "options" => {}
+      }
+
+      create_result = client.access_keys.create(key_body)
+      expect(create_result["name"]).to eq(key_body["name"])
+    end
+  end
+
+  describe "#get" do
+    it "gets a single access key" do
+      all_keys = client.access_keys.all
+
+      access_key = client.access_keys.get(all_keys.first["key"])
+
+      expect(access_key["name"]).to eq(all_keys.first["name"])
+    end
+  end
+
+  describe "#revoke" do
+    it "sets the is_active to false" do
+      all_keys = client.access_keys.all
+      key = all_keys.first["key"]
+
+      client.access_keys.revoke(key)
+      new_key = client.access_keys.get(key)
+      expect(new_key["is_active"]).to be_falsey
+    end
+  end
+
+  describe "#unrevoke" do
+    it "sets the is_active to true" do
+      all_keys = client.access_keys.all
+      key = all_keys.first["key"]
+
+      client.access_keys.unrevoke(key)
+      new_key = client.access_keys.get(key)
+      expect(new_key["is_active"]).to be_truthy
+    end
+  end
+
+  describe "#delete" do
+    it "deletes a key" do
+      all_keys = client.access_keys.all
+      key = all_keys.first["key"]
+
+      client.access_keys.delete(key)
+      all_keys = client.access_keys.all
+      expect(all_keys).to eq([])
+    end
+  end
+end

data/spec/integration/api_spec.rb

@@ -7,7 +7,7 @@ describe "Keen IO API" do
   def wait_for_count(event_collection, count)
     attempts = 0
     while attempts < 30
-      break if Keen.count(event_collection) == count
+      break if Keen.count(event_collection, {:timeframe => "this_2_hours"}) == count
       attempts += 1
       sleep(1)
     end
@@ -20,7 +20,7 @@ describe "Keen IO API" do
 
     describe "success" do
       it "should return a created status for a valid post" do
-        Keen.publish(collection, event_properties).should == api_success
+        expect(Keen.publish(collection, event_properties)).to eq(api_success)
       end
     end
 
@@ -33,7 +33,7 @@ describe "Keen IO API" do
       end
 
       it "should succeed if a non-url-safe event collection is specified" do
-        Keen.publish("infinite possibilities", event_properties).should == api_success
+        expect(Keen.publish("infinite possibilities", event_properties)).to eq(api_success)
       end
     end
 
@@ -45,7 +45,7 @@ describe "Keen IO API" do
           EM.run {
             Keen.publish_async(collection, event_properties).callback { |response|
               begin
-                response.should == api_success
+                expect(response).to eq(api_success)
               ensure
                 EM.stop
               end
@@ -60,7 +60,7 @@ describe "Keen IO API" do
           EM.run {
             Keen.publish_async("foo bar", event_properties).callback { |response|
               begin
-                response.should == api_success
+                expect(response).to eq(api_success)
               ensure
                 EM.stop
               end
@@ -72,7 +72,7 @@ describe "Keen IO API" do
 
     describe "batch" do
       it "should publish a batch of events" do
-        Keen.publish_batch(
+        expect(Keen.publish_batch(
           :batch_signups => [
             { :name => "bob" },
             { :name => "ted" }
@@ -81,7 +81,7 @@ describe "Keen IO API" do
             { :price => 30 },
             { :price => 40 }
           ]
-        ).should == {
+        )).to eq({
           "batch_purchases" => [
             { "success" => true },
             { "success" => true }
@@ -89,7 +89,7 @@ describe "Keen IO API" do
           "batch_signups" => [
             { "success" => true },
             { "success"=>true }
-          ]}
+          ]})
       end
     end
   end
@@ -110,7 +110,7 @@ describe "Keen IO API" do
                 { :price => 40 }
               ]).callback { |response|
               begin
-                response.should == api_success
+                expect(response).to eq(api_success)
               ensure
                 EM.stop
               end
@@ -151,111 +151,115 @@ describe "Keen IO API" do
     end
 
     it "should return a valid count_unique" do
-      Keen.count_unique(event_collection, :target_property => "price").should == 2
+      expect(Keen.count_unique(event_collection, :timeframe => "this_2_hours", :target_property => "price")).to eq(2)
     end
 
     it "should return a valid count with group_by" do
-      response = Keen.average(event_collection, :group_by => "username", :target_property => "price")
+      response = Keen.average(event_collection, :timeframe => "this_2_hours", :group_by => "username", :target_property => "price")
       bobs_response = response.select { |result| result["username"] == "bob" }.first
-      bobs_response["result"].should == 10
+      expect(bobs_response["result"]).to eq(10)
       teds_response = response.select { |result| result["username"] == "ted" }.first
-      teds_response["result"].should == 20
+      expect(teds_response["result"]).to eq(20)
     end
 
     it "should return a valid count with multi-group_by" do
-      response = Keen.average(event_collection, :group_by => ["username", "price"], :target_property => "price")
+      response = Keen.average(event_collection, :timeframe => "this_2_hours", :group_by => ["username", "price"], :target_property => "price")
       bobs_response = response.select { |result| result["username"] == "bob" }.first
-      bobs_response["result"].should == 10
-      bobs_response["price"].should == 10
+      expect(bobs_response["result"]).to eq(10)
+      expect(bobs_response["price"]).to eq(10)
       teds_response = response.select { |result| result["username"] == "ted" }.first
-      teds_response["result"].should == 20
-      teds_response["price"].should == 20
+      expect(teds_response["result"]).to eq(20)
+      expect(teds_response["price"]).to eq(20)
     end
 
     it "should return a valid sum" do
-      Keen.sum(event_collection, :target_property => "price").should == 30
+      expect(Keen.sum(event_collection, :timeframe => "this_2_hours", :target_property => "price")).to eq(30)
     end
 
     it "should return a valid minimum" do
-      Keen.minimum(event_collection, :target_property => "price").should == 10
+      expect(Keen.minimum(event_collection, :timeframe => "this_2_hours", :target_property => "price")).to eq(10)
     end
 
     it "should return a valid maximum" do
-      Keen.maximum(event_collection, :target_property => "price").should == 20
+      expect(Keen.maximum(event_collection, :timeframe => "this_2_hours", :target_property => "price")).to eq(20)
     end
 
     it "should return a valid average" do
-      Keen.average(event_collection, :target_property => "price").should == 15
+      expect(Keen.average(event_collection, :timeframe => "this_2_hours", :target_property => "price")).to eq(15)
     end
 
     it "should return a valid median" do
-      Keen.median(event_collection, :target_property => "price").should == 10
+      expect(Keen.median(event_collection, :timeframe => "this_2_hours", :target_property => "price")).to eq(10)
     end
 
     it "should return a valid percentile" do
-      Keen.percentile(event_collection, :target_property => "price", :percentile => 50).should == 10
-      Keen.percentile(event_collection, :target_property => "price", :percentile => 100).should == 20
+      expect(Keen.percentile(event_collection, :timeframe => "this_2_hours", :target_property => "price", :percentile => 50)).to eq(10)
+      expect(Keen.percentile(event_collection, :timeframe => "this_2_hours", :target_property => "price", :percentile => 100)).to eq(20)
     end
 
     it "should return a valid select_unique" do
-      results = Keen.select_unique(event_collection, :target_property => "price")
-      results.sort.should == [10, 20].sort
+      results = Keen.select_unique(event_collection, :timeframe => "this_2_hours", :target_property => "price")
+      expect(results.sort).to eq([10, 20].sort)
     end
 
     it "should return a valid extraction" do
-      results = Keen.extraction(event_collection)
-      results.length.should == 2
-      results.all? { |result| result["keen"] }.should be_true
-      results.map { |result| result["price"] }.sort.should == [10, 20]
-      results.map { |result| result["username"] }.sort.should == ["bob", "ted"]
+      results = Keen.extraction(event_collection, :timeframe => "this_2_hours")
+      expect(results.length).to eq(2)
+      expect(results.all? { |result| result["keen"] }).to be_truthy
+      expect(results.map { |result| result["price"] }.sort).to eq([10, 20])
+      expect(results.map { |result| result["username"] }.sort).to eq(["bob", "ted"])
     end
 
     it "should return a valid extraction of one property name" do
-      results = Keen.extraction(event_collection, :property_names => "price")
-      results.length.should == 2
-      results.any? { |result| result["keen"] }.should be_false
-      results.map { |result| result["price"] }.sort.should == [10, 20]
-      results.map { |result| result["username"] }.sort.should == [nil, nil]
+      results = Keen.extraction(event_collection, :timeframe => "this_2_hours", :property_names => "price")
+      expect(results.length).to eq(2)
+      expect(results.any? { |result| result["keen"] }).to be_falsey
+      expect(results.map { |result| result["price"] }.sort).to eq([10, 20])
+      expect(results.map { |result| result["username"] }.sort).to eq([nil, nil])
     end
 
     it "should return a valid extraction of more than one property name" do
-      results = Keen.extraction(event_collection, :property_names => ["price", "username"])
-      results.length.should == 2
-      results.any? { |result| result["keen"] }.should be_false
-      results.map { |result| result["price"] }.sort.should == [10, 20]
-      results.map { |result| result["username"] }.sort.should == ["bob", "ted"]
+      results = Keen.extraction(event_collection, :timeframe => "this_2_hours", :property_names => ["price", "username"])
+      expect(results.length).to eq(2)
+      expect(results.any? { |result| result["keen"] }).to be_falsey
+      expect(results.map { |result| result["price"] }.sort).to eq([10, 20])
+      expect(results.map { |result| result["username"] }.sort).to eq(["bob", "ted"])
     end
 
     it "should return a valid funnel" do
       steps = [{
         :event_collection => event_collection,
-        :actor_property => "username"
+        :actor_property => "username",
+        :timeframe => "this_2_hours"
       }, {
         :event_collection => @returns_event_collection,
-        :actor_property => "username"
+        :actor_property => "username",
+        :timeframe => "this_2_hours"
       }]
       results = Keen.funnel(:steps => steps)
-      results.should == [2, 1]
+      expect(results).to eq([2, 1])
     end
 
     it "should return all keys of valid funnel if full result option is passed" do
       steps = [{
+        :timeframe => "this_2_hours",
         :event_collection => event_collection,
         :actor_property => "username"
       }, {
+        :timeframe => "this_2_hours",
         :event_collection => @returns_event_collection,
         :actor_property => "username"
       }]
       results = Keen.funnel({ :steps => steps }, { :response => :all_keys })
-      results["result"].should == [2, 1]
+      expect(results["result"]).to eq([2, 1])
     end
 
     it "should apply filters" do
-      Keen.count(event_collection, :filters => [{
+      expect(Keen.count(event_collection, :timeframe => "this_2_hours", :filters => [{
         :property_name => "username",
         :operator => "eq",
         :property_value => "ted"
-      }]).should == 1
+      }])).to eq(1)
     end
   end
 
@@ -273,9 +277,9 @@ describe "Keen IO API" do
         { :property_name => "delete", :operator => "eq", :property_value => "me" }
       ])
       wait_for_count(event_collection, 1)
-      results = Keen.extraction(event_collection)
-      results.length.should == 1
-      results.first["delete"].should == "you"
+      results = Keen.extraction(event_collection, :timeframe => "this_2_hours")
+      expect(results.length).to eq(1)
+      expect(results.first["delete"]).to eq("you")
     end
   end
 
@@ -286,21 +290,13 @@ describe "Keen IO API" do
        # requires a project with at least 1 collection
        it "should return the project's collections as JSON" do
          first_collection = Keen.event_collections.first
-         first_collection["properties"]["keen.timestamp"].should == "datetime"
-       end
-     end
-
-     describe "event_collection" do
-       # requires a project with at least 1 collection
-       it "should return the project's named collection as JSON" do
-         first_collection = Keen.event_collection(:event_collection)
-         first_collection["properties"]["keen.timestamp"].should == "datetime"
+         expect(first_collection["properties"]["keen.timestamp"]).to eq("datetime")
        end
      end
 
      describe "project_info" do
        it "should return the project info as JSON" do
-         Keen.project_info["url"].should =~ Regexp.new(project_id)
+         expect(Keen.project_info["url"]).to include(project_id)
 
        end
      end

data/spec/keen/access_keys_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Keen do
+  let(:client) do
+    Keen::Client.new(
+      project_id: "12341234",
+      master_key: "abcdef",
+      api_url: "https://notreal.keen.io"
+    )
+  end
+
+  describe "#access_keys" do
+    describe "#all" do
+
+      it "returns all access keys" do
+        all_access_keys = [
+          key_object()
+        ]
+
+        stub_keen_get(access_keys_endpoint, 200, all_access_keys)
+
+        all_access_keys_response = client.access_keys.all
+
+        expect(all_access_keys_response).to eq(all_access_keys)
+      end
+    end
+
+    describe "#get" do
+      it "returns a specific access key given a key" do
+        key = key_object()
+
+        stub_keen_get(
+          access_keys_endpoint + "/#{key["key"]}",
+          200,
+          key
+        )
+
+        access_key_response = client.access_keys.get(key["key"])
+
+        expect(access_key_response).to eq(key)
+      end
+		end
+
+    describe "#create" do
+      it "returns the created saved query when creation is successful" do
+        key = key_object()
+
+        stub_keen_post(
+          access_keys_endpoint, 201, key
+        )
+
+        access_keys_response = client.access_keys.create(key)
+
+        expect(access_keys_response).to eq(key)
+      end
+    end
+
+    describe "#update" do
+      it "returns the updated access key when update is successful" do
+        key = key_object()
+
+        stub_keen_post(
+          access_keys_endpoint + "/#{key["key"]}", 200, key
+        )
+
+        access_keys_response = client.access_keys.update(key["key"], key)
+
+        expect(access_keys_response).to eq(key)
+      end
+    end
+
+    describe "#delete" do
+      it "returns true with deletion is successful" do
+        key = "asdf1234"
+
+        stub_keen_delete(
+          access_keys_endpoint + "/#{key}", 204
+        )
+
+        access_keys_response = client.access_keys.delete(key)
+
+        expect(access_keys_response).to eq(true)
+      end
+    end
+  end
+
+  def access_keys_endpoint
+    client.api_url + "/#{client.api_version}/projects/#{client.project_id}/keys"
+  end
+
+  def key_object(name = "Test Access Key")
+    {
+      "key" => "SDKFJSDKFJSDKFJSDKFJDSK",
+      "name" => name,
+      "is_active" => true,
+      "permitted" => ["queries", "cached_queries"],
+      "options" => {
+        "queries" => {
+          "filters" => [
+            {
+              "property_name" => "customer.id",
+              "operator" => "eq", 
+              "property_value" => "asdf12345z"
+            }
+          ]
+        },
+        "cached_queries" => {
+          "allowed" => ["my_cached_query"]
+        }
+      }
+    }
+  end
+end

data/spec/keen/saved_query_spec.rb

@@ -14,18 +14,18 @@ describe Keen do
 
       it "returns all saved queries" do
         all_saved_queries = [ {
-          refresh_rate: 0,
-          last_modified_date: "2015-10-19T20:14:29.797000+00:00",
-          query_name: "Analysis-API-Calls-this-1-day",
-          query: {
-            filters: [],
-            analysis_type: "count",
-            timezone: "UTC",
-            timeframe: "this_1_days",
-            event_collection: "analysis_api_call"
+          "refresh_rate" => 0,
+          "last_modified_date" => "2015-10-19T20:14:29.797000+00:00",
+          "query_name" => "Analysis-API-Calls-this-1-day",
+          "query" => {
+            "filters" => [],
+            "analysis_type" => "count",
+            "timezone" => "UTC",
+            "timeframe" => "this_1_days",
+            "event_collection" => "analysis_api_call"
           },
-          metadata: {
-            visualization: { chart_type: "metric"}
+          "metadata" => {
+            "visualization" => { "chart_type" => "metric"}
           }
         } ]
         stub_keen_get(saved_query_endpoint, 200, all_saved_queries)
@@ -39,22 +39,22 @@ describe Keen do
     describe "#get" do
       it "returns a specific saved query given a query id" do
         saved_query = {
-          refresh_rate: 0,
-          last_modified_date: "2015-10-19T20:14:29.797000+00:00",
-          query_name: "Analysis-API-Calls-this-1-day",
-          query: {
-            filters: [],
-            analysis_type: "count",
-            timezone: "UTC",
-            timeframe: "this_1_days",
-            event_collection: "analysis_api_call"
+          "refresh_rate" => 0,
+          "last_modified_date" => "2015-10-19T20:14:29.797000+00:00",
+          "query_name" => "Analysis-API-Calls-this-1-day",
+          "query" => {
+            "filters" => [],
+            "analysis_type" => "count",
+            "timezone" => "UTC",
+            "timeframe" => "this_1_days",
+            "event_collection" => "analysis_api_call"
           },
-          metadata: {
-            visualization: { chart_type: "metric"}
+          "metadata" => {
+            "visualization" => { "chart_type" => "metric"}
           }
         }
         stub_keen_get(
-          saved_query_endpoint + "/#{saved_query[:query_name]}",
+          saved_query_endpoint + "/#{saved_query["query_name"]}",
           200,
           saved_query
         )
@@ -84,18 +84,18 @@ describe Keen do
     describe "#create" do
       it "returns the created saved query when creation is successful" do
         saved_query = {
-          refresh_rate: 0,
-          last_modified_date: "2015-10-19T20:14:29.797000+00:00",
-          query_name: "new-query",
-          query: {
-            filters: [],
-            analysis_type: "count",
-            timezone: "UTC",
-            timeframe: "this_1_days",
-            event_collection: "analysis_api_call"
+          "refresh_rate" => 0,
+          "last_modified_date" => "2015-10-19T20:14:29.797000+00:00",
+          "query_name" => "new-query",
+          "query" => {
+            "filters" => [],
+            "analysis_type" => "count",
+            "timezone" => "UTC",
+            "timeframe" => "this_1_days",
+            "event_collection" => "analysis_api_call"
           },
-          metadata: {
-            visualization: { chart_type: "metric"}
+          "metadata" => {
+            "visualization" => { "chart_type" => "metric"}
           }
         }
         stub_keen_put(
@@ -121,18 +121,18 @@ describe Keen do
     describe "#update" do
       it "returns the created saved query when update is successful" do
         saved_query = {
-          refresh_rate: 0,
-          last_modified_date: "2015-10-19T20:14:29.797000+00:00",
-          query_name: "new-query",
-          query: {
-            filters: [],
-            analysis_type: "count",
-            timezone: "UTC",
-            timeframe: "this_1_days",
-            event_collection: "analysis_api_call"
+          "refresh_rate" => 0,
+          "last_modified_date" => "2015-10-19T20:14:29.797000+00:00",
+          "query_name" => "new-query",
+          "query" => {
+            "filters" => [],
+            "analysis_type" => "count",
+            "timezone" => "UTC",
+            "timeframe" => "this_1_days",
+            "event_collection" => "analysis_api_call"
           },
-          metadata: {
-            visualization: { chart_type: "metric"}
+          "metadata" => {
+            "visualization" => { "chart_type" => "metric"}
           }
         }
         stub_keen_put(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keen
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Alex Kleissner
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-15 00:00:00.000000000 Z
+date: 2017-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -154,19 +154,22 @@ files:
 - config/cacert.pem
 - keen.gemspec
 - lib/keen.rb
+- lib/keen/access_keys.rb
 - lib/keen/aes_helper.rb
 - lib/keen/aes_helper_old.rb
 - lib/keen/client.rb
 - lib/keen/client/maintenance_methods.rb
 - lib/keen/client/publishing_methods.rb
 - lib/keen/client/querying_methods.rb
-- lib/keen/client/saved_queries.rb
 - lib/keen/http.rb
+- lib/keen/saved_queries.rb
 - lib/keen/scoped_key.rb
 - lib/keen/version.rb
+- spec/integration/access_keys_spec.rb
 - spec/integration/api_spec.rb
 - spec/integration/saved_query_spec.rb
 - spec/integration/spec_helper.rb
+- spec/keen/access_keys_spec.rb
 - spec/keen/client/maintenance_methods_spec.rb
 - spec/keen/client/publishing_methods_spec.rb
 - spec/keen/client/querying_methods_spec.rb
@@ -204,9 +207,11 @@ signing_key:
 specification_version: 4
 summary: Keen IO API Client
 test_files:
+- spec/integration/access_keys_spec.rb
 - spec/integration/api_spec.rb
 - spec/integration/saved_query_spec.rb
 - spec/integration/spec_helper.rb
+- spec/keen/access_keys_spec.rb
 - spec/keen/client/maintenance_methods_spec.rb
 - spec/keen/client/publishing_methods_spec.rb
 - spec/keen/client/querying_methods_spec.rb

data/lib/keen/client/saved_queries.rb

@@ -1,88 +0,0 @@
-require 'keen/version'
-require "json"
-
-class SavedQueries
-  def initialize(client)
-    @client = client
-  end
-
-  def all
-    process_response(saved_query_response(client.master_key))
-  end
-
-  def get(saved_query_name, results = false)
-    saved_query_path = "/#{saved_query_name}"
-    api_key = client.master_key
-    if results
-      saved_query_path += "/result"
-      # The results path should use the READ KEY
-      api_key = client.read_key
-    end
-
-    response = saved_query_response(api_key, saved_query_path)
-    response_body = JSON.parse(response.body, symbolize_names: true)
-    process_response(response)
-  end
-
-  def create(saved_query_name, saved_query_body)
-    response = Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).put(
-      path: "#{saved_query_base_url}/#{saved_query_name}",
-      headers: api_headers(client.master_key, "sync"),
-      body: saved_query_body
-    )
-    process_response(response)
-  end
-  alias_method :update, :create
-
-  def delete(saved_query_name)
-    response = Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).delete(
-      path: "#{saved_query_base_url}/#{saved_query_name}",
-      headers: api_headers(client.master_key, "sync")
-    )
-    process_response(response)
-  end
-
-  private
-
-  attr_reader :client
-
-  def saved_query_response(api_key, path = "")
-    Keen::HTTP::Sync.new(client.api_url, client.proxy_url, client.read_timeout, client.open_timeout).get(
-      path: saved_query_base_url + path,
-      headers: api_headers(api_key, "sync")
-    )
-  end
-
-  def saved_query_base_url
-    "/#{client.api_version}/projects/#{client.project_id}/queries/saved"
-  end
-
-  def api_headers(authorization, sync_type)
-    user_agent = "keen-gem, v#{Keen::VERSION}, #{sync_type}"
-    user_agent += ", #{RUBY_VERSION}, #{RUBY_PLATFORM}, #{RUBY_PATCHLEVEL}"
-    if defined?(RUBY_ENGINE)
-      user_agent += ", #{RUBY_ENGINE}"
-    end
-    { "Content-Type" => "application/json",
-      "User-Agent" => user_agent,
-      "Authorization" => authorization,
-      "Keen-Sdk" => "ruby-#{Keen::VERSION}" }
-  end
-
-  def process_response(response)
-    case response.code.to_i
-    when 204
-      true
-    when 200..299
-      JSON.parse(response.body, symbolize_names: true)
-    when 400
-      raise Keen::BadRequestError.new(response.body)
-    when 401
-      raise Keen::AuthenticationError.new(response.body)
-    when 404
-      raise Keen::NotFoundError.new(response.body)
-    else
-      raise Keen::HttpError.new(response.body)
-    end
-  end
-end