mochigome 0.0.3 → 0.0.4

data/test/unit/query_test.rb

@@ -3,12 +3,9 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 describe Mochigome::Query do
   before do
     @category1 = create(:category, :name => "Category 1")
-    @product_a = create(:product, :name => "Product A", :category => @category1)
+    @product_a = create(:product, :name => "Product A", :category => @category1, :price => 5)
     @product_b = create(:product, :name => "Product B", :category => @category1)
 
-    # Belongs to a category, but fails Category's has_many(:products) conditions
-    @product_x = create(:product, :name => "Product X", :category => @category1, :categorized => false)
-
     @category2 = create(:category, :name => "Category 2")
     @product_c = create(:product, :name => "Product C", :category => @category2)
     @product_d = create(:product, :name => "Product D", :category => @category2)
@@ -43,10 +40,20 @@ describe Mochigome::Query do
     end
   end
 
-  # Convenience function to check DataSet output validity
-  def assert_equal_objs(a, b)
+  after do
+    Category.delete_all
+    Product.delete_all
+    Owner.delete_all
+    Store.delete_all
+    StoreProduct.delete_all
+    Sale.delete_all
+  end
+
+  # Convenience functions to check DataNode output validity
+
+  def assert_equal_children(a, node)
+    b = node.children
     assert_equal a.size, b.size
-    # Not checking aggregate data because we don't know about a's context here
     a.zip(b).each do |obj, fields|
       obj.mochigome_focus.field_data.each do |k,v|
         assert_equal v, fields[k]
@@ -54,60 +61,93 @@ describe Mochigome::Query do
     end
   end
 
-  it "returns an empty DataNode if no objects given" do
+  def assert_no_children(obj)
+    assert_empty obj.children
+  end
+
+  it "returns an empty DataNode if given an empty array" do
     q = Mochigome::Query.new([Category, Product])
     data_node = q.run([])
     assert_empty data_node
-    assert_empty data_node.children
+    assert_no_children data_node
   end
 
-  it "can build a one-layer DataNode" do
+  it "returns all possible results if no conditions given" do
+    q = Mochigome::Query.new([Category, Product])
+    data_node = q.run()
+    assert_equal 2, data_node.children.size
+    assert_equal 4, (data_node/0).children.size + (data_node/1).children.size
+  end
+
+  it "can build a one-layer DataNode given an object with an id to focus on" do
     q = Mochigome::Query.new([Product])
     data_node = q.run(@product_a)
-    assert_equal_objs [@product_a], data_node.children
-    assert_empty data_node.children[0].children
+    assert_equal_children [@product_a], data_node
+    assert_no_children data_node/0
+  end
+
+  it "can build a one-layer DataNode when given an arbitrary Arel condition" do
+    q = Mochigome::Query.new([Product])
+    tbl = Arel::Table.new(Product.table_name)
+    data_node = q.run(tbl[:name].eq(@product_a.name))
+    assert_equal_children [@product_a], data_node
+    assert_no_children data_node/0
+  end
+
+  it "orders by ID by default" do
+    q = Mochigome::Query.new([Product])
+    data_node = q.run([@product_b, @product_a, @product_c])
+    assert_equal_children [@product_a, @product_b, @product_c], data_node
+  end
+
+  it "orders by custom fields when the model focus settings specify so" do
+    q = Mochigome::Query.new([Category])
+    catZ = create(:category, :name => "Zebras") # Created first, has lower ID
+    catA = create(:category, :name => "Apples")
+    data_node = q.run([catZ, catA])
+    assert_equal catA.name, (data_node/0).name
+    assert_equal catZ.name, (data_node/1).name
   end
 
   it "uses the model focus's type name for the DataNode's type name" do
     q = Mochigome::Query.new([Store])
     data_node = q.run(@store_x)
-    assert_equal "Storefront", data_node.children[0].type_name.to_s
+    assert_equal "Storefront", (data_node/0).type_name.to_s
   end
 
   it "adds an internal_type attribute containing the model class's name" do
     q = Mochigome::Query.new([Store])
     data_node = q.run(@store_x)
-    assert_equal "Store", data_node.children[0][:internal_type]
+    assert_equal "Store", (data_node/0)[:internal_type]
   end
 
   it "can build a two-layer tree from a record with a belongs_to association" do
     q = Mochigome::Query.new([Category, Product])
     data_node = q.run(@product_a)
-    assert_equal_objs [@category1], data_node.children
-    assert_equal_objs [@product_a], data_node.children[0].children
-    assert_empty data_node.children[0].children[0].children
+    assert_equal_children [@category1], data_node
+    assert_equal_children [@product_a], data_node/0
+    assert_no_children data_node/0/0
   end
 
   it "can build a two-layer tree from an array of records in the second layer" do
     q = Mochigome::Query.new([Category, Product])
     data_node = q.run([@product_a, @product_d, @product_b])
-    assert_equal_objs [@category1, @category2], data_node.children
-    assert_equal_objs [@product_a, @product_b], data_node.children[0].children
-    assert_equal_objs [@product_d], data_node.children[1].children
+    assert_equal_children [@category1, @category2], data_node
+    assert_equal_children [@product_a, @product_b], data_node/0
+    assert_equal_children [@product_d], data_node/1
   end
 
   it "can build a two-layer tree from a record with a has_many association" do
     q = Mochigome::Query.new([Category, Product])
     data_node = q.run(@category1)
-    assert_equal_objs [@category1], data_node.children
-    assert_equal_objs [@product_a, @product_b], data_node.children[0].children
-    assert_empty data_node.children[0].children[0].children
+    assert_equal_children [@category1], data_node
+    assert_equal_children [@product_a, @product_b], data_node/0
+    assert_no_children data_node/0/0
   end
 
-  it "cannot build a DataNode tree when given disconnected layers" do
-    q = Mochigome::Query.new([Category, BoringDatum])
+  it "cannot build a Query through disconnected layers" do
     assert_raises Mochigome::QueryError do
-      data_node = q.run(@category1)
+      q = Mochigome::Query.new([Category, BoringDatum])
     end
   end
 
@@ -119,70 +159,158 @@ describe Mochigome::Query do
       [@product_a, @product_b, @product_c, @product_d, @product_e]
     ].each do |tgt|
       data_node = q.run(tgt)
-      assert_equal_objs [@john, @jane], data_node.children
-      assert_equal_objs [@store_x], data_node.children[0].children
-      assert_equal_objs [@store_y, @store_z], data_node.children[1].children
-      assert_equal_objs [@product_a, @product_c],
-        data_node.children[0].children[0].children
-      assert_equal_objs [@product_c, @product_d],
-        data_node.children[1].children[1].children
+      assert_equal_children [@john, @jane], data_node
+      assert_equal_children [@store_x], data_node/0
+      assert_equal_children [@store_y, @store_z], data_node/1
+      assert_equal_children [@product_a, @product_c], data_node/0/0
+      assert_equal_children [@product_c, @product_d], data_node/1/1
     end
   end
 
-  it "collects aggregate data in the context of all layers when traversing down" do
-    q = Mochigome::Query.new([Owner, Store, Product])
+  it "collects aggregate data by grouping on all layers" do
+    q = Mochigome::Query.new(
+      [Owner, Store, Product],
+      :aggregate_sources => [[Product, Sale]]
+    )
+
     data_node = q.run([@john, @jane])
     # Store X, Product C
-    assert_equal "Product C", data_node.children[0].children[0].children[1].name
-    assert_equal 3, data_node.children[0].children[0].children[1]['Sales count']
+    assert_equal "Product C", (data_node/0/0/1).name
+    assert_equal 3, (data_node/0/0/1)['Sales count']
     # Store Z, Product C
-    assert_equal "Product C", data_node.children[1].children[1].children[0].name
-    assert_equal 2, data_node.children[1].children[1].children[0]['Sales count']
-  end
+    assert_equal "Product C", (data_node/1/1/0).name
+    assert_equal 2, (data_node/1/1/0)['Sales count']
 
-  it "collects aggregate data in the context of all layers when traversing up" do
-    q = Mochigome::Query.new([Owner, Store, Product])
     data_node = q.run(@product_c)
     # Store X, Product C
-    assert_equal "Product C", data_node.children[0].children[0].children[0].name
-    assert_equal 3, data_node.children[0].children[0].children[0]['Sales count']
+    assert_equal "Product C", (data_node/0/0/0).name
+    assert_equal 3, (data_node/0/0/0)['Sales count']
     # Store Z, Product C
-    assert_equal "Product C", data_node.children[1].children[0].children[0].name
-    assert_equal 2, data_node.children[1].children[0].children[0]['Sales count']
+    assert_equal "Product C", (data_node/1/0/0).name
+    assert_equal 2, (data_node/1/0/0)['Sales count']
+  end
+
+  it "collects aggregate data on layers above the focus" do
+    q = Mochigome::Query.new(
+      [Owner, Store, Product],
+      :aggregate_sources => [[Product, Sale]]
+    )
+
+    data_node = q.run([@john, @jane])
+
+    assert_equal "Jane's Store (North)", (data_node/1/0).name
+    assert_equal 11, (data_node/1/0)['Sales count']
+
+    assert_equal "Jane Doe", (data_node/1).name
+    assert_equal 16, (data_node/1)['Sales count']
+
+    assert_equal 24, data_node['Sales count']
   end
 
-  it "collects aggregate data in the context of distant layers" do
-    # TODO: Implement me! I think this is necessary to justify focus_data_node_objs passing obj_stack
+  it "can do conditional counts" do
+    q = Mochigome::Query.new(
+      [Category],
+      :aggregate_sources => [[Category, Product]]
+    )
+    data_node = q.run([@category1, @category2])
+    assert_equal 1, (data_node/0)['Expensive products']
+    assert_equal 2, (data_node/1)['Expensive products']
   end
 
+  it "can do sums" do
+    q = Mochigome::Query.new(
+      [Owner, Store],
+      :aggregate_sources => [[Store, Product]]
+    )
+    data_node = q.run([@john])
+    assert_equal (@product_a.price + @product_c.price),
+      data_node['Products sum price']
+  end
+
+  it "still does conditional counts correctly when joins below focus used" do
+    af = proc do |cls|
+      return {} unless cls == Product
+      return {
+        :join_paths => [[Product, StoreProduct, Store]]
+      }
+    end
+    q = Mochigome::Query.new(
+      [Category],
+      :aggregate_sources => [[Category, Product]],
+      :access_filter => af
+    )
+    data_node = q.run([@category1, @category2])
+    assert_equal 1, (data_node/0)['Expensive products']
+    assert_equal 2, (data_node/1)['Expensive products']
+  end
+
+  it "still does sums correctly when joins below focus are used" do
+    af = proc do |cls|
+      return {} unless cls == Store
+      return {
+        :join_paths => [[Store, StoreProduct, Sale]]
+      }
+    end
+    q = Mochigome::Query.new(
+      [Owner, Store],
+      :aggregate_sources => [[Store, Product]],
+      :access_filter => af
+    )
+    data_node = q.run([@john])
+    assert_equal (@product_a.price + @product_c.price),
+      data_node['Products sum price']
+  end
+
+  it "does not include hidden aggregation fields in output" do
+    q = Mochigome::Query.new(
+      [Owner, Store],
+      :aggregate_sources => [[Store, Product]]
+    )
+    data_node = q.run([@john])
+    refute data_node.has_key?('Secret count')
+  end
+
+  it "correctly runs aggregation fields implemented in ruby" do
+    q = Mochigome::Query.new(
+      [Owner, Store],
+      :aggregate_sources => [[Store, Product]]
+    )
+    data_node = q.run([@john])
+    assert_equal 4, data_node["Count squared"]
+  end
+
+  # TODO: Test case where data model is already in layer path
+  # TODO: Test case where the condition is deeper than the focus model
+  # TODO: Test use of non-trivial function for aggregation value
+
   it "puts a comment on the root node describing the query" do
     q = Mochigome::Query.new([Owner, Store, Product])
     data_node = q.run([@store_x, @store_y, @store_z])
     c = data_node.comment
     assert_match c, /^Mochigome Version: #{Mochigome::VERSION}\n/
-    assert_match c, /\nTime: \w{3} \w{3} \d+ .+\n/
+    assert_match c, /\nReport Generated: \w{3} \w{3} \d+ .+\n/
     assert_match c, /\nLayers: Owner => Store => Product\n/
-    assert_match c, /\nAR Association Path:\n\* <- Owner.+\n\* == Store.+\n\* -> Product.+\n/
+    assert_match c, /\nAR Path: Owner => Store => StoreProduct => Product\n/
   end
 
-  it "puts a descriptive comment on the first node of each layer" do
+  it "names the root node 'report' by default" do
     q = Mochigome::Query.new([Owner, Store, Product])
     data_node = q.run([@store_x, @store_y, @store_z])
+    assert_equal "report", data_node.name
+  end
 
-    owner_comment = data_node.children[0].comment
-    assert owner_comment
-    assert_nil data_node.children[1].comment # No comment on second owner
-
-    store_comment = data_node.children[0].children[0].comment
-    assert store_comment
-    assert_nil data_node.children[1].children[0].comment # No comment on second store
-
-    product_comment = data_node.children[0].children[0].children[0].comment
-    assert product_comment
-    assert_nil data_node.children[0].children[0].children[1].comment # No comment on 2nd product
+  it "can set the root node's name to a provided value" do
+    q = Mochigome::Query.new(
+      [Owner, Store, Product],
+      :root_name => "cheese"
+    )
+    data_node = q.run([@store_x, @store_y, @store_z])
+    assert_equal "cheese", data_node.name
+  end
 
-    [owner_comment, store_comment, product_comment].each do |comment|
-      assert_match comment, /^Context:\nOwner:#{@john.id}.*\n/ # Owner is always in context
+  it "will complain if initialized with an unknown option" do
+    assert_raises Mochigome::QueryError do
+      q = Mochigome::Query.new([Owner, Store, Product], :flim_flam => 123)
     end
   end
 
@@ -199,4 +327,45 @@ describe Mochigome::Query do
       q.run(@category1)
     end
   end
+
+  it "can use a provided access filter function to limit query results" do
+    af = proc do |cls|
+      return {} unless cls == Product
+      return {
+        :condition => Arel::Table.new(Product.table_name)[:category_id].gt(0)
+      }
+    end
+    q = Mochigome::Query.new([Product], :access_filter => af)
+    dn = q.run(Product.all) # FIXME: Need a better way of doing "all objs" queries
+    assert_equal 4, dn.children.size
+    refute dn.children.any?{|c| c.name == "Product E"}
+  end
+
+  it "can do joins at the request of an access filter" do
+    af = proc do |cls|
+      return {} unless cls == Product
+      return {
+        :join_paths => [[Product, StoreProduct, Store]],
+        :condition => Arel::Table.new(Store.table_name)[:name].matches("Jo%")
+      }
+    end
+    q = Mochigome::Query.new([Product], :access_filter => af)
+    dn = q.run(Product.all) # FIXME: Need a better way of doing "all objs" queries
+    assert_equal 2, dn.children.size
+    refute dn.children.any?{|c| c.name == "Product E"}
+  end
+
+  it "access filter joins will not duplicate joins already in the query" do
+    af = proc do |cls|
+      return {} unless cls == Product
+      return {
+        :join_paths => [[Product, StoreProduct, Store]],
+        :condition => Arel::Table.new(Store.table_name)[:name].matches("Jo%")
+      }
+    end
+    q = Mochigome::Query.new([Product, Store], :access_filter => af)
+    assert_equal 1, q.instance_variable_get(:@ids_rel).to_sql.scan(/join .stores./i).size
+  end
+
+  # TODO: Test that access filter join paths are followed, rather than closest path
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,10 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-14 00:00:00 Z
+date: 2012-03-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  requirement: *id001
+  prerelease: false
+  type: :runtime
+  name: arel
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -27,12 +42,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  version_requirements: *id001
-  name: ruport
+  requirement: *id002
   prerelease: false
   type: :runtime
+  name: ruport
 - !ruby/object:Gem::Dependency 
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -41,12 +56,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  version_requirements: *id002
-  name: nokogiri
+  requirement: *id003
   prerelease: false
   type: :runtime
+  name: nokogiri
 - !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -55,11 +70,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  version_requirements: *id003
-  name: rgl
+  requirement: *id004
   prerelease: false
   type: :runtime
-description: Mochigome builds sophisticated report datasets from your ActiveRecord models
+  name: rgl
+description: Report generator that uses your ActiveRecord associations
 email: david.mike.simon@gmail.com
 executables: []
 
@@ -75,6 +90,7 @@ files:
 - README.rdoc
 - Rakefile
 - TODO
+- lib/arel_rails2_hacks.rb
 - lib/data_node.rb
 - lib/exceptions.rb
 - lib/mochigome.rb
@@ -96,11 +112,13 @@ files:
 - test/app_root/config/database.yml
 - test/app_root/config/environment.rb
 - test/app_root/config/environments/test.rb
+- test/app_root/config/initializers/arel.rb
 - test/app_root/config/offroad.yml
 - test/app_root/config/preinitializer.rb
 - test/app_root/config/routes.rb
 - test/app_root/db/migrate/20110817163830_create_tables.rb
 - test/app_root/vendor/plugins/mochigome/init.rb
+- test/console.sh
 - test/factories.rb
 - test/test.watchr
 - test/test_helper.rb