wonkavision 0.5.11 → 0.6.0

data/test/aggregation_test.rb

@@ -0,0 +1,170 @@
+require "test_helper"
+
+class AggregationTest < ActiveSupport::TestCase
+  context "Aggregation" do
+    setup do
+      @facts = Class.new
+      @facts.class_eval do
+        include Wonkavision::Facts
+      end
+
+      @agg = Class.new
+      @agg.class_eval do
+        def self.name; "MyAggregation"; end
+        include Wonkavision::Aggregation
+        dimension :a, :b, :c
+
+        dimension :complex do
+          key :cpx
+        end
+
+        measure :d
+        store :hash_store
+      end
+      @agg.aggregates @facts
+
+    end
+
+    should "configure a specification" do
+      assert_not_nil @agg.aggregation_spec
+    end
+
+    should "set the name of the aggregation to the name of the class" do
+      assert_equal @agg.name, @agg.aggregation_spec.name
+    end
+
+    should "proxy relevant calls to the specification" do
+      assert_equal @agg.dimensions, @agg.aggregation_spec.dimensions
+      assert_equal 4, @agg.dimensions.length
+    end
+
+    should "create complex dimensions" do
+      assert_equal :cpx, @agg.dimensions[:complex].key
+    end
+
+    should "register itself with the module" do
+      assert_equal @agg, Wonkavision::Aggregation.all[@agg.name]
+    end
+
+    should "set the aggregates property" do
+      assert_equal @facts, @agg.aggregates
+    end
+
+    should "register itself with its associated Facts class" do
+      assert_equal 1, @facts.aggregations.length
+      assert_equal @agg, @facts.aggregations[0]
+    end
+
+    should "set the specified storage" do
+      assert @agg.store.kind_of?(Wonkavision::Analytics::Persistence::HashStore)
+      assert_equal @agg, @agg.store.owner
+    end
+
+    should "manage a list of cached instances keyed by dimension hashes" do
+      instance = @agg[{ "a" => { "a"=>:b}}]
+      assert_not_nil instance
+      assert_equal instance, @agg[{ "a" => { "a"=>:b}}]
+      assert_not_equal instance, @agg[{  "a" => { "a"=>:b},  "b" => { "b"=>:c}}]
+    end
+
+    should "store the dimension list with the instance" do
+      instance = @agg[{ "a" => { "a"=>:b}}]
+      assert_equal( { "a" => { "a"=>:b}}, instance.dimensions )
+    end
+
+    context "#query" do
+      should "create a new query" do
+        assert @agg.query(:defer=>true).kind_of?(Wonkavision::Analytics::Query)
+      end
+      should "apply a provided block to the query" do
+        assert_equal [:a], @agg.query(:defer=>true){ select :a }.selected_dimensions
+      end
+      should "raise an error if the query is invalid" do
+        assert_raise(RuntimeError) { @agg.query{ select :a, :on => :rows} }
+      end
+      should "execute the query against the configured store" do
+        @agg.store.expects(:execute_query).returns([])
+        @agg.query
+      end
+      should "return a cellset based on the query results" do
+        @agg.store.expects(:execute_query).returns([])
+        assert @agg.query.kind_of?(Wonkavision::Analytics::CellSet)
+      end
+    end
+
+    context "instance methods" do
+      setup do
+        @instance = @agg[{ "a" => { "a"=>:b}}]
+      end
+
+      context "#dimension_names" do
+        should "present dimension names as an array" do
+          assert_equal ["a"], @instance.dimension_names
+        end
+      end
+
+      context "#dimension_keys" do
+        should "present dimension keys as an array" do
+          assert_equal [:b], @instance.dimension_keys
+        end
+      end
+
+      context "#add" do
+        should "call update with the appropriate action" do
+          @instance.expects(:update).with({:a=>:b},:add)
+          @instance.add({:a=>:b})
+        end
+      end
+
+      context "#reject" do
+        should "call update with the appropriate action" do
+          @instance.expects(:update).with({ :a=>:b}, :reject)
+          @instance.reject({:a=>:b})
+        end
+      end
+
+      context "#measure_changes_for" do
+        setup do
+          @added = @instance.send(:measure_changes_for,"a", 1000, "add")
+          @rejected = @instance.send(:measure_changes_for,"a", 1000, "reject")
+        end
+
+        should "prepare a hash of measure components" do
+          assert_equal 3, @added.length
+        end
+        should "prepare a count component" do
+          assert_equal 1, @added["measures.a.count"]
+        end
+        should "prepare a sum component" do
+          assert_equal 1000, @added["measures.a.sum"]
+        end
+        should "prepare a sum2 component" do
+          assert_equal 1000*1000, @added["measures.a.sum2"]
+        end
+        should "reverse the sign of the measures when the action is reject" do
+          @rejected.values.each { |val| assert val < 0}
+        end
+      end
+
+      context "#update" do
+        should "prepare aggrgation data and submit it to store.update_aggregation" do
+          expected = {
+            :dimension_keys => [:b],
+            :dimension_names => ["a"],
+            :measures => {
+              "measures.d.count" => 1,
+              "measures.d.sum" => 1000,
+              "measures.d.sum2" => 1000*1000 },
+            :dimensions => { "a" => { "a"=>:b}}
+          }
+
+          @instance.class.store.expects(:update_aggregation).with(expected)
+          @instance.send(:update, { "d" => 1000}, :add)
+
+        end
+
+      end
+
+    end
+  end
+end

data/test/analytics/test_aggregation.rb

@@ -0,0 +1,78 @@
+module Rpm
+  class AccountSummary
+    include Wonkavision::Analytics::Aggregation
+
+    event 'wv.billing_record.sample_added',
+          'wv.billing_record.sample_retracted'
+
+    dimension :company_id
+    dimension :current_payer_class, :current_payer
+    dimension :primary_payer_class, :primary_payer
+    dimension :status_category, :status
+    dimension :age_category
+    dimension :has_credit_balance
+
+    measure :age_in_days
+    measure :write_offs, :charges, :payments, :current_balance
+
+    aggregate_by :company_id do
+      aggregate_by :status_category
+      aggregate_by :status
+      aggregate_by :primary_payer_class, :has_credit_balance
+      aggregate_by :current_payer_class, :has_credit_balance
+    end
+
+  end
+end
+
+#wv.billing_record.sample
+{
+  action => :add,
+  #dimension data
+  :company_id => "123",
+  :current_payer_class => "commercial",
+  :current_payer => "payer_xyz",
+  :primary_payer_class => "commercial",
+  :primary_payer => "payer_abc",
+  :status_category => "category 1",
+  :status => :"status 1",
+  :age_category => "0-30 days",
+  :has_credit_balance => true,
+  #measure data
+  :age_in_days => 21,
+  :write_offs => 123.45,
+  :charges => 456.78,
+  :payments => 12.34,
+  :current_balance => 320.99
+}
+#collection name:
+#wv.rpm.account_summary
+{
+  action => :add,
+  dimensions => { :status_category => "category 1"},
+  measures => {
+    :age_in_days => {
+      :count => 1,
+      :sum => 123,
+      :sum2 => 123,
+      :mean => 123,
+      ...
+
+    },
+    :write_offs => {
+      :count => 1,
+      :sum => 123,
+      ...
+    }
+  }
+}
+
+#wv.rpm.account_summary.samples
+{
+  dimensions => { :status_category => "category 1"},
+  measures => {
+    :age_in_days => [12 => 1, 34 => 10, ...]
+  }
+}
+
+

data/test/apply_aggregation_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class ApplyAggregationTest < ActiveSupport::TestCase
+  context "ApplyAggregation" do
+    setup do
+      @agg = Class.new
+      @agg.class_eval do
+        def self.name; "MyAggregation" end
+        include Wonkavision::Aggregation
+        dimension :a, :b, :c
+        measure :d, :e
+        aggregate_by :a, :b
+        aggregate_by :a, :b, :c
+        store :hash_store
+      end
+      @handler = Wonkavision::Analytics::ApplyAggregation.new
+    end
+
+    should "initialize with the appropriate namespace" do
+      assert_equal Wonkavision.join("wv", "analytics"), @handler.class.event_namespace
+    end
+
+    context "#aggregation_for" do
+      should "look up an aggregation for the provided name" do
+        assert_equal @agg, @handler.aggregation_for(@agg.name)
+      end
+    end
+
+    context "#process_event" do
+      should "return false unless all appropriate metadata is present and valid" do
+        assert_equal false, @handler.process_event({"aggregation"=>"ack",
+                                                     "action"=>"add","measures"=>{},
+                                                     "dimensions"=>{}})
+
+        assert_equal false, @handler.process_event( { "aggregation"=>@agg.name,
+                                                      "action"=>"add","measures"=>{}})
+
+        assert_equal false, @handler.process_event( { "aggregation"=>@agg.name,
+                                                      "measures"=>{},"dimensions"=>{}})
+      end
+
+      context "with a valid message" do
+        setup do
+          @message = {
+            "aggregation" => @agg.name,
+            "action" => "add",
+            "dimensions" => { "a" => { "a" => :a }, "b" =>{ "b" => :b}, "c" => { "c" =>  :c } },
+            "measures" =>{ "d" => 1.0, "e" => 2.0 }
+          }
+
+        end
+
+        should "instantiate a new aggregation with the dimensions in the message" do
+          aggregator = @agg.new(@message["dimensions"])
+          @agg.expects(:new).with(@message["dimensions"]).returns(aggregator)
+          @handler.process_event(@message)
+        end
+        should "add measures if the action is add" do
+          @agg.any_instance.expects(:add).with(@message["measures"])
+          @handler.process_event(@message)
+        end
+        should "reject measures if the action is reject" do
+          @message["action"] = "reject"
+          @agg.any_instance.expects(:reject).with(@message["measures"])
+          @handler.process_event(@message)
+        end
+        should "raise an error if the action is anything other than add or reject" do
+          @message["action"] = "whateva"
+          assert_raise(RuntimeError) { @handler.process_event(@message) }
+        end
+        should "do nothing if measures is empty" do
+          @message["measures"] = { "d" => nil, "e" => nil}
+          @agg.any_instance.expects(:add).never
+          @handler.process_event(@message)
+        end
+
+
+      end
+
+    end
+
+
+    context "will listen for aggregation updated messages" do
+      should "respond to aggregation updated messages" do
+        Wonkavision::Analytics::ApplyAggregation.any_instance.expects(:process_event)
+        Wonkavision.event_coordinator.receive_event("wv/analytics/aggregation/updated",{ :a=>:b})
+      end
+    end
+
+  end
+
+end

data/test/attribute_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+class AttributeTest < ActiveSupport::TestCase
+  context "Attribute" do
+    setup do
+      @attribute = Wonkavision::Plugins::Aggregation::Attribute.new(:my_attribute,:an_option=>true)
+    end
+
+    should "take its name from the constructor" do
+      assert_equal :my_attribute, @attribute.name
+    end
+
+    should "take its options from the constructor" do
+      assert_equal( { :an_option => true}, @attribute.options )
+    end
+
+    context "#extract" do
+      should "extract a value from a hash based on the name of the attribute" do
+        assert_equal "hi", @attribute.extract({ "my_attribute" => "hi"})
+      end
+
+    end
+
+
+  end
+end

data/test/cellset_test.rb

@@ -0,0 +1,200 @@
+require "test_helper"
+require File.join $test_dir, "test_aggregation.rb"
+
+
+class CellSetTest < ActiveSupport::TestCase
+  Query = Wonkavision::Analytics::Query
+  CellSet = Wonkavision::Analytics::CellSet
+
+  context "CellSet" do
+    setup do
+      @aggregation = ::TestAggregation
+      test_data = File.join $test_dir, "test_data.tuples"
+      @test_data = eval(File.read(test_data))
+      @query = Wonkavision::Analytics::Query.new
+      @query.select :size, :shape, :on => :columns
+      @query.select :color, :on => :rows
+      @query.where  :dimensions.color.ne => "black"
+      @cellset = CellSet.new @aggregation, @query, @test_data
+    end
+
+    context "Public API" do
+      context "#initialize" do
+        should "initialize axes" do
+          assert_equal 2, @cellset.axes.length
+        end
+
+        should "populate dimension members from tuples" do
+          @cellset.axes.each do |axis|
+            axis.dimensions.each do |dimension|
+              assert dimension.members.length > 0
+            end
+          end
+        end
+
+        should "populate cells from tuples" do
+          assert_equal @test_data.length - 2, @cellset.length #2 records filtered out (color=black)
+        end
+      end
+      context "#[]" do
+        should "locate a cell based on its coordinates, specified in query order" do
+          cell = @cellset[:large, :square, :red]
+          assert_not_nil cell
+          assert_equal ["large", "square", "red"], cell.key
+          assert_equal 10, cell.cost.count
+        end
+      end
+      context "#length" do
+        should "return the number of total tuples in the set" do
+          assert_equal @test_data.length - 2, @cellset.length #2 records filtered out (color = black)
+        end
+      end
+    end
+    context "Implementation" do
+      context "#process_tuples" do
+        setup do
+          @dims, @cells = @cellset.send(:process_tuples, @aggregation, @query, @test_data)
+        end
+        context "processed cells" do
+          should "contain one entry for each matching tuple" do
+            assert_equal @test_data.length - 2, @cells.length #2 records are black, and filtered
+          end
+          should "be keyed by a query-ordered array of dimension keys" do
+            test_key = @cells.keys.find { |key|key - ["red", "square", "large"] == []}
+            assert_equal ["large", "square", "red"], test_key
+          end
+        end
+        context "processed dimension members" do
+          should "contain one entry for each dimension" do
+            assert_equal 3, @dims.length
+            @query.selected_dimensions.each { |dim| assert @dims.keys.include?(dim.to_s)}
+          end
+          should "provide a hash of members for the dimensions" do
+            test_dim = @dims["color"]
+            %w(red green yellow white).each do |mem_key| #black is filtered out
+              assert test_dim.keys.include?(mem_key)
+            end
+          end
+          should "include the dimension attributes in the member hash" do
+            test_dim = @dims["color"]
+            assert_equal( { "color" => "red" }, test_dim["red"] )
+          end
+        end
+      end
+      context "#key_for" do
+        setup do
+          @record = {
+            "dimension_keys"=>["yellow", "square", "small"],
+            "dimension_names"=>["color", "shape", "size"] }
+        end
+        should "re-order the dimension_keys array to match query order" do
+          assert_equal ["small", "square", "yellow"], @cellset.send(:key_for,@query,@record)
+        end
+      end
+      context "Support Classes" do
+        context "Axis" do
+          setup {  @axis = @cellset.columns }
+          context "#initialize" do
+            should "initialize a Dimension object for each dimension" do
+              assert_equal 2, @axis.dimensions.length
+            end
+            should "order dimensions in query order" do
+              assert_equal "size", @axis.dimensions[0].name
+              assert_equal "shape", @axis.dimensions[1].name
+            end
+          end
+        end
+        context "Dimension" do
+          setup { @dimension = @cellset.columns.dimensions[0] }
+          context "#initialize" do
+            should "should return #name" do
+              assert_equal "size", @dimension.name
+            end
+            should "extract its definition from the aggregation" do
+              assert_equal @aggregation.dimensions["size"], @dimension.definition
+            end
+            should "should contain a sorted list of members" do
+              %w(large medium small).each_with_index do |size,idx|
+                assert_equal size, @dimension.members[idx].key
+              end
+            end
+          end
+        end
+        context "Member" do
+          setup {  @member = @cellset.columns.dimensions[0].members[0]}
+          should "maintain a reference to its parent dimension" do
+            assert_equal @cellset.columns.dimensions[0], @member.dimension
+          end
+          should "provide named access to the main dimension attributes" do
+            assert_equal "large", @member.caption
+            assert_equal "large", @member.key
+            assert_equal "large", @member.sort
+          end
+          should "provide access to the raw attribute hash" do
+            assert_equal( { "size" => "large"}, @member.attributes )
+          end
+        end
+        context "Cell" do
+          setup {  @cell = @cellset[:large, :square, :red] }
+          should "provide access to the cell key" do
+            assert_equal ["large", "square", "red"], @cell.key
+          end
+          should "include a hash of measures" do
+            %w(cost weight).each { |measure| assert @cell.measures.keys.include?(measure)}
+          end
+          should "provide named access to each measure" do
+            assert_equal @cell.measures["cost"], @cell.cost
+            assert_equal @cell.measures["weight"], @cell.weight
+          end
+          context "#aggregate" do
+            setup do
+              @cell.aggregate({"cost"=>{ "count"=>1,"sum"=>1,"sum2"=>2},
+                                "different"=>{ "count"=>2,"sum"=>2,"sum2"=>8}})
+
+            end
+            should "insert any new measures" do
+              assert @cell.measures.keys.include?("different")
+            end
+            should "aggregate data from an existing measure" do
+              assert_equal 11, @cell.cost.count
+              assert_equal 51, @cell.cost.sum
+              assert_equal 252, @cell.cost.sum2
+            end
+
+          end
+        end
+
+        context "Measure" do
+          setup { @measure = @cellset[:large, :square, :red].cost }
+          should "provide access to its name" do
+            assert_equal "cost", @measure.name
+          end
+          should "provide access to the measure hash" do
+            assert_equal( {"count"=>10, "sum"=>50, "sum2"=>250}, @measure.data )
+          end
+          should "provide named hash to measure values" do
+            assert_equal 10, @measure.count
+            assert_equal 50, @measure.sum
+            assert_equal 250, @measure.sum2
+          end
+          should "calculate an average" do
+            assert_equal 5, @measure.average
+          end
+          context "#aggregate" do
+            setup do
+              @measure.aggregate(@measure.data.dup)
+            end
+            should "add sum, sum2 and count to the existing values" do
+              assert_equal 20, @measure.count
+              assert_equal 100, @measure.sum
+              assert_equal 500, @measure.sum2
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end