sleek 0.0.1

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

@@ -0,0 +1,226 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Query do
+  let(:query_class) { Sleek::Queries::Query }
+  subject(:query) { query_class.new(:default, :purchases) }
+
+  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
+      expect(query.bucket).to eq :purchases
+    end
+
+    context "when options are valid" do
+      before { query_class.any_instance.stub(valid_options?: true) }
+
+      it "does not raise ArgumerError" do
+        expect { query_class.new(:d, :p) }.to_not raise_exception ArgumentError
+      end
+    end
+
+    context "when options are invalid" do
+      before { query_class.any_instance.stub(valid_options?: false) }
+
+      it "raises ArgumentError" do
+        expect { query_class.new(:d, :p) }.to raise_exception ArgumentError, "options are invalid"
+      end
+    end
+  end
+
+  describe "#events" do
+    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)
+          query.events
+        end
+      end
+
+      context "when filter is specified" do
+        before { query.stub(filter?: true) }
+
+        it "applies filters" do
+          final = stub('final_criteria')
+          query.should_receive(:apply_filters).and_return(final)
+          expect(query.events).to eq final
+        end
+      end
+    end
+
+    context "when timeframe is specified" do
+      let(:start) { 1.day.ago }
+      let(:finish) { Time.now }
+      before { query.stub(:time_range).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)
+          pre_evts.should_receive(:between).with("s.t" => start..finish)
+          query.events
+        end
+      end
+
+      context "when filter is specified" do
+        before { query.stub(filter?: true) }
+
+        it "applies filters" 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)
+          pre_evts.should_receive(:between).and_return(criteria)
+          query.should_receive(:apply_filters).with(criteria).and_return(final)
+          expect(query.events).to eq final
+        end
+      end
+    end
+  end
+
+  describe "#apply_filters" do
+    it "applies every filter to criteria" do
+      filters = [Sleek::Filter.new(:test, :gt, 1), Sleek::Filter.new(:test, :lt, 100)]
+      query.stub(filter?: true, filters: filters)
+      criteria = stub('criteria')
+      criteria2 = stub('criteria2')
+      final = stub('final_criteria')
+      criteria.should_receive(:gt).with("d.test" => 1).and_return(criteria2)
+      criteria2.should_receive(:lt).with("d.test" => 100).and_return(final)
+
+      expect(query.apply_filters(criteria)).to eq final
+    end
+  end
+
+  describe "#filters" do
+    context "when filters are specified" do
+      context "when proper single filter" do
+        before { query.stub(options: { filter: [:test, :gt, 1] }) }
+
+        it "returns an one-element array with Filter" do
+          expect(query.filters).to eq [Sleek::Filter.new(:test, :gt, 1)]
+        end
+      end
+
+      context "when proper multiple filters" do
+        before { query.stub(options: { filter: [[:test, :gt, 1], [:test, :lt, 100]] }) }
+
+        it "returns multiple-element array with Filters" do
+          expect(query.filters).to eq [Sleek::Filter.new(:test, :gt, 1), Sleek::Filter.new(:test, :lt, 100)]
+        end
+      end
+
+      context "when malformed filter" do
+        before { query.stub(options: { filter: :mwahaha }) }
+
+        it "raises an exception" do
+          expect { query.filters }.to raise_exception ArgumentError, "wrong filter - mwahaha"
+        end
+      end
+    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
+        before { query.stub(options: {}) }
+
+        it "is true" do
+          expect(query.valid_options?).to be_true
+        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 }) }
+
+          it "is true" do
+            expect(query.valid_options?).to be_true
+          end
+        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
+        end
+      end
+    end
+
+    context "when options isn't a hash" do
+      before { query.stub(options: 1) }
+
+      it "is false" do
+        expect(query.valid_options?).to be_false
+      end
+    end
+  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
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Sum do
+  subject(:query) { Sleek::Queries::Sum.new(:default, :purchases, target_property: "total") }
+
+  describe "#perform" do
+    it "counts the events" do
+      events = stub('events')
+      events.should_receive(:sum).with("d.total").and_return(2_072_70)
+      expect(query.perform(events)).to eq 2_072_70
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Sleek::Queries::Targetable do
+  let(:query_superclass) do
+    Class.new(Struct.new(:options)) do
+      def valid_options?; true; end
+    end
+  end
+
+  let(:query_class) do
+    Class.new(query_superclass) do
+      include Sleek::Queries::Targetable
+    end
+  end
+
+  describe "validation" do
+    context "when target_property is passed" do
+      it "should pass" do
+        expect(query_class.new(target_property: :a).valid_options?).to be true
+      end
+    end
+
+    context "when target_property is not passed" do
+      it "should not pass" do
+        expect(query_class.new({}).valid_options?).to be false
+      end
+    end
+  end
+end

data/spec/lib/sleek/query_collection_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Sleek::QueryCollection do
+  subject(:collection) { Sleek::QueryCollection.new(:default) }
+
+  describe "#initialize" do
+    it "sets the namespace" do
+      collection = Sleek::QueryCollection.new(:my_namespace)
+      expect(collection.namespace).to eq :my_namespace
+    end
+  end
+
+  describe "query methods" do
+    it "creates query class and passes options" do
+      Sleek::Queries::Count.should_receive(:new).with(:default, :purchases, { some: :opts }).and_call_original
+      collection.count(:purchases, { some: :opts })
+    end
+
+    it "runs the query" do
+      count = stub('count_query')
+      Sleek::Queries::Count.should_receive(:new).and_return(count)
+      count.should_receive(:run)
+
+      collection.count(:purchases)
+    end
+  end
+end

data/spec/lib/sleek/timeframe_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Sleek::Timeframe do
+  let(:start_time) { 1.day.ago }
+  let(:end_time) { Time.now }
+  let(:range) { start_time..end_time }
+  subject(:timeframe) { Sleek::Timeframe.new(range) }
+
+  describe "#start" do
+    it "returns timeframe start" do
+      expect(timeframe.start).to eq start_time
+    end
+  end
+
+  describe "#end" do
+    it "returns timeframe end" do
+      expect(timeframe.end).to eq end_time
+    end
+  end
+
+  describe "#to_time_range" do
+    it "transforms passed timeframe to range" do
+      Sleek::Timeframe.should_receive(:to_range).with(range)
+      timeframe.to_time_range
+    end
+  end
+
+  describe ".to_range" do
+    context "when passed a range" do
+      context "when the range is of Time objects" do
+        it "returns that range" do
+          expect(Sleek::Timeframe.to_range(range)).to eq range
+        end
+      end
+
+      context "when passed other range" do
+        it "raises an exception" do
+          expect { Sleek::Timeframe.to_range(1..3) }.to raise_exception ArgumentError
+        end
+      end
+    end
+
+    context "when passed an array" do
+      context "when array has two Time elements" do
+        it "constructs the range" do
+          expect(Sleek::Timeframe.to_range([start_time, end_time])).to eq range
+        end
+      end
+
+      context "when passed other array" do
+        it "raises an exception" do
+          expect { Sleek::Timeframe.to_range([1, 2]) }.to raise_exception ArgumentError
+          expect { Sleek::Timeframe.to_range([start_time, end_time, end_time]) }.to raise_exception ArgumentError
+        end
+      end
+    end
+
+    context "when passed a string or a symbol" do
+      it "tries to parse it" do
+        range = stub('range')
+        Sleek::Timeframe.should_receive(:to_range).with('this_day').and_return range
+        expect(Sleek::Timeframe.to_range('this_day')).to eq range
+      end
+    end
+  end
+
+  describe ".parse" do
+    context "when passed the proper string" do
+      it "parses the string and returns time range" do
+        td = Sleek::Timeframe.parse('this_day')
+        expect(td.begin).to eq Time.now.beginning_of_day
+        expect(td.end).to eq Time.now.end_of_day.round
+
+        p2w = Sleek::Timeframe.parse('previous_2_weeks')
+        expect(p2w.begin).to eq Time.now.beginning_of_week - 2.weeks
+        expect(p2w.end).to eq Time.now.end_of_week.round - 1.weeks
+      end
+    end
+
+    context "when passed malformed string" do
+      it "raises an exception" do
+        expect { Sleek::Timeframe.parse('lol_wut') }.to raise_exception ArgumentError, "special timeframe string is malformed"
+      end
+    end
+  end
+end

data/spec/lib/sleek_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Sleek do
+  describe ".for_namespace" do
+    it "should return namespaced Sleek::Base instance" do
+      Sleek::Base.should_receive(:new).with(:test_ns)
+      Sleek.for_namespace(:test_ns)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'sleek'
+require 'database_cleaner'
+
+Mongoid.configure do |config|
+  config.connect_to('sleek_test', consistency: :strong)
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.orm = 'mongoid'
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: sleek
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gosha Arinich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Sleek is a library for doing analytics.
+email:
+- me@goshakkk.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/sleek.rb
+- lib/sleek/base.rb
+- lib/sleek/core_ext/range.rb
+- lib/sleek/core_ext/time.rb
+- lib/sleek/event.rb
+- lib/sleek/filter.rb
+- lib/sleek/interval.rb
+- lib/sleek/queries.rb
+- lib/sleek/queries/average.rb
+- lib/sleek/queries/count.rb
+- lib/sleek/queries/count_unique.rb
+- lib/sleek/queries/maximum.rb
+- lib/sleek/queries/minimum.rb
+- lib/sleek/queries/query.rb
+- lib/sleek/queries/sum.rb
+- lib/sleek/queries/targetable.rb
+- lib/sleek/query_collection.rb
+- lib/sleek/timeframe.rb
+- lib/sleek/version.rb
+- sleek.gemspec
+- sleek.png
+- spec/lib/sleek/base_spec.rb
+- spec/lib/sleek/event_spec.rb
+- spec/lib/sleek/filter_spec.rb
+- spec/lib/sleek/interval_spec.rb
+- spec/lib/sleek/queries/average_spec.rb
+- spec/lib/sleek/queries/count_spec.rb
+- spec/lib/sleek/queries/count_unique_spec.rb
+- spec/lib/sleek/queries/maximum_spec.rb
+- spec/lib/sleek/queries/minimum_spec.rb
+- spec/lib/sleek/queries/query_spec.rb
+- spec/lib/sleek/queries/sum_spec.rb
+- spec/lib/sleek/queries/targetable_spec.rb
+- spec/lib/sleek/query_collection_spec.rb
+- spec/lib/sleek/timeframe_spec.rb
+- spec/lib/sleek_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/goshakkk/sleek
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Sleek is a library for doing analytics.
+test_files:
+- spec/lib/sleek/base_spec.rb
+- spec/lib/sleek/event_spec.rb
+- spec/lib/sleek/filter_spec.rb
+- spec/lib/sleek/interval_spec.rb
+- spec/lib/sleek/queries/average_spec.rb
+- spec/lib/sleek/queries/count_spec.rb
+- spec/lib/sleek/queries/count_unique_spec.rb
+- spec/lib/sleek/queries/maximum_spec.rb
+- spec/lib/sleek/queries/minimum_spec.rb
+- spec/lib/sleek/queries/query_spec.rb
+- spec/lib/sleek/queries/sum_spec.rb
+- spec/lib/sleek/queries/targetable_spec.rb
+- spec/lib/sleek/query_collection_spec.rb
+- spec/lib/sleek/timeframe_spec.rb
+- spec/lib/sleek_spec.rb
+- spec/spec_helper.rb
+has_rdoc: