mongoid-report 0.1.9 → 0.2.0

data/spec/mongoid/report/aggregation_spec.rb

@@ -8,8 +8,9 @@ describe Mongoid::Report do
 
   describe '.aggregate_for' do
     it 'aggregates fields by app' do
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         attach_to Model do
           column :field1
@@ -20,10 +21,11 @@ describe Mongoid::Report do
       klass.create!(field1: 1)
       klass.create!(field1: 1)
 
-      example = Report.new
-      report = example.aggregate_for(klass)
-      report = report.all
-      rows = report.rows
+      example = report_klass.new
+      report = example.aggregate_for('report-klass', 'models')
+      scoped = report.all
+
+      rows = scoped.rows
 
       expect(rows.size).to eq(1)
       expect(rows[0]['field1']).to eq(3)
@@ -34,14 +36,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
@@ -60,14 +64,16 @@ describe Mongoid::Report do
       klass.create(day: two_days_ago , field1: 1 , field2: 2)
       klass.create(day: today        , field1: 1 , field2: 3)
 
-      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
 
-      scope = example.aggregate_for(Model)
+      scope = example.aggregate_for('report-klass', 'models')
       scope = scope.query('$match' => { :day  => { '$gte' => yesterday.mongoize, '$lte' => today.mongoize } })
       scope = scope.query('$match' => { :field2 => 2 })
       scope = scope.yield
@@ -87,14 +93,16 @@ describe Mongoid::Report do
     it 'skips empty match in query' do
       klass.create(day: today , field1: 1 , field2: 2)
 
-      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
 
-      scope = example.aggregate_for(Model)
+      scope = example.aggregate_for('report-klass', 'models')
       scope = scope.query()
       scope = scope.query({})
 
@@ -115,8 +123,9 @@ describe Mongoid::Report do
       klass.create(day: yesterday    , field1: 1 , field2: 2)
       klass.create(day: two_days_ago , field1: 1 , field2: 2)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         attach_to Model, as: 'example1' do
           group_by :day
@@ -129,7 +138,7 @@ describe Mongoid::Report do
         end
       end
 
-      example = Report.new
+      example = report_klass.new
       scope = example.aggregate
       scope
         .query('$match' => { :day  => { '$gte' => yesterday.mongoize, '$lte' => today.mongoize } })
@@ -137,14 +146,14 @@ describe Mongoid::Report do
         .query('$sort' => { day: -1 })
       scope = scope.all
 
-      rows = scope['example1'].rows
+      rows = scope['report-klass']['example1'].rows
       expect(rows.size).to eq(2)
       expect(rows[0]['field1']).to eq(2)
       expect(rows[0]['day']).to eq(today)
       expect(rows[1]['field1']).to eq(1)
       expect(rows[1]['day']).to eq(yesterday)
 
-      rows = scope['example2'].rows
+      rows = scope['report-klass']['example2'].rows
       expect(rows.size).to eq(2)
       expect(rows[0]['field2']).to eq(4)
       expect(rows[0]['day']).to eq(today)
@@ -158,8 +167,9 @@ describe Mongoid::Report do
       klass.create(day: yesterday    , field1: 1 , field2: 2)
       klass.create(day: two_days_ago , field1: 1 , field2: 2)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         report 'example' do
           attach_to Model, as: 'model1' do
@@ -173,7 +183,7 @@ describe Mongoid::Report do
           end
         end
       end
-      example = Report.new
+      example = report_klass.new
 
       scope = example.aggregate
       scope
@@ -182,14 +192,14 @@ describe Mongoid::Report do
         .query('$sort' => { day: -1 })
       scope = scope.all
 
-      rows = scope['example-model1'].rows
+      rows = scope['example']['model1'].rows
       expect(rows.size).to eq(2)
       expect(rows[0]['field1']).to eq(2)
       expect(rows[0]['day']).to eq(today)
       expect(rows[1]['field1']).to eq(1)
       expect(rows[1]['day']).to eq(yesterday)
 
-      rows = scope['example-model2'].rows
+      rows = scope['example']['model2'].rows
       expect(rows.size).to eq(2)
       expect(rows[0]['field2']).to eq(4)
       expect(rows[0]['day']).to eq(today)
@@ -203,13 +213,14 @@ describe Mongoid::Report do
       klass.create(day: yesterday    , field1: 1 , field2: 2)
       klass.create(day: two_days_ago , field1: 1 , field2: 2)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         report 'example' do
           attach_to Model, as: 'model1' do
             group_by :day
-            column :field1, as: 'new-field1'
+            column :field1
           end
 
           attach_to Model, as: 'model2' do
@@ -218,7 +229,7 @@ describe Mongoid::Report do
           end
         end
       end
-      example = Report.new
+      example = report_klass.new
 
       scope = example.aggregate
       scope
@@ -227,14 +238,14 @@ describe Mongoid::Report do
         .query('$sort' => { day: -1 })
       scope = scope.all
 
-      rows = scope['example-model1'].rows
+      rows = scope['example']['model1'].rows
       expect(rows.size).to eq(2)
-      expect(rows[0]['new-field1']).to eq(2)
+      expect(rows[0]['field1']).to eq(2)
       expect(rows[0]['day']).to eq(today)
-      expect(rows[1]['new-field1']).to eq(1)
+      expect(rows[1]['field1']).to eq(1)
       expect(rows[1]['day']).to eq(yesterday)
 
-      rows = scope['example-model2'].rows
+      rows = scope['example']['model2'].rows
       expect(rows.size).to eq(2)
       expect(rows[0]['field2']).to eq(4)
       expect(rows[0]['day']).to eq(today)
@@ -243,85 +254,89 @@ describe Mongoid::Report do
     end
   end
 
-  describe '.filter' do
-    it 'creates filter' do
+  describe '.match' do
+    it 'creates match' do
       klass.create(field1: 1, field2: 2)
       klass.create(field1: 3, field2: 4)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
-        filter field2: 2, for: Model
-        column :field1, for: Model
+        match field2: 2, collection: Model
+        column :field1, collection: Model
       end
-      example = Report.new
+      example = report_klass.new
 
       scope = example.aggregate
       scope = scope.all
 
-      rows = scope[Model].rows
+      rows = scope['report-klass']['models'].rows
       expect(rows.size).to eq(1)
       expect(rows[0]['field1']).to eq(1)
     end
 
-    it 'creates filter in report scope' do
+    it 'creates match in report scope' do
       klass.create(field1: 1, field2: 2)
       klass.create(field1: 3, field2: 4)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         report 'example' do
           attach_to Model do
-            filter field2: 2
+            match field2: 2
             column :field1
           end
         end
       end
 
-      example = Report.new
+      example = report_klass.new
       scope = example.aggregate
       scope = scope.all
 
-      rows = scope['example-models'].rows
+      rows = scope['example']['models'].rows
       expect(rows.size).to eq(1)
       expect(rows[0]['field1']).to eq(1)
     end
 
-    it 'creates filter in report scope' do
+    it 'creates match in report scope' do
       klass.create(day: today     , field1: 1 , field2: 2)
       klass.create(day: yesterday , field1: 1 , field2: 2)
       klass.create(day: today     , field1: 3 , field2: 4)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         report 'example' do
           attach_to Model do
-            filter field2: 2,
+            match field2: 2,
               day: ->(context) { Date.parse("20-12-2004").mongoize }
             column :field1
           end
         end
       end
-      example = Report.new
+      example = report_klass.new
 
       scope = example.aggregate
       scope = scope.all
 
-      rows = scope['example-models'].rows
+      rows = scope['example']['models'].rows
       expect(rows.size).to eq(1)
       expect(rows[0]['field1']).to eq(1)
     end
 
-    it 'creates filter in report scope' do
+    it 'creates match in report scope' do
       klass.create(day: today     , field1: 1 , field2: 2)
       klass.create(day: today     , field1: 1 , field2: 2)
       klass.create(day: yesterday , field1: 1 , field2: 2)
       klass.create(day: today     , field1: 3 , field2: 4)
 
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
+        def self.name ; 'report-klass' ; end
 
         def values
           [1, 2]
@@ -330,17 +345,17 @@ describe Mongoid::Report do
         report 'example' do
           attach_to Model do
             group_by :day
-            filter field2: ->(context) { { '$in' => context.values } }
+            match field2: ->(context) { { '$in' => context.values } }
             column :field1
           end
         end
       end
-      example = Report.new
+      example = report_klass.new
 
       scope = example.aggregate
       scope = scope.all
 
-      rows = scope['example-models'].rows
+      rows = scope['example']['models'].rows
       expect(rows.size).to eq(2)
       expect(rows[0]['field1']).to eq(1)
       expect(rows[1]['field1']).to eq(2)

data/spec/mongoid/report/attach_to_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Mongoid::Report do
+  it 'should creates settings in case of missing block' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do ; end
+      end
+    end
+
+    expect(report_klass.settings['example']).to be
+    expect(report_klass.settings['example'][:reports]['models']).to be
+  end
+end

data/spec/mongoid/report/collection_spec.rb

@@ -5,9 +5,11 @@ describe Mongoid::Report::Collection do
 
   describe '.rows' do
     it 'use returns aggregated rows' do
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
 
+        def self.name ; 'report-klass' ; end
+
         attach_to Model do
           column :field1
         end
@@ -15,9 +17,10 @@ describe Mongoid::Report::Collection do
 
       3.times { klass.create!(field1: 1) }
 
-      example = Report.new
-      report = example.aggregate_for(klass)
-      report = report.all
+      example = report_klass.new
+      report = example
+        .aggregate_for('report-klass', 'models')
+        .all
 
       rows = report.rows
       expect(rows.size).to eq(1)
@@ -27,17 +30,19 @@ describe Mongoid::Report::Collection do
 
   describe '.headers' do
     it 'returns columns for showing in the reports' do
-      Report = Class.new do
+      report_klass = Class.new do
         include Mongoid::Report
 
+        def self.name ; 'report-klass' ; end
+
         attach_to Model do
           column :field1, :field3, :field2
         end
       end
 
-      report = Report.new
+      report = report_klass.new
       report = report
-        .aggregate_for(klass)
+        .aggregate_for('report-klass', 'models')
         .all
 
       expect(report.headers).to eq(["field1", "field3", "field2"])

data/spec/mongoid/report/column_spec.rb

@@ -28,7 +28,7 @@ describe Mongoid::Report do
     scope = report.aggregate
     scope = scope.all
 
-    rows = scope['example-models'].rows
+    rows = scope['example']['models'].rows
     expect(rows.size).to eq(2)
     expect(rows[0]['field1']).to eq(1)
     expect(rows[0]['dynamic-field1']).to eq(10)

data/spec/mongoid/report/dynamic_attach_to_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Mongoid::Report do
+  let(:klass) { Model }
+
+  it 'allows to specify dynamic name for attach_to option' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to 'pregenerated' do
+          group_by :field1
+          column :field3
+        end
+
+        attach_to Model do
+          group_by :field1, :field2
+          column :field3
+        end
+      end
+    end
+
+    klass.create!(field1: 1, field2: 1, field3: 1)
+    klass.create!(field1: 1, field2: 2, field3: 1)
+
+    report = report_klass.new
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .out('new-collection')
+      .all
+
+    expect(scoped.rows.size).to eq(2)
+    expect(scoped.summary['field3']).to eq(2)
+
+    scoped = report.aggregate_for('example', 'pregenerated')
+    scoped = scoped
+      .in('new-collection')
+      .all
+
+    expect(scoped.rows.size).to eq(1)
+    expect(scoped.rows[0]['field3']).to eq(2)
+    expect(scoped.summary['field3']).to eq(2)
+  end
+
+
+  it 'should be possible to define column and other methods out of the attach_to scope' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        columns :field4 => ->(context, row, options) { row['field3'] }
+
+        column :field3, :field4
+
+        attach_to 'pregenerated' do
+          group_by :field1
+        end
+
+        attach_to Model do
+          group_by :field1, :field2
+        end
+      end
+    end
+
+    klass.create!(field1: 1, field2: 1, field3: 1)
+    klass.create!(field1: 1, field2: 2, field3: 1)
+
+    report = report_klass.new
+    scoped = report.aggregate_for('example', 'models')
+    scoped = scoped
+      .out('new-collection')
+      .all
+    expect(scoped.rows.size).to eq(2)
+    expect(scoped.summary['field3']).to eq(2)
+
+    scoped = report.aggregate_for('example', 'pregenerated')
+    scoped = scoped
+      .in('new-collection')
+      .all
+
+    expect(scoped.rows.size).to eq(1)
+    expect(scoped.rows[0]['field3']).to eq(2)
+    expect(scoped.rows[0]['field4']).to eq(2)
+    expect(scoped.summary['field3']).to eq(2)
+  end
+end

data/spec/mongoid/report/integration_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Mongoid::Report do
+  it 'works fine on multiple requests' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          match field2: 2
+          column :field1
+        end
+      end
+    end
+
+    Model.create(field1: 1, field2: 1)
+    Model.create(field1: 1, field2: 2)
+
+    report = report_klass.new
+    scoped = report.aggregate_for('example', 'models').all
+    queries1 = report.report_module_settings['example'][:reports]['models'][:queries].deep_dup
+
+    report = report_klass.new
+    scoped = report.aggregate_for('example', 'models').all
+    queries2 = report.report_module_settings['example'][:reports]['models'][:queries].deep_dup
+
+    expect(queries1).to eq(queries2)
+  end
+
+  it 'works find on multiple requests with drops of their stats' do
+    day1 = Date.parse("2014-01-01")
+    1.times { Model.create(day: day1, field1: 1, field2: 1) }
+
+    day2 = Date.parse("2014-01-02")
+    2.times { Model.create(day: day2, field1: 1, field2: 2) }
+
+    day3 = Date.parse("2014-01-03")
+    3.times { Model.create(day: day3, field1: 1, field2: 3) }
+
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        attach_to Model do
+          group_by :day
+          column :field1, :field2
+        end
+      end
+    end
+
+    # pregenerate the data
+    report = report_klass.new
+    scoped = report
+      .aggregate_for('example', 'models')
+      .query(
+        '$match' => {
+          'day' => {
+            '$gte' => day1.mongoize,
+            '$lte' => day3.mongoize,
+          },
+        })
+      .yield
+      .out('new-models', drop: {
+        'day' => {
+          '$gte' => day1.mongoize,
+          '$lte' => day3.mongoize,
+        },
+      })
+      .all
+    report = report_klass.new
+    # read the data from output collection
+    scoped = report
+      .aggregate_for('example', 'models')
+      .in('new-models')
+      .all
+
+    expect(scoped.rows.size).to eq(3)
+    row = scoped.rows.find { |row| row['day'] == day1 }
+    expect(row['field1']).to eq(1)
+    expect(row['field2']).to eq(1)
+    row = scoped.rows.find { |row| row['day'] == day2 }
+    expect(row['field1']).to eq(2)
+    expect(row['field2']).to eq(4)
+    row = scoped.rows.find { |row| row['day'] == day3 }
+    expect(row['field1']).to eq(3)
+    expect(row['field2']).to eq(9)
+
+    Model.where(day: day1).set(field1: 1, field2: 2)
+    Model.where(day: day2).set(field1: 2, field2: 3)
+    Model.where(day: day3).set(field1: 1, field2: 2)
+
+    # pregenerate the data
+    report = report_klass.new
+    scoped = report
+      .aggregate_for('example', 'models')
+      .query(
+        '$match' => {
+          'day' => {
+            '$gte' => day1.mongoize,
+            '$lte' => day3.mongoize,
+          },
+        })
+      .yield
+      .out('new-models', drop: {
+        'day' => {
+          '$gte' => day1.mongoize,
+          '$lte' => day3.mongoize,
+        },
+      })
+      .all
+    # read the data from output collection
+    report = report_klass.new
+    scoped = report
+      .aggregate_for('example', 'models')
+      .in('new-models')
+      .all
+
+    expect(scoped.rows.size).to eq(3)
+    row = scoped.rows.find { |row| row['day'] == day1 }
+    expect(row['field1']).to eq(1)
+    expect(row['field2']).to eq(2)
+    row = scoped.rows.find { |row| row['day'] == day2 }
+    expect(row['field1']).to eq(4)
+    expect(row['field2']).to eq(6)
+    row = scoped.rows.find { |row| row['day'] == day3 }
+    expect(row['field1']).to eq(3)
+    expect(row['field2']).to eq(6)
+  end
+end

data/spec/mongoid/report/module_configuration_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Mongoid::Report do
+  it 'should stores global queries for each defined attach_to blocks' do
+    report_klass = Class.new do
+      include Mongoid::Report
+
+      report 'example' do
+        match field1: 1
+
+        attach_to Model, as: 'models1' do ; end
+        attach_to Model, as: 'models2' do
+          column :field2
+        end
+      end
+    end
+
+    report = report_klass.new
+    queries1 = report.report_module_settings['example'][:reports]['models1'][:queries]
+    queries2 = report.report_module_settings['example'][:reports]['models2'][:queries]
+
+    expect(queries1).to eq([
+      { '$match' => { :field1 => 1 }},
+      { '$project' => { :_id => 1 }},
+      { '$group' => { :_id => {} } },
+      { '$project' => { :_id => 0 } },
+    ])
+    expect(queries2).to eq([
+      { '$match' => { :field1 => 1 }},
+      { '$project' => { :_id => 1, 'field2' => 1 }},
+      { '$group' => { :_id => {}, 'field2'=>{'$sum'=>'$field2'} } },
+      { '$project' => { :_id => 0, 'field2' => '$field2' } },
+    ])
+  end
+end