active_reporter 0.5.8

data/spec/active_reporter/dimension/base_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe ActiveReporter::Dimension::Base do
+  def new_dimension(dimension_params = {}, report_params = {}, opts = {})
+    report_params[:dimensions] = { foo: dimension_params }
+    ActiveReporter::Dimension::Base.new(
+      :foo,
+      OpenStruct.new(params: report_params),
+      opts
+    )
+  end
+
+  describe '#filter_values' do
+    it 'accepts one' do
+      dimension = new_dimension(only: 'bar')
+      expect(dimension.filter_values).to eq %w(bar)
+    end
+
+    it 'accepts many' do
+      dimension = new_dimension(only: %w(bar baz))
+      expect(dimension.filter_values).to eq %w(bar baz)
+    end
+
+    it 'determines #filtering?' do
+      dimension = new_dimension(only: %w(bar baz))
+      expect(dimension).to be_filtering
+
+      dimension = new_dimension
+      expect(dimension).not_to be_filtering
+    end
+  end
+
+  describe '#sort_order' do
+    it 'can be desc/asc, falls back to root, defaults to asc' do
+      dimension = new_dimension
+      expect(dimension.sort_order).to eq 'ASC'
+
+      dimension = new_dimension(sort_desc: true)
+      expect(dimension.sort_order).to eq 'DESC'
+
+      dimension = new_dimension(sort_desc: false)
+      expect(dimension.sort_order).to eq 'ASC'
+
+      dimension = new_dimension({}, sort_desc: true)
+      expect(dimension.sort_order).to eq 'DESC'
+
+      dimension = new_dimension({}, sort_desc: false)
+      expect(dimension.sort_order).to eq 'ASC'
+    end
+  end
+
+  describe '#null_order' do
+    it 'can be first/last, falls back to root, defaults to first (only if postgres)' do
+      if ActiveReporter.database_type == :postgres
+        dimension = new_dimension
+        expect(dimension.null_order).to eq 'NULLS FIRST'
+
+        dimension = new_dimension(nulls_last: true)
+        expect(dimension.null_order).to eq 'NULLS LAST'
+
+        dimension = new_dimension(nulls_last: false)
+        expect(dimension.null_order).to eq 'NULLS FIRST'
+
+        dimension = new_dimension({}, nulls_last: true)
+        expect(dimension.null_order).to eq 'NULLS LAST'
+
+        dimension = new_dimension({}, nulls_last: false)
+        expect(dimension.null_order).to eq 'NULLS FIRST'
+      else
+        dimension = new_dimension
+        expect(dimension.null_order).to be_blank
+      end
+    end
+  end
+
+  describe '#relate' do
+    it 'defaults to the identity function' do
+      dimension = new_dimension
+      expect(dimension.relate(5)).to eq 5
+    end
+
+    it 'can be overridden, e.g. for joins' do
+      dimension = new_dimension({}, {}, relation: ->(r) { r + 5 })
+      expect(dimension.relate(5)).to eq 10
+    end
+  end
+
+  describe '#expression' do
+    it 'defaults to treating name as a column of the report klass table' do
+      dimension = ActiveReporter::Dimension::Base.new(
+        :bar,
+        OpenStruct.new(table_name: 'foo')
+      )
+      expect(dimension.expression).to eq('foo.bar')
+    end
+
+    it 'can be overridden' do
+      dimension = new_dimension({}, {}, table_name: :baz, attribute: :bat)
+      expect(dimension.expression).to eq 'baz.bat'
+    end
+  end
+end

data/spec/active_reporter/dimension/bin/set_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe ActiveReporter::Dimension::Bin::Set do
+  describe '.from_hash' do
+    it 'builds a bin from a hash or nil' do
+      bin = described_class.from_hash(min: 1, max: 2)
+      expect(bin.min).to eq 1
+      expect(bin.max).to eq 2
+
+      bin = described_class.from_hash(nil)
+      expect(bin.min).to eq nil
+      expect(bin.max).to eq nil
+    end
+  end
+
+  describe '.from_sql' do
+    it 'builds a bin from a bin text string' do
+      bin = described_class.from_sql("1,2")
+      expect(bin.min).to eq '1'
+      expect(bin.max).to eq '2'
+
+      bin = described_class.from_sql("1,")
+      expect(bin.min).to eq '1'
+      expect(bin.max).to eq nil
+
+      bin = described_class.from_sql(",2")
+      expect(bin.min).to eq nil
+      expect(bin.max).to eq '2'
+
+      bin = described_class.from_sql(",")
+      expect(bin.min).to eq nil
+      expect(bin.max).to eq nil
+    end
+  end
+
+  describe '#contains_sql' do
+    it 'returns SQL checking if expr is in the bin' do
+      bin = described_class.new(1, 2)
+      expect(bin.contains_sql('foo')).to eq "(foo >= 1 AND foo < 2)"
+
+      bin = described_class.new(1, nil)
+      expect(bin.contains_sql('foo')).to eq "foo >= 1"
+
+      bin = described_class.new(nil, 2)
+      expect(bin.contains_sql('foo')).to eq "foo < 2"
+
+      bin = described_class.new(nil, nil)
+      expect(bin.contains_sql('foo')).to eq "foo IS NULL"
+    end
+  end
+
+  describe '#to_json' do
+    it 'reexpresses the bin as a hash' do
+      bin = described_class.new(1, 2)
+      json = { a: bin }.to_json
+      expect(JSON.parse(json)).to eq('a' => { 'min' => 1, 'max' => 2 })
+    end
+  end
+
+  describe 'hashing' do
+    it 'works with hashes' do
+      bin1 = described_class.new(1, 2)
+      bin2 = described_class.new(1, 2)
+      bin3 = { min: 1, max: 2 }
+
+      h = { bin3 => 'foo' }
+      expect(h[bin1]).to eq 'foo'
+      expect(h[bin2]).to eq 'foo'
+      expect(h[bin3]).to eq 'foo'
+    end
+
+    it 'works with nil' do
+      bin1 = described_class.new(nil, nil)
+      bin2 = described_class.new(nil, nil)
+      bin3 = nil
+
+      h = { bin3 => 'foo' }
+      expect(h[bin1]).to eq 'foo'
+      expect(h[bin2]).to eq 'foo'
+      expect(h[bin3]).to eq 'foo'
+    end
+  end
+end

data/spec/active_reporter/dimension/bin/table_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe ActiveReporter::Dimension::Bin::Table do
+  let(:bin_set) { ActiveReporter::Dimension::Bin::Set }
+
+  describe '#filter' do
+    it 'ORs together predicates across bins' do
+      table = described_class.new([
+        bin_set.new(nil, nil),
+        bin_set.new(0, nil),
+        bin_set.new(nil, 10),
+        bin_set.new(3, 5)
+      ])
+
+      sql = table.filter(Post, 'x').to_sql
+
+      expect(sql).to include "WHERE (x IS NULL OR x >= 0 OR x < 10 OR (x >= 3 AND x < 5))"
+    end
+  end
+
+  describe '#group' do
+    it 'joins to a union of bin rows, then groups by the range' do
+      table = described_class.new([
+        bin_set.new(nil, nil),
+        bin_set.new(0, nil),
+        bin_set.new(nil, 10),
+        bin_set.new(3, 5)
+      ])
+
+      sql = table.group(Post, 'likes', 'likes').to_sql
+
+      expect(sql).to start_with "SELECT likes_bin_table.bin_text AS likes"
+
+      if ActiveReporter.database_type == :mysql
+        expect(sql).to include "SELECT NULL AS min, NULL AS max, ',' AS bin_text"
+        expect(sql).to include "SELECT 0 AS min, NULL AS max, '0,' AS bin_text"
+        expect(sql).to include "SELECT NULL AS min, 10 AS max, ',10' AS bin_text"
+        expect(sql).to include "SELECT 3 AS min, 5 AS max, '3,5' AS bin_text"
+      else
+        expect(sql).to include "SELECT NULL AS min, NULL AS max, CAST(',' AS text) AS bin_text"
+        expect(sql).to include "SELECT 0 AS min, NULL AS max, CAST('0,' AS text) AS bin_text"
+        expect(sql).to include "SELECT NULL AS min, 10 AS max, CAST(',10' AS text) AS bin_text"
+        expect(sql).to include "SELECT 3 AS min, 5 AS max, CAST('3,5' AS text) AS bin_text"
+      end
+    end
+  end
+end

data/spec/active_reporter/dimension/bin_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe ActiveReporter::Dimension::Bin do
+  def new_dimension(dimension_params = {}, report_params = {}, opts = {})
+    report_params[:dimensions] = { foo: dimension_params }
+    ActiveReporter::Dimension::Bin.new(:foo,
+      OpenStruct.new(params: report_params),
+      opts
+    )
+  end
+
+  def expect_error(&block)
+    expect { yield }.to raise_error(ActiveReporter::InvalidParamsError)
+  end
+
+  describe 'param validation' do
+    it 'yells unless :bin_count is numeric' do
+      expect_error { new_dimension(bin_count: 'hey') }
+      expect_error { new_dimension(bin_count: nil) }
+      new_dimension(bin_count: 5)
+      new_dimension(bin_count: 1.24)
+    end
+  end
+
+  describe '#min/max' do
+    it 'finds the extremes in filter_values' do
+      dimension = new_dimension(only: [{ min: 1, max: 3 }, { min: -3 }, { min: 17, max: 40 }])
+      expect(dimension.min).to eq -3
+      expect(dimension.max).to eq 40
+    end
+
+    it 'falls back to the smallest value in the data' do
+      dimension = ActiveReporter::Dimension::Bin.new(:likes,
+        OpenStruct.new(records: Post, params: {}),
+        model: :post, attribute: :likes
+      )
+      expect(dimension.min).to be_nil
+      expect(dimension.max).to be_nil
+      create(:post, likes: 3)
+      create(:post, likes: 10)
+      create(:post, likes: 1)
+      expect(dimension.min).to eq 1
+      expect(dimension.max).to eq 10
+    end
+  end
+
+  describe '#group_values' do
+    it 'defaults to dividing the domain into bins of bin_width' do
+      dimension = new_dimension(only: { min: 0, max: 3 })
+      allow(dimension).to receive(:bin_width).and_return(1)
+      allow(dimension).to receive(:data_contains_nil?).and_return(false)
+      expect(dimension.group_values).to eq [
+        { min: 0, max: 1 },
+        { min: 1, max: 2 },
+        { min: 2, max: 3 }
+      ]
+    end
+
+    it 'is inclusive of max if data-driven' do
+      dimension = new_dimension(only: { min: 0 })
+      allow(dimension.report).to receive(:records).and_return(Post)
+      allow(dimension).to receive(:expression).and_return('posts.likes')
+      allow(dimension).to receive(:bin_width).and_return(1)
+      create(:post, likes: 2)
+      expect(dimension.group_values).to eq [
+        { min: 0, max: 1 },
+        { min: 1, max: 2 },
+        { min: 2, max: 3 }
+      ]
+    end
+
+    it 'can be customized' do
+      dimension = new_dimension(bins: { min: 0, max: 1 })
+      expect(dimension.group_values).to eq [{ min: 0, max: 1 }]
+    end
+  end
+end

data/spec/active_reporter/dimension/category_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ActiveReporter::Dimension::Category do
+  def author_dimension(report)
+    described_class.new(:author, report, model: :authors, attribute: :name, relation: ->(r) { r.joins(
+      "LEFT OUTER JOIN authors ON authors.id = posts.author_id") })
+  end
+
+  describe '#filter' do
+    it 'filters to rows matching at least one value' do
+      p1 = create(:post, author: 'Alice')
+      p2 = create(:post, author: 'Bob')
+      p3 = create(:post, author: nil)
+
+      def filter_by(author_values)
+        report = OpenStruct.new(
+          table_name: 'posts',
+          params: { dimensions: { author: { only: author_values } } }
+        )
+        dimension = author_dimension(report)
+        dimension.filter(dimension.relate(Post))
+      end
+
+      expect(filter_by(['Alice'])).to eq [p1]
+      expect(filter_by([nil])).to eq [p3]
+      expect(filter_by(['Alice', nil])).to eq [p1, p3]
+      expect(filter_by(['Alice', 'Bob'])).to eq [p1, p2]
+      expect(filter_by([])).to eq []
+    end
+  end
+
+  describe '#group' do
+    it 'groups the relation by the exact value of the SQL expression' do
+      p1 = create(:post, author: 'Alice')
+      p2 = create(:post, author: 'Alice')
+      p3 = create(:post, author: nil)
+      p4 = create(:post, author: 'Bob')
+      p5 = create(:post, author: 'Bob')
+      p6 = create(:post, author: 'Bob')
+
+      report = OpenStruct.new(table_name: 'posts', params: {})
+      dimension = author_dimension(report)
+
+      results = dimension.group(dimension.relate(Post)).select("COUNT(*) AS count").map do |r|
+        r.attributes.values_at(dimension.send(:sql_value_name), 'count')
+      end
+
+      expect(results).to eq [[nil, 1], ['Alice', 2], ['Bob', 3]]
+    end
+  end
+
+  describe '#group_values' do
+    it 'echoes filter_values if filtering' do
+      dimension = author_dimension(OpenStruct.new(params: {
+        dimensions: { author: { only: ['foo', 'bar'] } }
+      }))
+      expect(dimension.group_values).to eq %w(foo bar)
+    end
+  end
+end

data/spec/active_reporter/dimension/enum_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe ActiveReporter::Dimension::Enum do
+  def new_dimension(dimension_params = {}, report_params = {}, opts = { model: :post })
+    report_params[:dimensions] = dimension_params
+    ActiveReporter::Dimension::Enum.new(
+      :status,
+      OpenStruct.new(params: report_params, groupers: { status: {}, category: {} }, raw_data: {
+        ['published', 'post_count'] => 5, ['published', 'post_total'] => 500.00, ['published', 'post_average'] => 100.00,
+        ['archived', 'post_count'] => 7, ['archived', 'post_total'] => 530.25, ['archived', 'post_average'] => 75.75,
+      }),
+      opts
+    )
+  end
+
+  def status_dimension(report)
+    described_class.new(:status, report, model: :posts, attribute: :status)
+  end
+
+  def author_dimension(report)
+    described_class.new(:author, report, model: :authors, attribute: :name, relation: ->(r) { r.joins(
+      "LEFT OUTER JOIN authors ON authors.id = posts.author_id") })
+  end
+
+  describe '#group_values' do
+    # it 'echoes filter_values if filtering' do
+    #   dimension = status_dimension(OpenStruct.new(params: {
+    #     groupers: [:status]
+    #   }))
+    #   expect(dimension.group_values).to eq [nil, 'draft', 'unpublished', 'published', 'archived']
+    # end
+
+
+    it 'determines #filtering?' do
+      dimension = new_dimension({ status: {}, category: {} }, { groupers: [:status] })
+      expect(dimension).not_to be_filtering
+      expect(dimension.group_values).to match %w(published archived)
+    end
+  end
+
+  # describe '#all_values' do
+  #   it 'returns model enum values' do
+  #     dimension = author_dimension(OpenStruct.new(params: {
+  #       dimensions: { author: { only: [nil, 'draft', 'unpublished', 'published', 'archived'] } }
+  #     }))
+  #     expect(dimension.all_values).to eq described_class.
+  #   end
+  # end
+
+  # describe '#filter' do
+  #   it 'filters to rows matching at least one value' do
+  #     p1 = create(:post, author: 'Alice')
+  #     p2 = create(:post, author: 'Bob')
+  #     p3 = create(:post, author: nil)
+
+  #     def filter_by(author_values)
+  #       report = OpenStruct.new(
+  #         table_name: 'posts',
+  #         params: { dimensions: { author: { only: author_values } } }
+  #       )
+  #       dimension = author_dimension(report)
+  #       dimension.filter(dimension.relate(Post))
+  #     end
+
+  #     expect(filter_by(['Alice'])).to eq [p1]
+  #     expect(filter_by([nil])).to eq [p3]
+  #     expect(filter_by(['Alice', nil])).to eq [p1, p3]
+  #     expect(filter_by(['Alice', 'Bob'])).to eq [p1, p2]
+  #     expect(filter_by([])).to eq []
+  #   end
+  # end
+
+  # describe '#group' do
+  #   it 'groups the relation by the exact value of the SQL expression' do
+  #     p1 = create(:post, author: 'Alice')
+  #     p2 = create(:post, author: 'Alice')
+  #     p3 = create(:post, author: nil)
+  #     p4 = create(:post, author: 'Bob')
+  #     p5 = create(:post, author: 'Bob')
+  #     p6 = create(:post, author: 'Bob')
+
+  #     report = OpenStruct.new(table_name: 'posts', params: {})
+  #     dimension = author_dimension(report)
+
+  #     results = dimension.group(dimension.relate(Post)).select("COUNT(*) AS count").map do |r|
+  #       r.attributes.values_at(dimension.send(:sql_value_name), 'count')
+  #     end
+
+  #     expect(results).to eq [[nil, 1], ['Alice', 2], ['Bob', 3]]
+  #   end
+  # end
+
+  
+end