aggrobot 0.0.2 → 0.1.0

data/spec/support/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/spec/unit/aggrobot/query_planners/bucketed_groups_query_planner_spec.rb

@@ -4,90 +4,77 @@ module Aggrobot
   module QueryPlanner
 
     describe BucketedGroupsQueryPlanner do
+      before :all do
+        FactoryRobot.start(:users) do
+          count 400
+          name  4 => 'Tom', 7 => 'Hardy', 9 => 'Dark', 10 => 'Knight'
+          age   4 => 20, 7 => 40, 9 => 60, 10 => 80
+          score 4 => 100, 7 => 200, 9 => 300, 10 => 400
+        end
+      end
 
-      let(:collection) { double }
-      let(:group) { 'group_col' }
-      let(:buckets) { [1..2, [3, 4, 5], 8, 9] }
-      subject(:query_planner) { BucketedGroupsQueryPlanner.new(collection, group, buckets: buckets) }
 
-      describe '#sub_query' do
-        before do
-          collection.stub(:where).with('group_col' => 1..2).and_return('collection for 1..2')
-          collection.stub(:where).with('group_col' => [3,4,5]).and_return('collection for 3,4,5')
-          collection.stub(:where).with('group_col' => 8).and_return('collection for 8')
-          collection.stub(:where).with('group_col' => 9).and_return('collection for 9')
+      let(:buckets) { [100, 200..299, 300..399, 400] }
+      subject(:query_planner) { BucketedGroupsQueryPlanner.new(User, :score, buckets: buckets) }
+
+      context 'initialization' do
+        it 'requires explicit parameters' do
+          expect { BucketedGroupsQueryPlanner.new(User, :name) }.to raise_error(ArgumentError)
+          expect { BucketedGroupsQueryPlanner.new(User, :name, :keep_empty => true) }.to raise_error(ArgumentError)
+          expect { BucketedGroupsQueryPlanner.new('User', :name, :buckets => buckets, :keep_empty => true) }.to raise_error(ArgumentError)
+          expect { BucketedGroupsQueryPlanner.new(User, :name, :buckets => buckets, :keep_empty => true) }.to_not raise_error
         end
+      end
 
+      describe '#sub_query' do
+        let(:sub_query) { 'SELECT "users".* FROM "users"  WHERE "users"."score" = 100'}
         it 'returns the correct subquery' do
-          expect(query_planner.sub_query((1..2).to_s)).to eq 'collection for 1..2'
-          expect(query_planner.sub_query([3,4,5].to_s)).to eq 'collection for 3,4,5'
-          expect(query_planner.sub_query(8.to_s)).to eq 'collection for 8'
-          expect(query_planner.sub_query(9.to_s)).to eq 'collection for 9'
+          expect(query_planner.sub_query(100).to_sql).to eq sub_query
+        end
+
+        context 'group on multiple columns' do
+          let(:buckets) { [['Tim',1..2], ['Black', [3, 4, 5]], ['Knight',[8, 9]]] }
+          subject(:query_planner) { BucketedGroupsQueryPlanner.new(User, [:name, :score], buckets: buckets) }
+          let(:sub_query) { 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Tim\' AND ("users"."score" BETWEEN 1 AND 2)'}
+          it 'returns the correct subquery' do
+            expect(query_planner.sub_query(['Tim',1..2]).to_sql).to eq sub_query
+          end
         end
       end
 
       describe '#query_results' do
-        let(:bucketed_relation) { double }
-        before do
-          collection.stub(:where).and_return(bucketed_relation)
-        end
 
         context 'collection is none' do
-          before do
-            query_planner.stub(:collection_is_none? => true, :empty_default_groups => [])
-          end
+          subject(:query_planner) { BucketedGroupsQueryPlanner.new(User.unscoped.none, :score, buckets: buckets) }
           it 'returns empty result set' do
             expect(query_planner.query_results).to be_empty
           end
         end
 
         context 'collection is not none' do
-          before do
-            query_planner.stub(:collection_is_none? => false)
-            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize((1..2).to_s), limit: 1,
-                pluck: [SqlFunctions.sanitize((1..2).to_s), SqlFunctions.count, :col1, :col2])
-                .and_return(['results for 1..2'])
-            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize([3,4,5].to_s), limit: 1,
-                                   pluck: [SqlFunctions.sanitize([3,4,5].to_s), SqlFunctions.count, :col1, :col2])
-            .and_return(['results for 3,4,5'])
-            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(8.to_s), limit: 1,
-                                   pluck: [SqlFunctions.sanitize(8.to_s), SqlFunctions.count, :col1, :col2])
-            .and_return(['results for 8'])
-            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(9.to_s), limit: 1,
-                                   pluck: [SqlFunctions.sanitize(9.to_s), SqlFunctions.count, :col1, :col2])
-            .and_return(['results for 9'])
-          end
-          it 'returns empty result set' do
-            expect(query_planner.query_results([:col1, :col2])).to eq ["results for 1..2", "results for 3,4,5",
-                                                                       "results for 8", "results for 9"]
+          let(:results) { [[100, 160, 3200, 100.0], [200..299, 120, 4800, 200.0], [300..399, 80, 4800, 300.0], [400, 40, 3200, 400.0]] }
+          it 'returns correct result set' do
+            expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq results
           end
         end
 
         context 'empty buckets' do
-          before do
-            query_planner.stub(:collection_is_none? => false)
-            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(:populated.to_s), limit: 1,
-                                   pluck: [SqlFunctions.sanitize(:populated.to_s), SqlFunctions.count, :col1, :col2])
-            .and_return(['results for populated group'])
-
-            should_receive_queries(bucketed_relation, :group => SqlFunctions.sanitize(:empty.to_s), limit: 1,
-                                   pluck: [SqlFunctions.sanitize(:empty.to_s), SqlFunctions.count, :col1, :col2])
-            .and_return([])
-            bucketed_relation.stub(:none)
-          end
           context 'without keep_empty option' do
-            subject(:query_planner) { BucketedGroupsQueryPlanner.new(collection, group, buckets: [:populated, :empty]) }
+            let(:results){ [['Knight', 40, 3200, 400.0]] }
+            subject(:query_planner) { BucketedGroupsQueryPlanner.new(User, :name, buckets: ['Batman', 'Knight']) }
             it 'returns only populated result set' do
-              expect(query_planner.query_results([:col1, :col2])).to eq ["results for populated group"]
+              expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq results
             end
           end
 
           context 'with keep_empty option' do
-            subject(:query_planner) { BucketedGroupsQueryPlanner.new(collection, group, buckets: [:populated, :empty], keep_empty: true) }
-            it 'returns both empty and populated result sets' do
-              expect(query_planner.query_results([:col1, :col2])).to eq ["results for populated group", ["empty", 0]]
+            let(:results){ [['Batman', 0], ['Knight', 40, 3200, 400.0]] }
+            subject(:query_planner) { BucketedGroupsQueryPlanner.new(User, :name, buckets: ['Batman', 'Knight'], keep_empty: true) }
+            it 'returns only populated result set' do
+              expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq results
             end
           end
+
         end
       end
 

data/spec/unit/aggrobot/query_planners/default_query_planner_spec.rb

@@ -2,48 +2,72 @@ require 'spec_helper'
 
 module Aggrobot
   module QueryPlanner
-
     describe DefaultQueryPlanner do
-      let(:collection) { double }
-      let(:group) { 'group_col' }
-      subject(:query_planner) { DefaultQueryPlanner.new(collection, group) }
+      before :all do
+        FactoryRobot.start(:users) do
+          count 400
+          name  ['Tom', 'Hardy']
+          age   [20, 40]
+          score [100, 200]
+        end
+      end
+
+      after :all do
+        User.delete_all
+      end
 
+      context 'initializing with a non active record object' do
+        it 'raises exception' do
+          expect{ DefaultQueryPlanner.new('TEST') }.to raise_error(ArgumentError)
+        end
+      end
+
+      subject(:query_planner) { DefaultQueryPlanner.new(User, 'name') }
       describe '#sub_query' do
-        context 'when group was specified' do
-          before do
-            collection.should_receive(:where).with('group_col' => 'group').and_return('collection')
+        context 'when default group' do
+          let(:group_query) { 'SELECT "users".* FROM "users"' }
+          subject(:query_planner) { DefaultQueryPlanner.new(User) }
+          it 'returns the correct subquery' do
+            expect(query_planner.sub_query(DEFAULT_GROUP_BY).to_sql).to eq group_query
           end
+        end
+
+        context 'when group was specified' do
+          let(:tom_group_query) { 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Tom\'' }
+          let(:hardy_group_query) { 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Hardy\'' }
           it 'returns the correct subquery' do
-            expect(query_planner.sub_query('group')).to eq 'collection'
+            expect(query_planner.sub_query('Tom').to_sql).to eq tom_group_query
+            expect(query_planner.sub_query('Hardy').to_sql).to eq hardy_group_query
           end
         end
 
-        context 'when default group' do
-          let(:query_planner) { DefaultQueryPlanner.new(collection, DEFAULT_GROUP_BY) }
+        context 'when group is an array' do
+          subject(:query_planner) { DefaultQueryPlanner.new(User, ['name', 'age']) }
+          let(:array_group_query) { 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Tom\' AND "users"."age" = 20' }
           it 'returns the correct subquery' do
-            expect(query_planner.sub_query('group')).to eq collection
+            expect(query_planner.sub_query(['Tom', 20]).to_sql).to eq array_group_query
           end
         end
       end
 
       describe '#query_results' do
         context 'collection is none' do
-          before { query_planner.stub(:collection_is_none? => true) }
+          subject(:query_planner) { DefaultQueryPlanner.new(User.none) }
           it { expect(query_planner.query_results).to be_empty }
         end
 
         context 'collection is not none' do
-          let(:grouped_relation) { double }
-          before do
-            query_planner.stub(:collection_is_none? => false)
-
-            collection.should_receive(:group).with('group_col').and_return(grouped_relation)
-            grouped_relation.should_receive(:pluck)
-            .with('group_col', SqlFunctions.count, 'extra_col1', 'extra_col2')
-            .and_return(:results)
+          let(:group_results){ [['Hardy', 200, 8000, 200.0], ['Tom', 200, 4000, 100.0]] }
+          it 'returns results for columns' do
+            expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq group_results
           end
+        end
+
+        context 'collection is not none' do
+          subject(:query_planner) { DefaultQueryPlanner.new(User, ['name', 'age']) }
+          let(:group_results){ [[['Hardy', 40], 200, 8000, 200.0], [['Tom', 20], 200, 4000, 100.0]] }
           it 'returns results for columns' do
-            expect(query_planner.query_results(['extra_col1', 'extra_col2'])).to eq :results
+            expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq group_results
           end
         end
 

data/spec/unit/aggrobot/query_planners/group_limit_query_planner_spec.rb

@@ -3,129 +3,128 @@ require 'spec_helper'
 module Aggrobot
   module QueryPlanner
     describe GroupLimitQueryPlanner do
-      let(:collection) { double }
-      let(:group) { 'group_col' }
+
+      before :all do
+        FactoryRobot.start(:users) do
+          count 400
+          name  4 => 'Tom', 7 => 'Hardy', 9 => 'Dark', 10 => 'Knight'
+          age   4 => 20, 7 => 40, 9 => 60, 10 => 80
+          score 4 => 100, 7 => 200, 9 => 300, 10 => 400
+        end
+      end
 
       context 'initialization' do
         before do
           GroupLimitQueryPlanner.any_instance.stub(:process_top_groups_options)
         end
         it 'requires explicit parameters' do
-          expect { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2) }.to raise_error
-          expect { GroupLimitQueryPlanner.new(collection, group, :sort_by => 2) }.to raise_error
-          expect { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2, :sort_by => 2) }.to_not raise_error
+          expect { GroupLimitQueryPlanner.new(User, :name, :limit_to => 2) }.to raise_error(ArgumentError)
+          expect { GroupLimitQueryPlanner.new(User, :name, :sort_by => 2) }.to raise_error(ArgumentError)
+          expect { GroupLimitQueryPlanner.new('User', :name, :limit_to => 2, :sort_by => 2) }.to raise_error(ArgumentError)
+          expect { GroupLimitQueryPlanner.new(User, :name, :limit_to => 2, :sort_by => 2) }.to_not raise_error
         end
       end
 
       describe '#sub_query' do
 
         context 'with only default options' do
-          before do
-            should_receive_queries(collection, :group => group, :order => 'order_col desc',
-                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
-          end
-          subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
-                                                               :sort_by => :order_col, :other_group => 'others') }
+          let(:group_query){ 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Tom\'' }
+          let(:other_group_query) { 'SELECT "users".* FROM "users"  WHERE ("users"."name" NOT IN (\'Tom\', \'Hardy\'))' }
+          subject(:query_planner) { GroupLimitQueryPlanner.new(User, 'name', :limit_to => 2,
+                                                               :sort_by => SQLFunctions.count, :other_group => 'others') }
           context 'for one of the top groups' do
             it 'gives query with only that group in condition' do
-              should_receive_queries(collection, :where => {'group_col' => 'group1'}).and_return(:sub_query1)
-              expect(query_planner.sub_query('group1')).to eq :sub_query1
+              expect(query_planner.sub_query('Tom').to_sql).to eq group_query
             end
           end
 
           context 'for others group' do
             it 'gives query with only that group in condition' do
-              should_receive_queries(collection, :where => nil, not: {'group_col' => ['group1', 'group2']}).and_return(:sub_query_other)
-              expect(query_planner.sub_query('others')).to eq :sub_query_other
+              expect(query_planner.sub_query('others').to_sql).to eq other_group_query
             end
           end
         end
 
         context 'with always include option' do
-          before do
-            should_receive_queries(collection, :group => group, :order => 'order_col desc',
-                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
-          end
-          subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
-                                                               :sort_by => :order_col, :other_group => 'others', :always_include => 'always') }
+          let(:group_query){ 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Knight\'' }
+          let(:other_group_query) { 'SELECT "users".* FROM "users"  WHERE ("users"."name" NOT IN (\'Tom\', \'Knight\'))' }
+          subject(:query_planner) { GroupLimitQueryPlanner.new(User, :name, :limit_to => 2,
+                                                               :sort_by => SQLFunctions.count, :other_group => 'others', :always_include => 'Knight') }
           context 'for one of the top groups' do
             it 'gives query with only that group in condition' do
-              should_receive_queries(collection, :where => {'group_col' => 'always'}).and_return(:sub_query_always)
-              expect(query_planner.sub_query('always')).to eq :sub_query_always
+              expect(query_planner.sub_query('Knight').to_sql).to eq group_query
+            end
+          end
+
+          context 'for others group' do
+            it 'gives query with only that group in condition' do
+              expect(query_planner.sub_query('others').to_sql).to eq other_group_query
             end
           end
         end
 
+        context 'group on multiple coulmns' do
+          let(:group_query){ 'SELECT "users".* FROM "users"  WHERE "users"."name" = \'Knight\' AND "users"."age" = 80' }
+          let(:other_group_query) { 'SELECT "users".* FROM "users"  WHERE ("users"."name" NOT IN (\'Tom\', \'Hardy\')) AND ("users"."age" NOT IN (20, 40))' }
+          subject(:query_planner) { GroupLimitQueryPlanner.new(User, [:name, :age], :limit_to => 2,
+                                                               :sort_by => SQLFunctions.count, :other_group => 'others') }
+          context 'for one of the top groups' do
+            it 'gives query with only that group in condition' do
+              expect(query_planner.sub_query(['Knight', 80]).to_sql).to eq group_query
+            end
+          end
+
+          context 'for others group' do
+            it 'gives query with only that group in condition' do
+              expect(query_planner.sub_query('others').to_sql).to eq other_group_query
+            end
+          end
+        end
       end
 
       describe '#query_results' do
-        let(:columns) { ['group_col', 'COUNT(*)', 'col1', 'col2'] }
-        let(:other_columns) { ["'others'", 'COUNT(*)', 'col1', 'col2'] }
-        subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
-                                                             :sort_by => :order_col, :other_group => 'others') }
-
-
+        subject(:query_planner) { GroupLimitQueryPlanner.new(User, 'name', :limit_to => 2,
+                                                             :sort_by => SQLFunctions.count, :other_group => 'others') }
         context 'when collection is none' do
-          before do
-            should_receive_queries(collection, :group => group, :order => 'order_col desc',
-                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
-            query_planner.stub(:collection_is_none? => true)
-          end
+          subject(:query_planner) { GroupLimitQueryPlanner.new(User.unscoped.none, :name, :limit_to => 2,
+                                                               :sort_by => SQLFunctions.count, :other_group => 'others') }
           it 'returns empty result' do
             expect(query_planner.query_results).to be_empty
           end
         end
 
         context 'with reverse sort order' do
-          let(:conditions) { {'group_col' => ['group2', 'group1']} }
-          subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2, :order => 'asc',
-                                                               :sort_by => :order_col, :other_group => 'others') }
-          before do
-            should_receive_queries(collection, :group => group, :order => 'order_col asc',
-                                   :limit => 2, :pluck => group).and_return(['group2', 'group1'])
-            should_receive_queries(collection, :where => conditions,
-                                   :group => group, :pluck => columns).and_return([:group2_results, :group1_results])
-            should_receive_queries(collection, :where => nil, :not => conditions,
-                                   :group => "'others'", :pluck => other_columns).and_return([:others])
-            query_planner.stub(:collection_is_none? => false)
-          end
-
+          let(:reverse_order_groups){ [["Dark", 80, 4800, 300.0], ["Knight", 40, 3200, 400.0], ["others", 280, 8000, 142.86]] }
+          subject(:query_planner) { GroupLimitQueryPlanner.new(User, :name, :limit_to => 2, :order => 'asc',
+                                                               :sort_by => SQLFunctions.count, :other_group => 'others') }
           it 'returns results for reverse order' do
-            expect(query_planner.query_results(['col1', 'col2'])).to eq [:group2_results, :group1_results, :others]
+            expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq reverse_order_groups
           end
         end
 
         context 'when collection is not none and default sort order' do
-          let(:conditions) { {'group_col' => ['group1', 'group2']} }
-
-          before do
-            should_receive_queries(collection, :group => group, :order => 'order_col desc',
-                                   :limit => 2, :pluck => group).and_return(['group1', 'group2'])
-            query_planner.stub(:collection_is_none? => false)
-          end
-
+          let(:results) { [['Hardy', 120, 4800, 200.0], ['Tom', 160, 3200, 100.0], ['others', 120, 8000, 333.33]] }
           context 'with default options' do
             it 'returns top group results' do
-              should_receive_queries(collection, :group => group, :where => conditions, :pluck => columns).and_return([:group1_results, :group2_results])
-              should_receive_queries(collection, :where => nil, :not => conditions,
-                                     :group => "'others'", :pluck => other_columns).and_return([:others])
-              expect(query_planner.query_results(['col1', 'col2'])).to eq [:group1_results, :group2_results, :others]
+              expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq results
             end
           end
 
-
           context 'with always_include option added' do
-            subject(:query_planner) { GroupLimitQueryPlanner.new(collection, group, :limit_to => 2,
-                                                                 :sort_by => :order_col, :always_include => 'always', :other_group => 'others') }
-            let(:conditions) { {'group_col' => ['group1', 'always']} }
-            before do
-              query_planner.stub(:collection_is_none? => false)
+            let(:results){ [["Knight", 40, 3200, 400.0], ["Tom", 160, 3200, 100.0], ["others", 200, 9600, 240.0]] }
+            subject(:query_planner) { GroupLimitQueryPlanner.new(User, :name, :limit_to => 2,
+                                                                 :sort_by => SQLFunctions.count, :always_include => 'Knight', :other_group => 'others') }
+            it 'returns top group results inlcuding the always_include group' do
+              expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq results
             end
+          end
+
+          context 'with grouping on multiple columns' do
+            let(:results){ [[["Dark", 60], 80, 4800, 300.0], [["Tom", 20], 160, 3200, 100.0], ["others", 80, 160, 8000, 250.0]] }
+            subject(:query_planner) { GroupLimitQueryPlanner.new(User, [:name, :age], :limit_to => 2,
+                                                                 :sort_by => SQLFunctions.count, :other_group => 'others', :always_include => ['Dark', 60]) }
             it 'returns top group results inlcuding the always_include group' do
-              should_receive_queries(collection, :group => group, :where => conditions, :pluck => columns).and_return([:group1_results, :group2_results])
-              should_receive_queries(collection, :where => nil, :not => conditions,
-                                     :group => "'others'", :pluck => other_columns).and_return([:others])
-              expect(query_planner.query_results(['col1', 'col2'])).to eq [:group1_results, :group2_results, :others]
+              expect(query_planner.query_results([SQLFunctions.sum(:age), SQLFunctions.average(:score)])).to eq results
             end
           end
 

data/spec/unit/aggrobot/sql_functions_spec.rb

@@ -1,82 +1,83 @@
 require 'spec_helper'
-require 'aggrobot/sql_functions'
+require 'aggrobot/sql_functions/common'
 
 module Aggrobot
-
-  describe SqlFunctions do
-    before do
-      module SqlFunctions
-        ROUNDING_DIGITS = 2
-      end
+  describe SQLFunctions do
+    before(:all) do
+      SQLFunctions.setup(2, SQLFunctions::MYSQL_ADAPTER_NAME)
     end
+    subject { SQLFunctions }
 
     describe '.sql_attr' do
       it 'returns an escaped sql attribute' do
-        expect(SqlFunctions.desc('attr')).to eq 'attr desc'
+        expect(subject.desc('attr')).to eq 'attr desc'
+      end
+      it 'returns an escaped sql attribute to order asc' do
+        expect(subject.asc('attr')).to eq 'attr asc'
       end
     end
 
     describe '.count' do
       it 'get SQL Sum' do
-        expect(SqlFunctions.count('attr')).to eq 'COUNT(attr)'
+        expect(subject.count('attr')).to eq 'COUNT(attr)'
       end
     end
 
     describe '.unique_count' do
       it 'gets distinct COUNT' do
-        expect(SqlFunctions.unique_count('attr')).to eq 'COUNT(DISTINCT attr)'
+        expect(subject.unique_count('attr')).to eq 'COUNT(DISTINCT attr)'
       end
     end
 
     describe '.max' do
       it 'gets max' do
-        expect(SqlFunctions.max('attr')).to eq 'MAX(attr)'
+        expect(subject.max('attr')).to eq 'MAX(attr)'
       end
     end
 
     describe '.max' do
       it 'gets min' do
-        expect(SqlFunctions.min('attr')).to eq 'MIN(attr)'
+        expect(subject.min('attr')).to eq 'MIN(attr)'
       end
     end
 
     describe '.sum' do
       it 'gets sum' do
-        expect(SqlFunctions.sum('attr')).to eq 'SUM(attr)'
+        expect(subject.sum('attr')).to eq 'SUM(attr)'
       end
     end
 
     describe '.avg' do
       it 'gets avg' do
-        expect(SqlFunctions.avg('attr')).to eq "ROUND(AVG(attr), #{SqlFunctions::ROUNDING_DIGITS})"
+        expect(subject.avg('attr')).to eq 'ROUND(AVG(attr), 2)'
       end
     end
 
     describe '.group_collect' do
       it 'does group concat' do
-        expect(SqlFunctions.group_collect('attr')).to eq 'GROUP_CONCAT(DISTINCT attr)'
+        expect(subject.group_collect('attr')).to eq 'GROUP_CONCAT(DISTINCT attr)'
       end
     end
 
     describe '.percent' do
       it 'calculate percent' do
-        expect(SqlFunctions.percent('attr', 100)).to eq "ROUND((100*100.0)/attr, #{SqlFunctions::ROUNDING_DIGITS})"
+        expect(subject.percent('attr', 100)).to eq 'ROUND((100*100.0)/attr, 2)'
       end
 
       it 'calculate percent with default params' do
-        expect(SqlFunctions.percent('attr')).to eq "ROUND((COUNT(*)*100.0)/attr, #{SqlFunctions::ROUNDING_DIGITS})"
+        expect(SQLFunctions.percent('attr')).to eq 'ROUND((COUNT(*)*100.0)/attr, 2)'
       end
     end
 
     describe '.mysql' do
       it 'multiplies' do
-        expect(SqlFunctions.multiply('attr', 100, 2)).to eq 'ROUND(attr*100, 2)'
+        expect(SQLFunctions.multiply('attr', 100, 2)).to eq 'ROUND(attr*100, 2)'
       end
     end
 
     describe '.divide' do
       it 'divides' do
-        expect(SqlFunctions.divide('attr', 100, 2)).to eq 'ROUND(attr/100, 2)'
+        expect(SQLFunctions.divide('attr', 100, 2)).to eq 'ROUND(attr/100, 2)'
       end
     end