mochigome 0.0.3 → 0.0.4

data/test/test_helper.rb

@@ -1,67 +1,67 @@
 ENV['RAILS_ENV'] = 'test'
 
-prev_dir = Dir.getwd
 begin
-  Dir.chdir("#{File.dirname(__FILE__)}/..")
-
-  begin
-    # Used when running test files directly
-    $LOAD_PATH << File.dirname(__FILE__)
-    $LOAD_PATH << "#{File.dirname(__FILE__)}/../lib"
-    require "#{File.dirname(__FILE__)}/app_root/config/environment"
-  rescue LoadError
-    # This is needed for root-level rake task 'test'
-    require "app_root/config/environment"
-  end
-ensure
-  Dir.chdir(prev_dir)
+  # Used when running test files directly
+  d = File.expand_path File.dirname(__FILE__)
+  $LOAD_PATH << d
+  $LOAD_PATH << "#{d}/../lib"
+  $LOAD_PATH << "#{d}/app_root/config"
+  require "environment"
+rescue LoadError
+  # This is needed for root-level rake task 'test'
+  require "app_root/config/environment"
 end
 
 require 'rubygems'
-require 'minitest/autorun'
-require 'redgreen'
 
-module MiniTest
-  def self.filter_backtrace(backtrace)
-    backtrace = backtrace.select do |e|
-      if ENV['FULL_BACKTRACE']
-        true
-      else
-        !(e.include?("/ruby/") || e.include?("/gems/"))
+if ENV['NO_MINITEST']
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate") # Migrations in the test app
+else
+  require 'minitest/autorun'
+  require 'redgreen'
+
+  module MiniTest
+    def self.filter_backtrace(backtrace)
+      backtrace = backtrace.select do |e|
+        if ENV['FULL_BACKTRACE']
+          true
+        else
+          !(e.include?("/ruby/") || e.include?("/gems/"))
+        end
       end
-    end
 
-    common_prefix = nil
-    backtrace.each do |elem|
-      next if elem.start_with? "./"
-      if common_prefix
-        until elem.start_with? common_prefix
-          common_prefix.chop!
+      common_prefix = nil
+      backtrace.each do |elem|
+        next if elem.start_with? "./"
+        if common_prefix
+          until elem.start_with? common_prefix
+            common_prefix.chop!
+          end
+        else
+          common_prefix = String.new(elem)
         end
-      else
-        common_prefix = String.new(elem)
       end
-    end
 
-    return backtrace.map do |element|
-      if element.start_with? common_prefix && common_prefix.size < element.size
-        element[common_prefix.size, element.size]
-      elsif element.start_with? "./"
-        element[2, element.size]
-      elsif element.start_with?(Dir.getwd)
-        element[Dir.getwd.size+1, element.size]
-      else
-        element
+      return backtrace.map do |element|
+        if element.start_with? common_prefix && common_prefix.size < element.size
+          element[common_prefix.size, element.size]
+        elsif element.start_with? "./"
+          element[2, element.size]
+        elsif element.start_with?(Dir.getwd)
+          element[Dir.getwd.size+1, element.size]
+        else
+          element
+        end
       end
     end
   end
-end
-
 
-require 'factories'
-MiniTest::Unit::TestCase.send(:include, Factory::Syntax::Methods)
+  require 'factories'
+  MiniTest::Unit::TestCase.send(:include, Factory::Syntax::Methods)
 
-MiniTest::Unit::TestCase.add_setup_hook do
-  ActiveRecord::Migration.verbose = false
-  ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate") # Migrations in the test app
+  MiniTest::Unit::TestCase.add_setup_hook do
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate") # Migrations in the test app
+  end
 end

data/test/unit/data_node_test.rb

@@ -77,6 +77,13 @@ describe Mochigome::DataNode do
       ]
       assert_equal @datanode.children.drop(1), new_children
     end
+
+    it "understands forward-slash to mean indexing in children" do
+      @datanode << Mochigome::DataNode.new(:subdata, :alice)
+      @datanode << Mochigome::DataNode.new(:subdata, :bob)
+      assert_equal @datanode.children[0], @datanode/0
+      assert_equal @datanode.children[1], @datanode/1
+    end
   end
 
   describe "when populated" do

data/test/unit/model_extensions_test.rb

@@ -1,31 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
-describe "an input string" do
-  it "will be converted by auto_numerify to an integer if appropriate" do
-    [35, -35, 0].each do |n|
-      result = Mochigome::ReportFocus.auto_numerify(n.to_s)
-      assert_equal n, result
-      assert_kind_of Integer, result
-    end
-  end
-
-  it "will be converted by auto_numerify to a float if appropriate" do
-    [-35.5, 35.5, 0.0].each do |n|
-      result = Mochigome::ReportFocus.auto_numerify(n.to_s)
-      assert_in_delta n, result
-      assert_kind_of Float, result
-    end
-  end
-
-  it "will remain a string if it is not numeric" do
-    ["", "zero", "yeehah", "foo0.0" "9.2bar"].each do |s|
-      result = Mochigome::ReportFocus.auto_numerify(s)
-      assert_equal s, result
-      assert_kind_of String, result
-    end
-  end
-end
-
 describe "an ActiveRecord model" do
   before do
     @model_class = Class.new(ActiveRecord::Base)
@@ -147,6 +121,27 @@ describe "an ActiveRecord model" do
     assert_equal "Moby Dick", i.mochigome_focus.name
   end
 
+  it "uses the primary key as the default ordering" do
+    @model_class.class_eval do
+      acts_as_mochigome_focus do |f|
+        f.name :last_name
+      end
+    end
+    assert_equal "id",
+      @model_class.mochigome_focus_settings.get_ordering
+  end
+
+  it "can specify a custom ordering" do
+    @model_class.class_eval do
+      acts_as_mochigome_focus do |f|
+        f.name :last_name
+        f.ordering :first_name
+      end
+    end
+    assert_equal "first_name",
+      @model_class.mochigome_focus_settings.get_ordering
+  end
+
   it "can specify fields" do
     @model_class.class_eval do
       acts_as_mochigome_focus do |f|
@@ -275,119 +270,141 @@ describe "an ActiveRecord model" do
     end
   end
 
-  it "appears in Mochigome's global model list if it acts_as_mochigome_focus" do
-    assert !Mochigome.reportFocusModels.include?(@model_class)
-    @model_class.class_eval do
-      acts_as_mochigome_focus
-    end
-    assert Mochigome.reportFocusModels.include?(@model_class)
-  end
+  # Actual use of aggregations is tested in query_test.
 
   it "can specify aggregated data to be collected" do
     @model_class.class_eval do
-      has_mochigome_aggregations [:average_x, :Count, "sum x"]
+      has_mochigome_aggregations do |a|
+        a.fields [
+          :average_x,
+          :Count,
+          {"bloo" => :sum_x}
+        ]
+      end
     end
-    # Peeking in past API to make sure it set the expressions correctly
     assert_equal [
-      {:name => "Whales average x", :expr => "avg(x)"},
-      {:name => "Whales Count", :expr => "count(*)"},
-      {:name => "Whales sum x", :expr => "sum(x)"}
-    ], @model_class.mochigome_aggregations
+      "Whales average x",
+      "Whales Count",
+      "bloo"
+    ], @model_class.mochigome_aggregation_settings.options[:fields].map{|a| a[:name]}
   end
 
   it "can specify aggregations with custom names" do
     @model_class.class_eval do
-      has_mochigome_aggregations [{"Mean X" => "avg x"}]
+      has_mochigome_aggregations do |a|
+        a.fields [{"Mean X" => "avg x"}]
+      end
     end
     assert_equal [
-      {:name => "Mean X", :expr => "avg(x)"}
-    ], @model_class.mochigome_aggregations
+      "Mean X"
+    ], @model_class.mochigome_aggregation_settings.options[:fields].map{|a| a[:name]}
   end
 
-  it "can specify aggregations with custom SQL expressions" do
+  it "can specify aggregations with custom arel expressions for value" do
     @model_class.class_eval do
-      has_mochigome_aggregations [{"The Answer" => "7*6"}]
+      has_mochigome_aggregations do |a|
+        a.fields [{"The Answer" => [:sum, lambda{|t| t[:some_number_column]*2}]}]
+      end
     end
     assert_equal [
-      {:name => "The Answer", :expr => "7*6"}
-    ], @model_class.mochigome_aggregations
+      "The Answer"
+    ], @model_class.mochigome_aggregation_settings.options[:fields].map{|a| a[:name]}
   end
 
-  it "can specify aggregations with custom conditions" do
+  it "can specify aggregations with custom arel expressions for aggregation" do
     @model_class.class_eval do
-      has_mochigome_aggregations [{"Blue Sales" => ["count", "color='blue'"]}]
+      has_mochigome_aggregations do |a|
+        a.fields [{"The Answer" => [lambda{|a| a.sum}, :some_col]}]
+      end
     end
     assert_equal [
-      {:name => "Blue Sales", :expr => "count(*)", :conditions => "color='blue'"}
-    ], @model_class.mochigome_aggregations
+      "The Answer"
+    ], @model_class.mochigome_aggregation_settings.options[:fields].map{|a| a[:name]}
   end
 
-  it "cannot call has_mochigome_aggregations with nonsense" do
+  it "cannot call aggregation fields method with nonsense" do
     assert_raises Mochigome::ModelSetupError do
       @model_class.class_eval do
-        has_mochigome_aggregations 3
+        has_mochigome_aggregations do |a|
+          a.fields 3
+        end
       end
     end
     assert_raises Mochigome::ModelSetupError do
       @model_class.class_eval do
-        has_mochigome_aggregations [42]
+        has_mochigome_aggregations do |a|
+          a.fields [42]
+        end
       end
     end
   end
 
-  describe "with some aggregatable data" do
-    before do
-      @store1 = create(:store)
-      @store2 = create(:store)
-      @product_a = create(:product, :name => "Product A", :price => 30)
-      @product_b = create(:product, :name => "Product B", :price => 50)
-      @sp1A = create(:store_product, :store => @store1, :product => @product_a)
-      @sp1B = create(:store_product, :store => @store1, :product => @product_b)
-      @sp2A = create(:store_product, :store => @store2, :product => @product_a)
-      @sp2B = create(:store_product, :store => @store2, :product => @product_b)
-      [
-        [2, @sp1A],
-        [4, @sp1B],
-        [7, @sp2A],
-        [3, @sp2B]
-      ].each do |num, sp|
-        num.times { create(:sale, :store_product => sp) }
+  it "can specify hidden aggregation fields" do
+    @model_class.class_eval do
+      has_mochigome_aggregations do |a|
+        a.hidden_fields [:count]
       end
     end
+    agg = @model_class.mochigome_aggregation_settings.options[:fields].first
+    assert_equal "Whales count", agg[:name]
+    assert agg[:hidden]
+  end
 
-    it "can collect aggregate data from a report focus through an association" do
-      assert_equal 9, @product_a.mochigome_focus.aggregate_data('sales')['Sales count']
-      assert_equal 7, @product_b.mochigome_focus.aggregate_data('sales')['Sales count']
-    end
-
-    it "can collect aggregate data through all known associations with :all keyword" do
-      assert_equal 9, @product_a.mochigome_focus.aggregate_data(:all)['Sales count']
+  it "can specify aggregation fields in ruby which post-process regular fields" do
+    @model_class.class_eval do
+      has_mochigome_aggregations do |a|
+        a.hidden_fields [:count]
+        a.fields_in_ruby [
+          {"Double count" => lambda{|row| row["Whales count"]*2}}
+        ]
+      end
     end
+    agg = @model_class.mochigome_aggregation_settings.options[:fields].last
+    assert_equal "Double count", agg[:name]
+    assert agg[:in_ruby]
+  end
 
-    it "returns both field data and all aggregate data with the data method" do
-      data = @product_a.mochigome_focus.data
-      assert_equal 9, data['Sales count']
-      assert_equal 30, data['price']
+  def assoc_query_words_match(assoc, words)
+    q = assoc.call(Arel::Table.new(:foo).project(Arel.star)).to_sql
+    cur_word = words.shift
+    q.split(/[ .]/).each do |s_word|
+      if s_word.gsub(/["'`]+/, '').downcase == cur_word.downcase
+        cur_word = words.shift
+      end
     end
+    return true if cur_word.nil?
+    raise "AQWM '#{q}': NO WORD MATCH ON '#{cur_word}'"
+  end
 
-    it "can return data aggregated in the context of another class with similar assoc" do
-      focus = @product_a.mochigome_focus
-      assert_equal 2, focus.aggregate_data('sales', :context => [@sp1A])['Sales count']
+  it "can convert a belongs_to association into a lambda that processes an arel relation" do
+    @model_class.class_eval do
+      belongs_to :store
     end
+    assert assoc_query_words_match @model_class.arelified_assoc(:store),
+      %w{select * from foo join stores on fake store_id = stores id}
+  end
 
-    it "can return data aggregated in the context through the data method" do
-      focus = @product_a.mochigome_focus
-      assert_equal 2, focus.data(:context => [@sp1A])['Sales count']
+  it "can convert a has_many association into an arel relation lambda" do
+    @model_class.class_eval do
+      has_many :stores
     end
+    assert assoc_query_words_match @model_class.arelified_assoc(:stores),
+      %w{select * from foo join stores on fake id = stores whale_id}
+  end
 
-    it "can return data aggregated using a custom sql expression" do
-      focus = @store1.mochigome_focus
-      assert_equal 9001, focus.data['Power level']
+  it "can convert a has_one association into an arel relation lambda" do
+    @model_class.class_eval do
+      has_one :store
     end
+    assert assoc_query_words_match @model_class.arelified_assoc(:store),
+      %w{select * from foo join stores on fake id = stores whale_id}
+  end
 
-    it "can return data aggregated using custom conditions" do
-      focus = @store1.mochigome_focus
-      assert_equal 1, focus.data['Expensive products']
+  it "raises AssociationError on attempting to arelify a non-extant assoc" do
+    assert_raises Mochigome::AssociationError do
+      Store.arelified_assoc(:dinosaurs)
     end
   end
+
+  # TODO: Test proper conditions used on polymorphic assocs
 end