sleek 0.0.1 → 0.0.2

data/lib/sleek/version.rb

@@ -1,3 +1,3 @@
 module Sleek
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/spec/lib/sleek/event_spec.rb

@@ -3,18 +3,18 @@ require 'spec_helper'
 describe Sleek::Event do
   describe ".create_with_namespace" do
     it "creates event record" do
-      expect { Sleek::Event.create_with_namespace(:default, "signups", { name: 'John Doe', email: 'john@doe.com' }) }.to change { Sleek::Event.count }.by(1)
+      expect { described_class.create_with_namespace(:default, "signups", { name: 'John Doe', email: 'john@doe.com' }) }.to change { Sleek::Event.count }.by(1)
     end
 
     it "sets namespace and bucket" do
-      evt = Sleek::Event.create_with_namespace(:default, "signups", {})
+      evt = described_class.create_with_namespace(:default, "signups", {})
       expect(evt.namespace).to eq :default
       expect(evt.bucket).to eq "signups"
     end
 
     it "sets the data" do
       data = { name: 'John Doe', email: 'j@d.com' }
-      evt = Sleek::Event.create_with_namespace(:ns, "buc", data)
+      evt = described_class.create_with_namespace(:ns, "buc", data)
       expect(evt.data).to eq data
     end
   end

data/spec/lib/sleek/filter_spec.rb

@@ -4,20 +4,20 @@ describe Sleek::Filter do
   describe "#initialize" do
     context "when valid operator is passed" do
       it "does not raise an exception" do
-        expect { Sleek::Filter.new(:test, :eq, 1) }.to_not raise_exception ArgumentError
+        expect { described_class.new(:test, :eq, 1) }.to_not raise_exception ArgumentError
       end
     end
 
     context "when invalid operator is passed" do
       it "raises an exception" do
-        expect { Sleek::Filter.new(:test, :lol, 1) }.to raise_exception ArgumentError, "unsupported operator - lol"
+        expect { described_class.new(:test, :lol, 1) }.to raise_exception ArgumentError, "unsupported operator - lol"
       end
     end
   end
 
   describe "#apply" do
     it "appleis the filter to the criteria" do
-      filter = Sleek::Filter.new(:test, :eq, 1)
+      filter = described_class.new(:test, :eq, 1)
       criteria = stub('criteria')
       criteria.should_receive(:eq).with("d.test" => 1)
       filter.apply(criteria)

data/spec/lib/sleek/group_by_criteria_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Sleek::GroupByCriteria do
+  let(:collection) { mock('collection', aggregate: []) }
+  let(:criteria) { mock('criteria', collection: collection) }
+  let(:group_by) { "d.field" }
+  let(:db_group) { "$d.field" }
+  subject(:crit) { described_class.new(criteria, group_by) }
+
+  describe "#aggregates" do
+    it "makes up the pipeline" do
+      crit.should_receive(:aggregates_pipeline).with(:some_field, false)
+
+      crit.aggregates(:some_field, false)
+    end
+
+    it "aggregates on the collection" do
+      pipeline = double('pipeline')
+      result_a = double('result_a')
+      result = double('result', to_a: result_a)
+      crit.stub(:aggregates_pipeline).and_return(pipeline)
+      collection.should_receive(:aggregate).with(pipeline).and_return(result)
+
+      expect(crit.aggregates(:some_field, false)).to eq result_a
+    end
+  end
+
+  describe "#aggregates_prop" do
+    it "aggregates on the collection" do
+      crit.should_receive(:aggregates).with(:some_field, false).and_return([])
+      crit.aggregates_prop(:some_field, "count", false)
+    end
+
+    it "maps the result" do
+      crit.stub(:aggregates).and_return([{"_id" => :a, "count" => 1}, {"_id" => :b, "count" => 4}])
+      expect(crit.aggregates_prop(:some_field, "count", false)).to eq({ a: 1, b: 4 })
+    end
+  end
+
+  describe "#aggregates_pipeline" do
+    let(:new_criteria) { stub('new_criteria') }
+    let(:selector) { stub('selector') }
+
+    context "when not aggregating on specific field" do
+      let(:pipeline) { crit.aggregates_pipeline }
+
+      before do
+        criteria.should_receive(:ne).with(group_by => nil).and_return(new_criteria)
+        new_criteria.should_receive(:selector).and_return(selector)
+      end
+
+      it "adds group_by_field != nil to criteria and matches the criteria" do
+        expect(pipeline.first).to eq "$match" => selector
+      end
+
+      it "groups with count" do
+        expect(pipeline.last).to eq "$group" => { "_id" => db_group, "count" => { "$sum" => 1 } }
+      end
+
+      it "has only two operators" do
+        expect(pipeline).to have(2).items
+      end
+    end
+
+    context "when aggregating on specific field" do
+      let(:field) { "d.property" }
+      let(:db_field) { "$d.property" }
+      let(:new_criteria2) { stub('new_criteria2') }
+
+      before do
+        criteria.should_receive(:ne).with(field => nil).and_return(new_criteria)
+        new_criteria.should_receive(:ne).with(group_by => nil).and_return(new_criteria2)
+        new_criteria2.should_receive(:selector).and_return(selector)
+      end
+
+      context "when not including unique counter" do
+        let(:pipeline) { crit.aggregates_pipeline(field) }
+
+        it "adds group_by_field != nil and field != nil to criteria and matches the criteria" do
+          expect(pipeline.first).to eq "$match" => selector
+        end
+
+        it "groups with count, min, max, sum, avg" do
+          expect(pipeline.last).to eq "$group" => {
+            "_id" => db_group, 
+            "count" => { "$sum" => 1 },
+            "max" => { "$max" => db_field },
+            "min" => { "$min" => db_field },
+            "sum" => { "$sum" => db_field },
+            "avg" => { "$avg" => db_field }
+          }
+        end
+
+        it "has 2 operators" do
+          expect(pipeline).to have(2).items
+        end
+      end
+
+      context "when including unique counter" do
+        let(:pipeline) { crit.aggregates_pipeline(field, true) }
+
+        it "adds group_by_field != nil and field != nil to criteria and matches the criteria" do
+          expect(pipeline.first).to eq "$match" => selector
+        end
+
+        it "groups with count, min, max, sum, avg" do
+          expect(pipeline[1]).to eq "$group" => {
+            "_id" => db_group, 
+            "count" => { "$sum" => 1 },
+            "max" => { "$max" => db_field },
+            "min" => { "$min" => db_field },
+            "sum" => { "$sum" => db_field },
+            "avg" => { "$avg" => db_field },
+            "unique_set" => { "$addToSet" => db_field }
+          }
+        end
+
+        it "unwinds the set of unique values" do
+          expect(pipeline[2]).to eq "$unwind" => "$unique_set"
+        end
+
+        it "groups aggregates back and counts unique values" do
+          expect(pipeline.last).to eq "$group" => {
+            "_id" => "$_id",
+            "count_unique" => { "$sum" => 1 },
+            "count" => { "$first" => "count" },
+            "max" => { "$first" => "max" },
+            "min" => { "$first" => "min" },
+            "avg" => { "$first" => "avg" }
+          }
+        end
+
+        it "has 4 operators" do
+          expect(pipeline).to have(4).items
+        end
+      end
+    end
+  end
+end

data/spec/lib/sleek/interval_spec.rb

@@ -3,20 +3,21 @@ require 'spec_helper'
 describe Sleek::Interval do
   describe "#initialize" do
     it "transforms interval description into value" do
-      Sleek::Interval.should_receive(:interval_value).with(:hourly)
-      Sleek::Interval.new(:hourly, Sleek::Timeframe.new(Time.now.all_day))
+      described_class.should_receive(:interval_value).with(:hourly)
+      described_class.new(:hourly, Time.now.all_day)
     end
   end
 
   describe "#timeframes" do
     it "slices timeframe into interval-long timeframes" do
-      bd = Time.now.beginning_of_day
-      interval = Sleek::Interval.new(:hourly, Sleek::Timeframe.new(Time.now.all_day))
+      now = ActiveSupport::TimeZone.new('UTC').now
+      bd = now.beginning_of_day
+      interval = described_class.new(:hourly, now.all_day)
       expect(interval.timeframes.count).to eq 23
 
       23.times do |i|
         subtf = interval.timeframes[i]
-        expect(subtf.start).to eq bd + 1.hour * i
+        expect(subtf.begin).to eq bd + 1.hour * i
         expect(subtf.end).to eq bd + 1.hour * (i + 1)
       end
     end

data/spec/lib/sleek/{base_spec.rb → namespace_spec.rb}

@@ -1,30 +1,37 @@
 require 'spec_helper'
 
-describe Sleek::Base do
-  subject(:sleek) { Sleek::Base.new(:default) }
+describe Sleek::Namespace do
+  subject(:sleek) { described_class.new(:default) }
 
   describe "#initialize" do
     it "sets the namespace" do
-      sleek = Sleek::Base.new(:my_namespace)
-      expect(sleek.namespace).to eq :my_namespace
+      sleek = described_class.new(:my_namespace)
+      expect(sleek.name).to eq :my_namespace
     end
   end
 
   describe "#record" do
     it "creates an event record" do
       data = { name: 'John Doe', email: 'j@d.com' }
-
       Sleek::Event.should_receive(:create_with_namespace).with(:default, "signups", data)
-
       sleek.record("signups", data)
     end
   end
 
   describe "#queries" do
     it "returns QueryCollection for current namespace" do
-      Sleek::QueryCollection.should_receive(:new).with(:default).and_call_original
+      Sleek::QueryCollection.should_receive(:new).with(sleek).and_call_original
       qc = sleek.queries
-      expect(qc.namespace).to eq :default
+      expect(qc.namespace).to eq sleek
+    end
+  end
+
+  describe "#delete!" do
+    it "deletes everything from the namespace" do
+      events = stub('events')
+      sleek.should_receive(:events).and_return(events)
+      events.should_receive(:delete_all)
+      sleek.delete!
     end
   end
 

data/spec/lib/sleek/queries/average_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Sleek::Queries::Average do
-  subject(:query) { Sleek::Queries::Average.new(:default, :purchases, target_property: "total") }
+  subject(:query) { described_class.new(:default, :purchases, target_property: "total") }
 
   describe "#perform" do
     it "counts the events" do

data/spec/lib/sleek/queries/count_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Sleek::Queries::Count do
-  subject(:query) { Sleek::Queries::Count.new(:default, :purchases) }
+  subject(:query) { described_class.new(:default, :purchases) }
 
   describe "#perform" do
     it "counts the events" do

data/spec/lib/sleek/queries/count_unique_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Sleek::Queries::CountUnique do
-  subject(:query) { Sleek::Queries::CountUnique.new(:default, :purchases, target_property: "customer.id") }
+  subject(:query) { described_class.new(:default, :purchases, target_property: "customer.id") }
 
   describe "#perform" do
     it "counts the events" do

data/spec/lib/sleek/queries/maximum_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Sleek::Queries::Maximum do
-  subject(:query) { Sleek::Queries::Maximum.new(:default, :purchases, target_property: "total") }
+  subject(:query) { described_class.new(:default, :purchases, target_property: "total") }
 
   describe "#perform" do
     it "counts the events" do

data/spec/lib/sleek/queries/minimum_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Sleek::Queries::Minimum do
-  subject(:query) { Sleek::Queries::Minimum.new(:default, :purchases, target_property: "total") }
+  subject(:query) { described_class.new(:default, :purchases, target_property: "total") }
 
   describe "#perform" do
     it "counts the events" do

data/spec/lib/sleek/queries/query_spec.rb

@@ -1,13 +1,22 @@
 require 'spec_helper'
 
 describe Sleek::Queries::Query do
-  let(:query_class) { Sleek::Queries::Query }
-  subject(:query) { query_class.new(:default, :purchases) }
+  let(:query_class) { described_class }
+  let(:namespace) { mock('namespace', name: :default) }
+  subject(:query) { query_class.new(namespace, :purchases) }
+
+  describe ".require_target_property!" do
+    it "sets a flag indicating target property is required by the query" do
+      klass = Class.new(query_class)
+      expect { klass.require_target_property! }.to change { klass.require_target_property? }.from(false).to(true)
+    end
+  end
 
   describe "#initialize" do
     it "sets the namespace and bucket" do
-      query = Sleek::Queries::Query.new(:my_namespace, :purchases)
-      expect(query.namespace).to eq :my_namespace
+      my_namespace = double('my_namespace', name: :my_namespace)
+      query = described_class.new(my_namespace, :purchases)
+      expect(query.namespace).to eq my_namespace
       expect(query.bucket).to eq :purchases
     end
 
@@ -29,10 +38,34 @@ describe Sleek::Queries::Query do
   end
 
   describe "#events" do
+    let(:evts) { double('events') }
+
+    context "when group_by is specified" do
+      before { query.stub(options: { group_by: "group" }) }
+
+      it "creates a group_by criteria from Mongoid::Criteria" do
+        namespace.should_receive(:events).and_return(evts)
+        Sleek::GroupByCriteria.should_receive(:new).with(evts, "d.group")
+
+        query.events
+      end
+
+      it "returns a group_by criteria" do
+        namespace.stub(events: evts)
+
+        crit = query.events
+
+        expect(crit.class).to eq Sleek::GroupByCriteria
+        expect(crit.criteria).to eq evts
+        expect(crit.group_by).to eq "d.group"
+      end
+    end
+
     context "when no timeframe is specifies" do
       context "when no filter is specified" do
         it "returns events in current namespace and bucket" do
-          Sleek::Event.should_receive(:where).with(namespace: :default, bucket: :purchases)
+          namespace.stub(events: evts)
+          namespace.should_receive(:events).with(:purchases)
           query.events
         end
       end
@@ -42,6 +75,7 @@ describe Sleek::Queries::Query do
 
         it "applies filters" do
           final = stub('final_criteria')
+          namespace.stub(events: evts)
           query.should_receive(:apply_filters).and_return(final)
           expect(query.events).to eq final
         end
@@ -51,12 +85,12 @@ describe Sleek::Queries::Query do
     context "when timeframe is specified" do
       let(:start) { 1.day.ago }
       let(:finish) { Time.now }
-      before { query.stub(:time_range).and_return(start..finish) }
+      before { query.stub(:timeframe).and_return(start..finish) }
 
       context "when no filter is specified" do
         it "gets only events between timeframe ends" do
           pre_evts = stub('pre_events')
-          Sleek::Event.should_receive(:where).with(namespace: :default, bucket: :purchases).and_return(pre_evts)
+          namespace.should_receive(:events).with(:purchases).and_return(pre_evts)
           pre_evts.should_receive(:between).with("s.t" => start..finish)
           query.events
         end
@@ -69,7 +103,7 @@ describe Sleek::Queries::Query do
           pre_evts = stub('pre_events')
           criteria = stub('criteria')
           final = stub('final_criteria')
-          Sleek::Event.should_receive(:where).with(namespace: :default, bucket: :purchases).and_return(pre_evts)
+          namespace.should_receive(:events).with(:purchases).and_return(pre_evts)
           pre_evts.should_receive(:between).and_return(criteria)
           query.should_receive(:apply_filters).with(criteria).and_return(final)
           expect(query.events).to eq final
@@ -120,35 +154,9 @@ describe Sleek::Queries::Query do
     end
   end
 
-  describe "#timeframe" do
-    context "when timeframe is specified" do
-      let(:tf) { stub('timeframe') }
-      before { query.stub(options: { timeframe: tf }) }
-
-      it "creates new timeframe instance" do
-        Sleek::Timeframe.should_receive(:new).with(tf)
-        query.timeframe
-      end
-    end
-  end
-
-  describe "#series" do
-    context "when timeframe and interval are specified" do
-      let(:tf) { stub('timeframe') }
-      before { query.stub(options: { timeframe: 'this_day', interval: :hourly }, timeframe: tf) }
-
-      it "splits timeframe into intervals of sub-timeframes" do
-        interval = stub('interval')
-        Sleek::Interval.should_receive(:new).with(:hourly, tf).and_return(interval)
-        interval.should_receive(:timeframes)
-        query.series
-      end
-    end
-  end
-
   describe "#valid_options?" do
     context "when options is a hash" do
-      context "when no interval is passed" do
+      context "when target property is not required" do
         before { query.stub(options: {}) }
 
         it "is true" do
@@ -156,25 +164,22 @@ describe Sleek::Queries::Query do
         end
       end
 
-      context "when interval is passed" do
-        context "when timeframe is passed" do
-          before { query.stub(options: { interval: :hourly, timeframe: Time.now.all_day }) }
+      context "when target property is required" do
+        before { query.stub(require_target_property?: true) }
 
-          it "is true" do
-            expect(query.valid_options?).to be_true
-          end
+        it "is true if target property is specified" do
+          query.stub(options: { target_property: "total" })
+          expect(query.valid_options?).to be_true
         end
 
-        context "when timeframe is not passed" do
-          before { query.stub(options: { interval: :hourly }) }
-          it "is false" do
-            expect(query.valid_options?).to be_false
-          end
+        it "is false if target property is not specified" do
+          query.stub(options: {})
+          expect(query.valid_options?).to be_false
         end
       end
     end
 
-    context "when options isn't a hash" do
+    context "when options is not a hash" do
       before { query.stub(options: 1) }
 
       it "is false" do
@@ -184,43 +189,12 @@ describe Sleek::Queries::Query do
   end
 
   describe "#run" do
-    context "when no series were requested" do
-      it "performs query on events" do
-        events = stub
-        result = stub
-        query.should_receive(:perform).with(events).and_return(result)
-        query.stub(events: events)
-        query.run
-      end
-    end
-
-    context "when series were requested" do
-      let(:series) { (0..23).to_a.map { |i| stub(to_time_range: (i..(i+1))) } }
-      before { query.stub(options: { timeframe: 'this_day', interval: :hourly }, series: series) }
-
-      it "performs query on each of sub-timeframes" do
-        24.times do |i|
-          evts = stub('events')
-          query.should_receive(:events).with(i..(i+1)).and_return(evts)
-          query.should_receive(:perform).with(evts)
-        end
-
-        query.run
-      end
-
-      it "returns the array of results" do
-        results = []
-
-        24.times do |i|
-          evts = stub('events')
-          value = stub('value')
-          results << { timeframe: series[i], value: value }
-          query.should_receive(:events).with(i..(i+1)).and_return(evts)
-          query.should_receive(:perform).with(evts).and_return(value)
-        end
-
-        expect(query.run).to eq results
-      end
+    it "performs query on events" do
+      events = double('events')
+      result = double('result')
+      query.should_receive(:perform).with(events).and_return(result)
+      query.stub(events: events)
+      query.run
     end
   end
 end