keen 0.5.0 → 0.6.0

data/lib/keen/http.rb

@@ -12,6 +12,12 @@ module Keen
           :path, :headers, :body)
         @http.post(path, body, headers)
       end
+
+      def get(options)
+        path, headers = options.values_at(
+          :path, :headers)
+        @http.get(path, headers)
+      end
     end
 
     class Async

data/lib/keen/version.rb

@@ -1,3 +1,3 @@
 module Keen
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/spec/integration/api_spec.rb

@@ -3,51 +3,129 @@ require File.expand_path("../spec_helper", __FILE__)
 describe "Keen IO API" do
   let(:project_id) { ENV['KEEN_PROJECT_ID'] }
 
-  let(:collection) { "users" }
-  let(:event_properties) { { "name" => "Bob" } }
-  let(:api_success) { { "created" => true } }
+  describe "publishing" do
+    let(:collection) { "users" }
+    let(:event_properties) { { "name" => "Bob" } }
+    let(:api_success) { { "created" => true } }
 
-  describe "success" do
-
-    it "should return a created status for a valid post" do
-      Keen.publish(collection, event_properties).should == api_success
+    describe "success" do
+      it "should return a created status for a valid post" do
+        Keen.publish(collection, event_properties).should == api_success
+      end
     end
-  end
 
-  describe "failure" do
-    it "should raise a not found error if an invalid project id" do
-      client = Keen::Client.new(:project_id => "riker")
-      expect {
-        client.publish(collection, event_properties)
-      }.to raise_error(Keen::NotFoundError)
-    end
+    describe "failure" do
+      it "should raise a not found error if an invalid project id" do
+        client = Keen::Client.new(:project_id => "riker")
+        expect {
+          client.publish(collection, event_properties)
+        }.to raise_error(Keen::NotFoundError)
+      end
 
-    it "should success if a non-url-safe event collection is specified" do
-      Keen.publish("infinite possibilities", event_properties).should == api_success
+      it "should succeed if a non-url-safe event collection is specified" do
+        Keen.publish("infinite possibilities", event_properties).should == api_success
+      end
     end
-  end
 
-  describe "async" do
-    # no TLS support in EventMachine on jRuby
-    unless defined?(JRUBY_VERSION)
+    describe "async" do
+      # no TLS support in EventMachine on jRuby
+      unless defined?(JRUBY_VERSION)
 
-      it "should publish the event and trigger callbacks" do
-        EM.run {
-          Keen.publish_async(collection, event_properties).callback { |response|
-            response.should == api_success
-            EM.stop
+        it "should publish the event and trigger callbacks" do
+          EM.run {
+            Keen.publish_async(collection, event_properties).callback { |response|
+              response.should == api_success
+              EM.stop
+            }
           }
-        }
-      end
+        end
 
-      it "should publish to non-url-safe collections" do
-        EM.run {
-          Keen.publish_async("foo bar", event_properties).callback { |response|
-            response.should == api_success
-            EM.stop
+        it "should publish to non-url-safe collections" do
+          EM.run {
+            Keen.publish_async("foo bar", event_properties).callback { |response|
+              response.should == api_success
+              EM.stop
+            }
           }
-        }
+        end
       end
     end
   end
+
+  describe "queries" do
+    let(:api_key) { ENV['KEEN_API_KEY'] }
+    let(:event_collection) { "purchases_" + rand(100000).to_s }
+    let(:returns_event_collection) { "returns_" + rand(100000).to_s }
+
+    before(:all) do
+      Keen.publish(event_collection, {
+        :username => "bob",
+        :price => 10
+      })
+      Keen.publish(event_collection, {
+        :username => "ted",
+        :price => 20
+      })
+      Keen.publish(returns_event_collection, {
+        :username => "bob",
+        :price => 30
+      })
+      sleep(1)
+    end
+
+    it "should return a valid count" do
+      Keen.count(event_collection).should == 2
+    end
+
+    it "should return a valid count_unique" do
+      Keen.count_unique(event_collection, :target_property => "price").should == 2
+    end
+
+    it "should return a valid sum" do
+      Keen.sum(event_collection, :target_property => "price").should == 30
+    end
+
+    it "should return a valid minimum" do
+      Keen.minimum(event_collection, :target_property => "price").should == 10
+    end
+
+    it "should return a valid maximum" do
+      Keen.maximum(event_collection, :target_property => "price").should == 20
+    end
+
+    it "should return a valid average" do
+      Keen.average(event_collection, :target_property => "price").should == 15
+    end
+
+    it "should return a valid select_unique" do
+      results = Keen.select_unique(event_collection, :target_property => "price")
+      results.sort.should == [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
+    end
+
+    it "should return a valid funnel" do
+      steps = [{
+        :event_collection => event_collection,
+        :actor_property => "username"
+      }, {
+        :event_collection => returns_event_collection,
+        :actor_property => "username"
+      }]
+      results = Keen.funnel(:steps => steps)
+      results.should == [2, 1]
+    end
+
+    it "should apply filters" do
+      Keen.count(event_collection, :filters => [{
+        :property_name => "username",
+        :operator => "eq",
+        :property_value => "ted"
+      }]).should == 1
+    end
+  end
 end

data/spec/keen/client/publishing_methods_spec.rb

@@ -0,0 +1,161 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Keen::Client::PublishingMethods do
+  let(:project_id) { "12345" }
+  let(:api_host) { "api.keen.io" }
+  let(:collection) { "users" }
+  let(:event_properties) { { "name" => "Bob" } }
+  let(:api_success) { { "created" => true } }
+  let(:client) { Keen::Client.new(:project_id => project_id) }
+
+  describe "publish" do
+    it "should post using the collection and properties" do
+      stub_keen_post(api_event_resource_url(collection), 201, "")
+      client.publish(collection, event_properties)
+      expect_keen_post(api_event_resource_url(collection), event_properties, "sync")
+    end
+
+    it "should return the proper response" do
+      api_response = { "created" => true }
+      stub_keen_post(api_event_resource_url(collection), 201, api_response)
+      client.publish(collection, event_properties).should == api_response
+    end
+
+    it "should raise an argument error if no event collection is specified" do
+      expect {
+        client.publish(nil, {})
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should raise an argument error if no properties are specified" do
+      expect {
+        client.publish(collection, nil)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should url encode the event collection" do
+      stub_keen_post(api_event_resource_url("foo%20bar"), 201, "")
+      client.publish("foo bar", event_properties)
+      expect_keen_post(api_event_resource_url("foo%20bar"), event_properties, "sync")
+    end
+
+    it "should wrap exceptions" do
+      stub_request(:post, api_event_resource_url(collection)).to_timeout
+      e = nil
+      begin
+        client.publish(collection, event_properties)
+      rescue Exception => exception
+        e = exception
+      end
+
+      e.class.should == Keen::HttpError
+      e.original_error.class.should == Timeout::Error
+      e.message.should == "Couldn't connect to Keen IO: execution expired"
+    end
+
+    it "should raise an exception if client has no project_id" do
+      expect {
+        Keen::Client.new.publish(collection, event_properties)
+      }.to raise_error(Keen::ConfigurationError)
+    end
+  end
+
+  describe "publish_async" do
+    # no TLS support in EventMachine on jRuby
+    unless defined?(JRUBY_VERSION)
+      it "should require a running event loop" do
+        expect {
+          client.publish_async(collection, event_properties)
+        }.to raise_error(Keen::Error)
+      end
+
+      it "should post the event data" do
+        stub_keen_post(api_event_resource_url(collection), 201, api_success)
+        EM.run {
+          client.publish_async(collection, event_properties).callback {
+            begin
+              expect_keen_post(api_event_resource_url(collection), event_properties, "async")
+            ensure
+              EM.stop
+            end
+          }
+        }
+      end
+
+      it "should uri encode the event collection" do
+        stub_keen_post(api_event_resource_url("foo%20bar"), 201, api_success)
+        EM.run {
+          client.publish_async("foo bar", event_properties).callback {
+            begin
+              expect_post(api_event_resource_url("foo%20bar"), event_properties, "async")
+            ensure
+              EM.stop
+            end
+          }
+        }
+      end
+
+      it "should raise an argument error if no event collection is specified" do
+        expect {
+          client.publish_async(nil, {})
+        }.to raise_error(ArgumentError)
+      end
+
+      it "should raise an argument error if no properties are specified" do
+        expect {
+          client.publish_async(collection, nil)
+        }.to raise_error(ArgumentError)
+      end
+
+      describe "deferrable callbacks" do
+        it "should trigger callbacks" do
+          stub_keen_post(api_event_resource_url(collection), 201, api_success)
+          EM.run {
+            client.publish_async(collection, event_properties).callback { |response|
+              begin
+                response.should == api_success
+              ensure
+                EM.stop
+              end
+            }
+          }
+        end
+
+        it "should trigger errbacks" do
+          stub_request(:post, api_event_resource_url(collection)).to_timeout
+          EM.run {
+            client.publish_async(collection, event_properties).errback { |error|
+              begin
+                error.should_not be_nil
+                error.message.should == "Couldn't connect to Keen IO: WebMock timeout error"
+              ensure
+                EM.stop
+              end
+            }
+          }
+        end
+      end
+    end
+  end
+
+  it "should raise an exception if client has no project_id" do
+    expect {
+      Keen::Client.new.publish_async(collection, event_properties)
+    }.to raise_error(Keen::ConfigurationError)
+  end
+
+  describe "#add_event" do
+    it "should alias to publish" do
+      client.should_receive(:publish).with("users", {:a => 1}, {:b => 2})
+      client.add_event("users", {:a => 1}, {:b => 2})
+    end
+  end
+
+  describe "beacon_url" do
+    it "should return a url with a base-64 encoded json param" do
+      client = Keen::Client.new(project_id)
+      client.beacon_url("sign_ups", { :name => "Bob" }).should ==
+        "https://api.keen.io/3.0/projects/12345/events/sign_ups?data=eyJuYW1lIjoiQm9iIn0="
+    end
+  end
+end

data/spec/keen/client/querying_methods_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Keen::Client do
+  let(:project_id) { "12345" }
+  let(:api_key) { "abcde" }
+  let(:api_host) { "api.keen.io" }
+  let(:api_version) { "3.0" }
+  let(:event_collection) { "users" }
+  let(:client) { Keen::Client.new(:project_id => project_id, :api_key => api_key) }
+
+  def query_url(query_name, query_params)
+    "https://#{api_host}/#{api_version}/projects/#{project_id}/queries/#{query_name}#{query_params}"
+  end
+
+  describe "querying names" do
+    let(:params) { { :event_collection => "signups" } }
+
+    ["minimum", "maximum", "sum", "average", "count", "count_unique", "select_unique", "extraction"].each do |query_name|
+      it "should call keen query passing the query name" do
+        client.should_receive(:query).with(query_name.to_sym, event_collection, params)
+        client.send(query_name, event_collection, params)
+      end
+    end
+
+    describe "funnel" do
+      it "should call keen query w/o event collection" do
+        client.should_receive(:query).with(:funnel, nil, params)
+        client.funnel(params)
+      end
+    end
+  end
+
+  describe "#query" do
+    describe "with an improperly configured client" do
+      it "should require a project id" do
+        expect {
+          Keen::Client.new(:api_key => api_key).count("users", {})
+        }.to raise_error(Keen::ConfigurationError)
+      end
+
+      it "should require an api key" do
+        expect {
+          Keen::Client.new(:project_id => project_id).count("users", {})
+        }.to raise_error(Keen::ConfigurationError)
+      end
+    end
+
+    describe "with a valid client" do
+      let(:query) { client.method(:query) }
+      let(:query_name) { "count" }
+      let(:api_response) { { "result" => 1 } }
+
+      def test_query(extra_query_params="", extra_query_hash={})
+        expected_query_params = "?api_key=#{api_key}&event_collection=#{event_collection}"
+        expected_query_params += extra_query_params
+        expected_url = query_url(query_name, expected_query_params)
+        stub_keen_get(expected_url, 200, :result => 1)
+        response = query.call(query_name, event_collection, extra_query_hash)
+        response.should == api_response["result"]
+        expect_keen_get(expected_url, "sync")
+      end
+
+      it "should call the API w/ proper headers and return the processed json response" do
+        test_query
+      end
+
+      it "should encode filters properly" do
+        filters = [{
+          :property_name => "animal",
+          :operator => "eq",
+          :property_value => "dogs"
+        }]
+        filter_str = MultiJson.encode(filters)
+        test_query("&filters=#{filter_str}", :filters => filters)
+      end
+
+      it "should encode absolute timeframes properly" do
+        timeframe = {
+          :start => "2012-08-13T19:00Z",
+          :end => "2012-08-13T19:00Z",
+        }
+        timeframe_str = MultiJson.encode(timeframe)
+        test_query("&timeframe=#{timeframe_str}", :timeframe => timeframe)
+      end
+
+      it "should encode steps properly" do
+        steps = [{
+          :event_collection => "signups",
+          :actor_property => "user.id"
+        }]
+        steps_str = MultiJson.encode(steps)
+        test_query("&steps=#{steps_str}", :steps => steps)
+      end
+
+      it "should not encode relative timeframes" do
+        timeframe = "last_10_days"
+        test_query("&timeframe=#{timeframe}", :timeframe => timeframe)
+      end
+
+      it "should raise a failed responses" do
+        query_params = "?api_key=#{api_key}&event_collection=#{event_collection}"
+        url = query_url(query_name, query_params)
+
+        stub_keen_get(url, 401, :error => {})
+        expect {
+          query.call(query_name, event_collection, {})
+        }.to raise_error(Keen::AuthenticationError)
+        expect_keen_get(url, "sync")
+      end
+    end
+  end
+
+  describe "#count" do
+    it "should not require params" do
+      query_params = "?api_key=#{api_key}&event_collection=#{event_collection}"
+      url = query_url("count", query_params)
+      stub_keen_get(url, 200, :result => 10)
+      client.count(event_collection).should == 10
+      expect_keen_get(url, "sync")
+    end
+  end
+
+  describe "#extraction" do
+    it "should not require params" do
+      query_params = "?api_key=#{api_key}&event_collection=#{event_collection}"
+      url = query_url("extraction", query_params)
+      stub_keen_get(url, 200, :result => { "a" => 1 } )
+      client.extraction(event_collection).should == { "a" => 1 }
+      expect_keen_get(url, "sync")
+    end
+  end
+end