influxer 0.2.4 → 0.3.1

data/spec/metrics/relation_spec.rb

@@ -1,205 +1,245 @@
 require 'spec_helper'
 
-describe Influxer::Relation do
-  before do
-    allow_any_instance_of(Influxer::Client).to receive(:query) do |_, sql|
-      sql
-    end
-  end
-
+describe Influxer::Relation, :query do
   let(:rel) { Influxer::Relation.new DummyMetrics }
   let(:rel2) { Influxer::Relation.new DummyComplexMetrics }
 
-  specify { expect(rel).to respond_to :write }
-  specify { expect(rel).to respond_to :build }
-
-  # read
-  specify { expect(rel).to respond_to :select }
-  specify { expect(rel).to respond_to :where }
-  specify { expect(rel).to respond_to :limit }
-  specify { expect(rel).to respond_to :group }
+  context "instance methods" do
+    subject { rel }
 
-  # delete
-  specify { expect(rel).to respond_to :delete_all }
+    specify { is_expected.to respond_to :write }
+    specify { is_expected.to respond_to :select }
+    specify { is_expected.to respond_to :where }
+    specify { is_expected.to respond_to :limit }
+    specify { is_expected.to respond_to :group }
+    specify { is_expected.to respond_to :delete_all }
+    specify { is_expected.to respond_to :to_sql }
+  end
 
-  specify { expect(rel).to respond_to :to_sql }
+  describe "#build" do
+    specify { expect(rel.build).to be_a DummyMetrics }
+    specify { expect(rel.new).to be_a DummyMetrics }
+  end
 
   describe "#merge!" do
-    it "should merge multi values" do
+    it "merge multi values" do
       r1 = rel.where(id: [1, 2], dummy: 'qwe').time(:hour)
-      r2 = Influxer::Relation.new(DummyMetrics).where.not(user_id: 0).group(:user_id)
+      r2 = Influxer::Relation.new(DummyMetrics).where.not(user_id: 0).group(:user_id).order(user_id: :asc)
       r1.merge!(r2)
-      expect(r1.to_sql).to eq "select * from \"dummy\" group by time(1h),user_id where (id=1 or id=2) and (dummy='qwe') and (user_id<>0)"
+      expect(r1.to_sql)
+        .to eq "select * from \"dummy\" where (id=1 or id=2) and (dummy='qwe') and (user_id<>0) " \
+               "group by time(1h),user_id order by user_id asc"
     end
 
-    it "should merge single values" do
-      r1 = rel.time(:hour, fill: 0).limit(10)
-      r2 = Influxer::Relation.new(DummyMetrics).merge(:doomy).limit(5)
+    it "merge single values" do
+      r1 = rel.time(:hour, fill: 0).slimit(10)
+      r2 = Influxer::Relation.new(DummyMetrics).group(:dummy_id).offset(10).slimit(5)
       r1.merge!(r2)
-      expect(r1.to_sql).to eq "select * from \"dummy\" merge \"doomy\" group by time(1h) fill(0) limit 5"
+      expect(r1.to_sql).to eq "select * from \"dummy\" group by time(1h),dummy_id fill(0) offset 10 slimit 5"
     end
   end
 
-  describe "sql generation" do
-    describe "from clause" do
-      it "should generate valid from if no conditions" do
+  context "sql generation" do
+    describe "#from" do
+      it "generates valid from if no conditions" do
         expect(rel.to_sql).to eq "select * from \"dummy\""
       end
     end
 
     describe "#select" do
-      it "should select array of symbols" do
+      it "select array of symbols" do
         expect(rel.select(:user_id, :dummy_id).to_sql).to eq "select user_id,dummy_id from \"dummy\""
       end
 
-      it "should select string" do
+      it "select string" do
         expect(rel.select("count(user_id)").to_sql).to eq "select count(user_id) from \"dummy\""
       end
+
+      it "select expression" do
+        expect(rel.select("(value + 6) / 10").to_sql).to eq "select (value + 6) / 10 from \"dummy\""
+      end
     end
 
     describe "#where" do
-      it "should generate valid conditions from hash" do
-        Timecop.freeze(Time.now) do
-          expect(rel.where(user_id: 1, dummy: 'q', timer: Time.now).to_sql).to eq "select * from \"dummy\" where (user_id=1) and (dummy='q') and (timer=#{Time.now.to_i}s)"
-        end
+      it "sgenerate valid conditions from hash" do
+        Timecop.freeze(Time.now)
+        expect(rel.where(user_id: 1, dummy: 'q', timer: Time.now).to_sql).to eq "select * from \"dummy\" where (user_id=1) and (dummy='q') and (timer=#{Time.now.to_i}s)"
       end
 
-      it "should generate valid conditions from strings" do
+      it "generate valid conditions from strings" do
         expect(rel.where("time > now() - 1d").to_sql).to eq "select * from \"dummy\" where (time > now() - 1d)"
       end
 
-      it "should handle regexps" do
+      it "handle regexps" do
         expect(rel.where(user_id: 1, dummy: /^du.*/).to_sql).to eq "select * from \"dummy\" where (user_id=1) and (dummy=~/^du.*/)"
       end
 
-      it "should handle ranges" do
+      it "handle ranges" do
         expect(rel.where(user_id: 1..4).to_sql).to eq "select * from \"dummy\" where (user_id>1 and user_id<4)"
       end
 
-      it "should handle arrays" do
+      it "handle arrays" do
         expect(rel.where(user_id: [1, 2, 3]).to_sql).to eq "select * from \"dummy\" where (user_id=1 or user_id=2 or user_id=3)"
       end
+
+      context "with tags" do
+        it "integer tag values" do
+          expect(rel.where(dummy_id: 10).to_sql).to eq "select * from \"dummy\" where (dummy_id='10')"
+        end
+
+        it "array tag values" do
+          expect(rel.where(dummy_id: [10, 'some']).to_sql).to eq "select * from \"dummy\" where (dummy_id='10' or dummy_id='some')"
+        end
+      end
     end
 
     describe "#not" do
-      it "should negate simple values" do
+      it "negate simple values" do
         expect(rel.where.not(user_id: 1, dummy: :a).to_sql).to eq "select * from \"dummy\" where (user_id<>1) and (dummy<>'a')"
       end
 
-      it "should handle regexp" do
+      it "handle regexp" do
         expect(rel.where.not(user_id: 1, dummy: /^du.*/).to_sql).to eq "select * from \"dummy\" where (user_id<>1) and (dummy!~/^du.*/)"
       end
 
-      it "should handle ranges" do
+      it "handle ranges" do
         expect(rel.where.not(user_id: 1..4).to_sql).to eq "select * from \"dummy\" where (user_id<1 and user_id>4)"
       end
 
-      it "should handle arrays" do
+      it "handle arrays" do
         expect(rel.where.not(user_id: [1, 2, 3]).to_sql).to eq "select * from \"dummy\" where (user_id<>1 and user_id<>2 and user_id<>3)"
       end
     end
 
-    describe "#merge" do
-      it "should merge with one series" do
-        expect(rel.merge("dubby").to_sql).to eq "select * from \"dummy\" merge \"dubby\""
-      end
-
-      it "should merge with one series as regexp" do
-        expect(rel.merge(/^du[1-6]+$/).to_sql).to eq "select * from \"dummy\" merge /^du[1-6]+$/"
-      end
-    end
-
     describe "#past" do
-      it "should work with predefined symbols" do
+      it "work with predefined symbols" do
         expect(rel.past(:hour).to_sql).to eq "select * from \"dummy\" where (time > now() - 1h)"
       end
 
-      it "should work with any symbols" do
+      it "work with any symbols" do
         expect(rel.past(:s).to_sql).to eq "select * from \"dummy\" where (time > now() - 1s)"
       end
 
-      it "should work with strings" do
+      it "work with strings" do
         expect(rel.past("3d").to_sql).to eq "select * from \"dummy\" where (time > now() - 3d)"
       end
 
-      it "should work with numbers" do
+      it "work with numbers" do
         expect(rel.past(1.day).to_sql).to eq "select * from \"dummy\" where (time > now() - 86400s)"
       end
     end
 
     describe "#since" do
-      it "should work with datetime" do
+      it "work with datetime" do
         expect(rel.since(Time.utc(2014, 12, 31)).to_sql).to eq "select * from \"dummy\" where (time > 1419984000s)"
       end
     end
 
     describe "#group" do
-      it "should generate valid groups" do
+      it "generate valid groups" do
         expect(rel.group(:user_id, "time(1m) fill(0)").to_sql).to eq "select * from \"dummy\" group by user_id,time(1m) fill(0)"
       end
 
       context "group by time predefined values" do
-        it "should group by hour" do
+        it "group by hour" do
           expect(rel.time(:hour).to_sql).to eq "select * from \"dummy\" group by time(1h)"
         end
 
-        it "should group by minute" do
+        it "group by minute" do
           expect(rel.time(:minute).to_sql).to eq "select * from \"dummy\" group by time(1m)"
         end
 
-        it "should group by second" do
+        it "group by second" do
           expect(rel.time(:second).to_sql).to eq "select * from \"dummy\" group by time(1s)"
         end
 
-        it "should group by millisecond" do
-          expect(rel.time(:ms).to_sql).to eq "select * from \"dummy\" group by time(1u)"
+        it "group by millisecond" do
+          expect(rel.time(:ms).to_sql).to eq "select * from \"dummy\" group by time(1ms)"
         end
 
-        it "should group by day" do
+        it "group by microsecond" do
+          expect(rel.time(:u).to_sql).to eq "select * from \"dummy\" group by time(1u)"
+        end
+
+        it "group by day" do
           expect(rel.time(:day).to_sql).to eq "select * from \"dummy\" group by time(1d)"
         end
 
-        it "should group by week" do
+        it "group by week" do
           expect(rel.time(:week).to_sql).to eq "select * from \"dummy\" group by time(1w)"
         end
 
-        it "should group by month" do
+        it "group by month" do
           expect(rel.time(:month).to_sql).to eq "select * from \"dummy\" group by time(30d)"
         end
 
-        it "should group by hour and fill" do
+        it "group by hour and fill" do
           expect(rel.time(:month, fill: 0).to_sql).to eq "select * from \"dummy\" group by time(30d) fill(0)"
         end
       end
 
-      it "should group by time with string value" do
+      it "group by time with string value" do
         expect(rel.time("4d").to_sql).to eq "select * from \"dummy\" group by time(4d)"
       end
 
-      it "should group by time with string value and fill null" do
-        expect(rel.time("4d", fill: :null).to_sql).to eq "select * from \"dummy\" group by time(4d) fill(null)"
+      %w(null previous none).each do |val|
+        it "group by time with string value and fill #{val}" do
+          expect(rel.time("4d", fill: val.to_sym).to_sql).to eq "select * from \"dummy\" group by time(4d) fill(#{val})"
+        end
       end
 
-      it "should group by time and other fields with fill null" do
+      it "group by time and other fields with fill zero" do
         expect(rel.time("4d", fill: 0).group(:dummy_id).to_sql).to eq "select * from \"dummy\" group by time(4d),dummy_id fill(0)"
       end
+
+      it "group by time and other fields with fill negative" do
+        expect(rel.time("4d", fill: -1).group(:dummy_id).to_sql).to eq "select * from \"dummy\" group by time(4d),dummy_id fill(-1)"
+      end
+    end
+
+    describe "#order" do
+      it "generate valid order" do
+        expect(rel.order(time_spent: :asc).to_sql).to eq "select * from \"dummy\" order by time_spent asc"
+      end
+
+      it "generate order from string" do
+        expect(rel.order('cpu desc, val asc').to_sql).to eq "select * from \"dummy\" order by cpu desc, val asc"
+      end
     end
 
     describe "#limit" do
-      it "should generate valid limi" do
+      it "generate valid limit" do
         expect(rel.limit(100).to_sql).to eq "select * from \"dummy\" limit 100"
       end
     end
 
-    describe "calculations" do
+    describe "#slimit" do
+      it "generate valid slimit" do
+        expect(rel.slimit(100).to_sql).to eq "select * from \"dummy\" slimit 100"
+      end
+    end
+
+    describe "#offset" do
+      it "generate valid offset" do
+        expect(rel.limit(100).offset(10).to_sql).to eq "select * from \"dummy\" limit 100 offset 10"
+      end
+    end
+
+    describe "#soffset" do
+      it "generate valid soffset" do
+        expect(rel.soffset(10).to_sql).to eq "select * from \"dummy\" soffset 10"
+      end
+    end
+
+    context "calculations" do
       context "one arg calculation methods" do
         [
           :count, :min, :max, :mean,
           :mode, :median, :distinct, :derivative,
-          :stddev, :sum, :first, :last, :difference, :histogram
+          :stddev, :sum, :first, :last
         ].each do |method|
           describe "##{method}" do
-            it do
+            specify do
               expect(rel.where(user_id: 1).calc(method, :column_name).to_sql)
                 .to eq "select #{method}(column_name) from \"dummy\" where (user_id=1)"
             end
@@ -207,62 +247,77 @@ describe Influxer::Relation do
         end
       end
 
-      context "two args calculation methods" do
-        [
-          :percentile, :histogram, :top, :bottom
-        ].each do |method|
-          describe "##{method}" do
-            it do
-              expect(rel.where(user_id: 1).calc(method, :column_name, 10).to_sql)
-                .to eq "select #{method}(column_name,10) from \"dummy\" where (user_id=1)"
-            end
-          end
+      context "with aliases" do
+        it "select count as alias" do
+          expect(rel.count(:val, 'total').to_sql).to eq "select count(val) as total from \"dummy\""
         end
+
+        it "select percentile as alias" do
+          expect(rel.percentile(:val, 90, 'p1').to_sql).to eq "select percentile(val,90) as p1 from \"dummy\""
+        end
+      end
+    end
+
+    context "complex queries" do
+      it "group + where" do
+        expect(rel.count('user_id').group(:traffic_source).fill(0).where(user_id: 123).past('28d').to_sql)
+          .to eq "select count(user_id) from \"dummy\" where (user_id=123) and (time > now() - 28d) " \
+                 "group by traffic_source fill(0)"
+      end
+
+      it "where + group + order + limit" do
+        expect(rel.group(:user_id).where(account_id: 123).order(account_id: :desc).limit(10).offset(10).to_sql)
+          .to eq "select * from \"dummy\" where (account_id=123) group by user_id " \
+                 "order by account_id desc limit 10 offset 10"
+      end
+
+      it "offset + slimit" do
+        expect(rel.where(account_id: 123).slimit(10).offset(10).to_sql)
+          .to eq "select * from \"dummy\" where (account_id=123) " \
+                 "offset 10 slimit 10"
       end
     end
   end
 
   describe "#empty?" do
-    after(:each) { Influxer.reset }
-    it "should return false if has points" do
-      Influxer.client.stub(:query) { { points: [{ time: 1, id: 2 }] } }
+    it "return false if has points" do
+      allow(client).to receive(:query) { [{ "values" => [{ time: 1, id: 2 }] }] }
       expect(rel.empty?).to be_falsey
       expect(rel.present?).to be_truthy
     end
 
-    it "should return true if no points" do
-      Influxer.client.stub(:query) { {} }
+    it "return true if no points" do
+      allow(client).to receive(:query) { [] }
       expect(rel.empty?).to be_truthy
       expect(rel.present?).to be_falsey
     end
   end
 
   describe "#delete_all" do
-    it do
-      Timecop.freeze(Time.now) do
-        expect(rel.where(user_id: 1, dummy: 'q', timer: Time.now).delete_all)
-          .to eq "delete from \"dummy\" where (user_id=1) and (dummy='q') and (timer=#{Time.now.to_i}s)"
-      end
+    it "without tags" do
+      expect(rel.delete_all)
+        .to eq "drop series from \"dummy\""
     end
-  end
 
-  describe "#inspect" do
-    after(:each) do
-      Influxer.reset
+    it "with tags" do
+      expect(rel.where(dummy_id: 1, host: 'eu').delete_all)
+        .to eq "drop series from \"dummy\" where (dummy_id='1') and (host='eu')"
     end
+  end
 
-    it "should return correct String represantation of empty relation" do
-      Influxer.client.stub(:query) { {} }
+  describe "#inspect" do
+    it "return correct String represantation of empty relation" do
+      allow(rel).to receive(:to_a) { [] }
       expect(rel.inspect).to eq "#<Influxer::Relation []>"
     end
 
-    it "should return correct String represantation of non-empty relation" do
-      Influxer.client.stub(:query) { { "dummy" => [1, 2, 3] } }
+    it "return correct String represantation of non-empty relation" do
+      allow(rel).to receive(:to_a) { [1, 2, 3] }
       expect(rel.inspect).to eq "#<Influxer::Relation [1, 2, 3]>"
     end
 
-    it "should return correct String represantation of non-empty large (>11) relation" do
-      Influxer.client.stub(:query) { { "dummy" => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] } }
+    it "return correct String represantation of non-empty large (>11) relation" do
+      allow(rel).to receive(:to_a) { [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] }
       expect(rel.inspect).to eq "#<Influxer::Relation [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]>"
     end
   end

data/spec/metrics/scoping_spec.rb

@@ -1,12 +1,6 @@
 require 'spec_helper'
 
-describe Influxer::Metrics do
-  before do
-    allow_any_instance_of(Influxer::Client).to receive(:query) do |_, sql|
-      sql
-    end
-  end
-
+describe Influxer::Metrics, :query do
   let(:klass) do
     Class.new(Influxer::Metrics) do
       set_series 'dummy'
@@ -34,37 +28,37 @@ describe Influxer::Metrics do
   end
 
   describe "default scope" do
-    it "should work without default scope" do
+    it "works without default scope" do
       expect(klass.all.to_sql).to eq "select * from \"dummy\""
     end
 
-    it "should work with default scope" do
+    it "works with default scope" do
       expect(dummy.all.to_sql).to eq "select * from \"dummy\" group by time(1h)"
     end
 
-    it "should work with unscoped" do
+    it "works with unscoped" do
       expect(dummy.unscoped.to_sql).to eq "select * from \"dummy\""
     end
 
-    it "should work with several defaults" do
+    it "works with several defaults" do
       expect(dappy.where(user_id: 1).to_sql)
-        .to eq "select * from \"dummy\" group by time(1h) where (user_id=1) limit 100"
+        .to eq "select * from \"dummy\" where (user_id=1) group by time(1h) limit 100"
     end
   end
 
   describe "named scope" do
-    it "should work with named scope" do
+    it "works with named scope" do
       expect(doomy.by_user(1).to_sql)
-        .to eq "select * from \"dummy\" group by time(1h) where (user_id=1) limit 100"
+        .to eq "select * from \"dummy\" where (user_id=1) group by time(1h) limit 100"
     end
 
-    it "should work with named scope with empty relation" do
+    it "works with named scope with empty relation" do
       expect(doomy.by_user(nil).to_sql).to eq "select * from \"dummy\" group by time(1h) limit 100"
     end
 
-    it "should work with several scopes" do
+    it "works with several scopes" do
       expect(doomy.where(dummy_id: 100).by_user([1, 2, 3]).daily.to_sql)
-        .to eq "select * from \"dummy\" group by time(1d) where (dummy_id=100) and (user_id=1 or user_id=2 or user_id=3) limit 100"
+        .to eq "select * from \"dummy\" where (dummy_id=100) and (user_id=1 or user_id=2 or user_id=3) group by time(1d) limit 100"
     end
   end
 end

data/spec/model/user_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+fdescribe User do
+  let(:user) { described_class.create age: 20, gender: 1, email: 'user@example.com' }
+  subject { user }
+
+  specify { is_expected.to respond_to :metrics }
+  specify { is_expected.to respond_to :visits_metrics }
+  specify { is_expected.to respond_to :action_metrics }
+  specify { is_expected.to respond_to :custom_metrics }
+
+  describe "#metrics" do
+    subject { user.metrics.new }
+
+    it "add foreign key" do
+      expect(subject.user_id).to eq user.id
+    end
+  end
+
+  describe "#visits_metrics" do
+    subject { user.visits_metrics.new }
+
+    it "adds inherited attributes" do
+      expect(subject.age).to eq 20
+      expect(subject.gender).to eq 1
+    end
+  end
+
+  describe "#action_metrics" do
+    subject { user.action_metrics.new }
+
+    it "adds custom foreign key" do
+      expect(subject.user).to eq user.id
+    end
+  end
+
+  describe "#custom_metrics" do
+    subject { user.custom_metrics.new }
+
+    it "doesn't add foreign key" do
+      expect(subject.user_id).to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,21 +3,51 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 ENV["RAILS_ENV"] ||= 'test'
 
-# require 'simplecov'
-# SimpleCov.root File.join(File.dirname(__FILE__), '..', 'lib')
-# SimpleCov.start
+if ENV['COVER']
+  require 'simplecov'
+  SimpleCov.root File.join(File.dirname(__FILE__), '..')
+  SimpleCov.start
+end
 
 require 'rspec'
-require 'pry'
-require 'rails/all'
-require 'rspec/rails'
+require "webmock/rspec"
+require 'pry-byebug'
 require 'timecop'
 
-require "dummy/config/environment"
+require 'active_record'
+require 'sqlite3'
+
+require "influxer"
+
+# Rails stub
+class Rails
+  class << self
+    def cache
+      @cache ||= ActiveSupport::Cache::MemoryStore.new
+    end
+
+    def logger
+      @logger ||= Logger.new(nil)
+    end
+
+    def env
+      'test'
+    end
+  end
+end
+
+require "influxer/rails/client"
+
+ActiveRecord::Base.send :include, Influxer::Model
 
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+Dir["#{File.dirname(__FILE__)}/support/metrics/*.rb"].each { |f| require f }
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
   config.mock_with :rspec
-  config.use_transactional_fixtures = true
+
+  config.after(:each) { Influxer.reset! }
+  config.after(:each) { Timecop.return }
 end

data/spec/support/metrics/action_metrics.rb

@@ -0,0 +1,3 @@
+class ActionMetrics < Influxer::Metrics
+  tags :user, :action
+end

data/spec/support/metrics/custom_metrics.rb

@@ -0,0 +1,4 @@
+class CustomMetrics < Influxer::Metrics
+  tags :code, :user_id
+  attributes :val
+end

data/spec/support/{dummy_metrics.rb → metrics/dummy_metrics.rb}

@@ -1,5 +1,6 @@
 class DummyMetrics < Influxer::Metrics # :nodoc:
-  attributes :dummy_id, :user_id
+  tags :dummy_id, :host
+  attributes :user_id
 
   validates_presence_of :dummy_id, :user_id
 

data/spec/support/metrics/user_metrics.rb

@@ -0,0 +1,4 @@
+class UserMetrics < Influxer::Metrics
+  tags :user_id
+  attributes :time_spent
+end

data/spec/support/metrics/visits_metrics.rb

@@ -0,0 +1,4 @@
+class VisitsMetrics < Influxer::Metrics
+  tags :user_id, :gender
+  attributes :age, :page
+end

data/spec/support/shared_contexts/shared_query.rb

@@ -0,0 +1,16 @@
+shared_context "stub_query", :query do
+  let(:client) { Influxer.client }
+
+  before do
+    # Stub all query methods
+    allow_any_instance_of(InfluxDB::Client).to receive(:query) do |_, sql|
+      sql
+    end
+
+    allow_any_instance_of(Influxer::Client).to receive(:exec) do |_, sql|
+      sql
+    end
+
+    allow_any_instance_of(InfluxDB::Client).to receive(:post)
+  end
+end

data/spec/support/user.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define do
+  create_table :users do |t|
+    t.string :email
+    t.integer :age
+    t.integer :gender
+  end
+end
+
+class User < ActiveRecord::Base
+  has_metrics
+  has_metrics :visits_metrics, class_name: "VisitsMetrics", inherits: [:gender, :age]
+  has_metrics :action_metrics, class_name: "ActionMetrics", foreign_key: :user
+  has_metrics :custom_metrics, class_name: "CustomMetrics", foreign_key: nil
+end