mongoid-report 0.1.9 → 0.2.0

data/spec/mongoid/report/out_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Mongoid::Report do
+  let(:klass) { Model }
+
+  it 'should merge properly results on splitted requests' do
+    ########## 1. Making the first report and out to the defined collection name.
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :field1
+          batches pool_size: 2
+          column :field1, :field2
+        end
+      end
+    end
+
+    klass.create!(day: 0.days.ago, field1: 1, field2: 1)
+    klass.create!(day: 1.days.ago, field1: 1, field2: 1)
+    klass.create!(day: 1.days.ago, field1: 2, field2: 2)
+    klass.create!(day: 2.days.ago, field1: 3, field2: 3)
+    klass.create!(day: 3.days.ago, field1: 1, field2: 1)
+    klass.create!(day: 4.days.ago, field1: 1, field2: 1)
+
+    report = report_klass.new
+
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .in_batches(day: (5.days.ago.to_date..0.days.from_now.to_date))
+      .out('stored-report')
+      .all
+
+    values = scoped.rows.map {|row| row['field2']}
+    expect(values.size).to eq(3)
+    expect(values).to include(4)
+    expect(values).to include(2)
+    expect(values).to include(3)
+
+    stored_report_klass = Class.new do
+      include Mongoid::Document
+      store_in collection: 'stored-report'
+    end
+
+    out = stored_report_klass.all
+    expect(out.count).to eq(3)
+    values = out.map { |o| o['field2'] }
+    expect(values).to include(4)
+    expect(values).to include(2)
+    expect(values).to include(3)
+
+    ########## 2. Making the second report and out to the defined collection name with new data.
+    klass.create!(day: 3.days.ago, field1: 1, field2: 1)
+
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .in_batches(day: (5.days.ago.to_date..0.days.from_now.to_date))
+      .out('stored-report')
+      .all
+
+    values = scoped.rows.map {|row| row['field2']}
+    expect(values.size).to eq(3)
+    expect(values).to include(5)
+    expect(values).to include(2)
+    expect(values).to include(3)
+
+    out = stored_report_klass.all
+    expect(out.count).to eq(3)
+    values = out.map { |o| o['field2'] }
+    expect(values).to include(5)
+    expect(values).to include(2)
+    expect(values).to include(3)
+  end
+
+  it 'should leave data out of date range' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :day
+          batches pool_size: 2
+          column :field1, :day
+        end
+      end
+    end
+
+    stored_report_klass = Class.new do
+      include Mongoid::Document
+      store_in collection: 'stored-report'
+    end
+
+    klass.create!(day: 0.days.ago, field1: 1)
+    klass.create!(day: 1.days.ago, field1: 1)
+    klass.create!(day: 1.days.ago, field1: 1)
+    klass.create!(day: 2.days.ago, field1: 1)
+    klass.create!(day: 3.days.ago, field1: 1)
+    klass.create!(day: 4.days.ago, field1: 1)
+
+    report = report_klass.new
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .in_batches(day: (1.days.ago.to_date..0.days.from_now.to_date))
+      .out('stored-report', drop: { 'day' => { '$gte' => 1.days.ago.to_date.mongoize, '$lte' => 0.days.from_now.to_date.mongoize } })
+      .all
+
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .in_batches(day: (5.days.ago.to_date..1.days.ago.to_date))
+      .out('stored-report', drop: { 'day' => { '$gte' => 5.days.ago.to_date.mongoize, '$lte' => 1.days.ago.to_date.mongoize } })
+      .all
+
+    out = stored_report_klass.all
+    expect(out.count).to eq(5)
+
+    days = stored_report_klass.distinct('day')
+    4.times do |i|
+      expect(days).to include(i.days.ago.to_date)
+    end
+  end
+end

data/spec/mongoid/report/queries_builder_spec.rb

@@ -4,13 +4,15 @@ describe Mongoid::Report::QueriesBuilder do
 
   describe '.queries' do
     it 'builds queries for aggregation' do
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
-        column :field1, for: Model
+        def self.name ; 'report-klass' ; end
+
+        column :field1, collection: Model
       end
-      report = Report.new
+      report = report_klass.new
 
-      queries = report.queries(Model)
+      queries = report.queries('report-klass', 'models')
       expect(queries.size).to eq(3)
       expect(queries[0]).to eq(
         '$project' => {
@@ -30,17 +32,18 @@ describe Mongoid::Report::QueriesBuilder do
     end
 
     it 'builds queries using custom one group' do
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         attach_to Model do
           group_by :day
           column :field1
         end
       end
-      report = Report.new
+      report = report_klass.new
 
-      queries = report.queries(Model)
+      queries = report.queries('report-klass', 'models')
       expect(queries.size).to eq(3)
       expect(queries[0]).to eq(
         '$project' => {
@@ -61,18 +64,18 @@ describe Mongoid::Report::QueriesBuilder do
         })
     end
 
-    class Report5
-      include Mongoid::Report
-
-      attach_to Model do
-        group_by :day, :field2
+    it 'builds queries using custom one group' do
+      report_klass = Class.new do
+        include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
-        column :field1, :field3
+        attach_to Model do
+          group_by :day, :field2
+          column :field2, :field1, :field3
+        end
       end
-    end
 
-    it 'builds queries using custom one group' do
-      queries = Report5.new.queries(Model)
+      queries = report_klass.new.queries('report-klass', 'models')
       expect(queries.size).to eq(3)
       expect(queries[0]).to eq(
         '$project' => {
@@ -99,4 +102,39 @@ describe Mongoid::Report::QueriesBuilder do
     end
   end
 
+  it 'allows to pass raw query' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to 'models' do
+          query '$match' => { 'field1' => 1 }
+          match 'field2' => 2
+          match 'field3' => ->(report) { 3 }
+          match '$or' => ->(this) {
+            [
+              { 'field1' => 1 },
+              { 'field2' => 2 },
+            ]
+          }
+          column :field1, :field2
+        end
+      end
+    end
+
+    Model.create(field1: 1, field2: 2, field3: 1)
+    Model.create(field1: 2, field2: 2, field3: 1)
+    Model.create(field1: 1, field2: 2, field3: 3)
+
+    report = report_klass.new
+    queries = report.report_module_settings['example'][:reports]['models'][:queries]
+    expect(queries).to include('$match' => { 'field1' => 1 })
+    expect(queries).to include('$match' => { 'field2' => 2 })
+
+    scope = report.aggregate_for('example', 'models').all
+    expect(scope.rows.size).to eq(1)
+    expect(scope.rows[0]['field1']).to eq(1)
+    expect(scope.rows[0]['field2']).to eq(2)
+  end # it
+
 end

data/spec/mongoid/report/set_spec.rb

@@ -6,7 +6,7 @@ describe Mongoid::Report do
   it 'allows to save options per report and attached model' do
     2.times { klass.create!(field1: 1) }
 
-    Report = Class.new do
+    report_klass = Class.new do
       include Mongoid::Report
 
       report 'example' do
@@ -19,8 +19,8 @@ describe Mongoid::Report do
       end
     end
 
-    report = Report.new
-    report = report.aggregate_for('example-models')
+    report = report_klass.new
+    report = report.aggregate_for('example', 'models')
     report = report.all
 
     rows = report.rows

data/spec/mongoid/report/summary_spec.rb

@@ -12,14 +12,16 @@ describe Mongoid::Report do
       klass.create!(day: today     , field1: 1)
       klass.create!(day: yesterday , field1: 1)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
-        group_by :day, for: Model
-        column :field1, for: Model
+        def self.name ; 'report-klass' ; end
+
+        group_by :day, collection: Model
+        column :field1, collection: Model
       end
-      example = Report.new
+      example = report_klass.new
 
-      report = example.aggregate_for(klass)
+      report = example.aggregate_for('report-klass', 'models')
       report = report.all
       rows = report.rows
 
@@ -28,39 +30,108 @@ describe Mongoid::Report do
     end
 
     it 'should support dynamic columns as well' do
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
 
         COLUMNS = {
           :'new-field1' => ->(context, row, options) { row['field1'] * 10 },
-          :'new-field2' => ->(context, row, options) { row['field1'] * 20 },
+          :'new-field2' => ->(context, row, options) { row['field2'] * 20 },
         }
 
         report 'example' do
           attach_to Model do
             columns COLUMNS
-            column :field1, 'new-field1'
+            column :field1, :field2, 'new-field1', 'new-field2'
+          end
+        end
+      end
+
+      klass.create!(field1: 1, field2: 3)
+      klass.create!(field1: 2, field2: 2)
+      klass.create!(field1: 3, field2: 1)
+
+      report = report_klass.new
+      report = report.aggregate_for('example', 'models')
+      report = report.all
+      rows = report.rows
+
+      expect(rows[0].keys.size).to eq(4)
+      expect(rows[0]['field1']).to eq(6)
+      expect(rows[0]['field2']).to eq(6)
+      expect(rows[0]['new-field1']).to eq(60)
+      expect(rows[0]['new-field2']).to eq(120)
+
+      expect(report.summary.keys.size).to eq(4)
+      expect(report.summary['field1']).to eq(6)
+      expect(report.summary['field2']).to eq(6)
+      expect(report.summary['new-field1']).to eq(60)
+      expect(report.summary['new-field2']).to eq(120)
+    end
+
+    it 'should not summaries day field' do
+      report_klass = Class.new do
+        include Mongoid::Report
+
+        report 'example' do
+          attach_to Model do
+            group_by :day
+            column :day, :field1
           end
         end
       end
 
-      klass.create!(field1: 1)
-      klass.create!(field1: 1)
-      klass.create!(field1: 1)
+      klass.create!(day: DateTime.now, field1: 1)
+      klass.create!(day: DateTime.now, field1: 1)
+      klass.create!(day: DateTime.now, field1: 1)
 
-      report = Report.new
-      report = report.aggregate_for('example-models')
+      report = report_klass.new
+      report = report.aggregate_for('example', 'models')
       report = report.all
       rows = report.rows
 
       expect(rows[0].keys.size).to eq(2)
       expect(rows[0]['field1']).to eq(3)
-      expect(rows[0]['new-field1']).to eq(30)
+      expect(rows[0]['day']).to be
 
-      expect(report.summary.keys.size).to eq(2)
+      expect(report.summary.keys.size).to eq(1)
       expect(report.summary['field1']).to eq(3)
-      expect(report.summary['new-field1']).to eq(30)
     end
+
+    it 'should calculate dynamic columns for summary' do
+      report_klass = Class.new do
+        include Mongoid::Report
+
+        COLUMNS = {
+          :'new-field1' => ->(context, row, options) { row['field2'] * 10 / row['field1'] * 1.2 },
+          :'new-field2' => ->(context, row, options) { row['field2'] * 20.0 * row['field1'] / 100 },
+        }
+
+        report 'example' do
+          attach_to Model do
+            columns COLUMNS
+            group_by :day
+            column :day, :field1, :field2, 'new-field1', 'new-field2'
+          end
+        end
+      end
+
+      klass.create!(day: 1.day.ago, field1: 1, field2: 3)
+      klass.create!(day: 2.day.ago, field1: 2, field2: 0)
+      klass.create!(day: 3.day.ago, field1: 3, field2: 1)
+      klass.create!(day: 4.day.ago, field1: 4, field2: 0)
+
+      report = report_klass.new
+      report = report.aggregate_for('example', 'models')
+      report = report.all
+      rows = report.rows
+
+      expect(report.summary.keys.size).to eq(4)
+      expect(report.summary['field1']).to eq(10)
+      expect(report.summary['field2']).to eq(4)
+      expect(report.summary['new-field1']).to eq(4.8)
+      expect(report.summary['new-field2']).to eq(8.0)
+    end
+
   end
 
 end

data/spec/mongoid/report/threads_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 require 'benchmark'
 
-describe Mongoid::Report do
+describe Mongoid::Report, long: true do
   let(:klass) { Model }
 
   it 'aggregates fields by app in threads' do
-    Report = Class.new do
+    report_klass = Class.new do
       include Mongoid::Report
 
       attach_to Model, as: 'field1-aggregation' do
@@ -17,9 +17,11 @@ describe Mongoid::Report do
       end
     end
 
-    30000.times { klass.create!(field1: 1, field2: 1) }
+    times = 30000
 
-    report = Report.new
+    times.times { klass.create!(field1: 1, field2: 1) }
+
+    report = report_klass.new
     scoped = report.aggregate
 
     Mongoid::Report::Config.use_threads_on_aggregate = true
@@ -37,4 +39,130 @@ describe Mongoid::Report do
 
     time2.real.should > time1.real
   end
+
+  it 'should work faster using batches in threads on aggregate' do
+    report_klass1 = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :day
+          column :field1
+        end
+      end
+    end
+
+    report_klass2 = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :day
+          batches pool_size: 4
+          column :field1
+        end
+      end
+    end
+
+    times = 10
+
+    times.times.map do |i|
+      Thread.new do
+        10000.times { klass.create!(day: i.days.ago, field1: 1) }
+      end
+    end.map(&:join)
+
+    report1 = report_klass1.new
+    scoped = report1.aggregate
+
+    time1 = Benchmark.measure do
+      rows = scoped.all
+      expect(rows['example']['models'].rows[0]['field1']).to eq(10000)
+    end
+
+    report2 = report_klass2.new
+    scoped = report2.aggregate_for('example', 'models')
+
+    time2 = Benchmark.measure do
+      scoped = scoped
+        .in_batches(day: (5.days.ago.to_date..0.days.from_now.to_date))
+        .all
+      expect(scoped.rows[0]['field1']).to eq(10000)
+    end
+
+    puts time2
+    puts time1
+
+    time1.real.should > time2.real
+  end
+
+  it 'should merge properly results on splitted requests' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :field1
+          batches pool_size: 2
+          column :field1, :field2
+        end
+      end
+    end
+
+    klass.create!(day: 0.days.ago, field1: 1, field2: 1)
+    klass.create!(day: 1.days.ago, field1: 1, field2: 1)
+    klass.create!(day: 1.days.ago, field1: 2, field2: 2)
+    klass.create!(day: 2.days.ago, field1: 3, field2: 3)
+    klass.create!(day: 3.days.ago, field1: 1, field2: 1)
+    klass.create!(day: 4.days.ago, field1: 1, field2: 1)
+
+    report = report_klass.new
+
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .in_batches(day: (5.days.ago.to_date..0.days.from_now.to_date))
+      .all
+
+    values = scoped.rows.map {|row| row['field2']}
+    expect(values).to include(4)
+    expect(values).to include(2)
+    expect(values).to include(3)
+  end
+
+  it 'should merge properly results with multiple groups' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :field1, :field2
+          batches pool_size: 2
+          column :field1, :field2, :field3
+        end
+      end
+    end
+
+    klass.create!(day: 0.days.ago, field1: 1, field2: 4, field3: 1)
+    klass.create!(day: 1.days.ago, field1: 1, field2: 5, field3: 1)
+    klass.create!(day: 1.days.ago, field1: 2, field2: 6, field3: 2)
+    klass.create!(day: 2.days.ago, field1: 3, field2: 7, field3: 3)
+    klass.create!(day: 3.days.ago, field1: 1, field2: 8, field3: 1)
+    klass.create!(day: 4.days.ago, field1: 1, field2: 9, field3: 1)
+
+    report = report_klass.new
+
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .in_batches(day: (5.days.ago.to_date..0.days.from_now.to_date))
+      .all
+
+    expect(scoped.summary['field3']).to eq(9)
+    expect(scoped.rows.size).to eq(6)
+    expect(scoped.rows).to include({"field3"=>2, "field1"=>2, "field2"=>6})
+    expect(scoped.rows).to include({"field3"=>3, "field1"=>3, "field2"=>7})
+    expect(scoped.rows).to include({"field3"=>1, "field1"=>1, "field2"=>5})
+    expect(scoped.rows).to include({"field3"=>1, "field1"=>1, "field2"=>4})
+    expect(scoped.rows).to include({"field3"=>1, "field1"=>1, "field2"=>9})
+    expect(scoped.rows).to include({"field3"=>1, "field1"=>1, "field2"=>8})
+  end
 end