wonkavision 0.5.11 → 0.6.0

data/test/query_test.rb

@@ -0,0 +1,106 @@
+require "test_helper"
+
+class QueryTest < ActiveSupport::TestCase
+  Query = Wonkavision::Analytics::Query
+
+  context "Query" do
+    setup do
+      @query = Query.new
+    end
+
+    context "Class methods" do
+      context "#axis_ordinal" do
+        should "convert nil or empty string to axis zero" do
+          assert_equal 0, Query.axis_ordinal(nil)
+          assert_equal 0, Query.axis_ordinal("")
+        end
+        should "convert string integers into real integers" do
+          assert_equal 3, Query.axis_ordinal("3")
+        end
+        should "correctly interpret named axes" do
+          ["Columns", :rows, :PAGES, "chapters", "SECTIONS"].each_with_index do |item,idx|
+            assert_equal idx, Query.axis_ordinal(item)
+          end
+        end
+
+      end
+    end
+
+    context "#select" do
+      should "associate dimensions with the default axis (columns)" do
+        @query.select :hi, :there
+        assert_equal [:hi,:there], @query.axes[0]
+      end
+      should "associate dimensions with the specified axis" do
+        @query.select :hi, :there, :on => :rows
+        assert_equal [:hi, :there], @query.axes[1]
+      end
+    end
+
+    context "#selected_dimensions" do
+      should "collect dimensions from each axis" do
+        @query.select :c, :d; @query.select :b, :a, :on => :rows
+        assert_equal [:c,:d,:b,:a], @query.selected_dimensions
+      end
+    end
+
+    context "#referenced_dimensions" do
+      should "match selected dimensions with no dimension filters" do
+        @query.select :c, :d
+        assert_equal @query.selected_dimensions, @query.referenced_dimensions
+      end
+      should "include filter dimensions in the presence of a dimension filter"do
+        @query.select(:c,:d).where(:e=>:f)
+        assert_equal 3,  @query.referenced_dimensions.length
+        assert_equal [], @query.referenced_dimensions - [:c, :d, :e]
+      end
+    end
+
+    context "#matches_filter?" do
+      should "return true if all filters are applied" do
+        @query.expects(:all_filters_applied?).returns(true)
+        assert @query.matches_filter?(nil,nil)
+      end
+    end
+
+    context "#where" do
+      should "convert a symbol to a MemberFilter" do
+        @query.where :a=>:b
+        assert @query.filters[0].kind_of?(Wonkavision::Analytics::MemberFilter)
+      end
+
+      should "append filters to the filters array" do
+        @query.where :a=>:b, :c=>:d
+        assert_equal 2, @query.filters.length
+      end
+
+      should "set the member filters value from the hash" do
+        @query.where :a=>:b
+        assert_equal :b, @query.filters[0].value
+      end
+
+      should "add dimension names to the slicer" do
+        @query.where :dimensions.a => :b
+        assert @query.slicer.include?(:a)
+      end
+
+      should "not add measure names to the slicer" do
+        @query.where :measures.a => :b
+        assert @query.slicer.include?(:a) == false
+      end
+
+    end
+
+    context "#slicer" do
+      setup do
+        @query.select :a, :b
+        @query.where :dimensions.b=>:b, :dimensions.c=>:c
+      end
+      should "include only dimensions not on another axis" do
+        assert_equal [:c], @query.slicer
+      end
+
+    end
+
+  end
+end

data/test/split_by_aggregation_test.rb

@@ -0,0 +1,114 @@
+require "test_helper"
+
+class SplitByAggregationTest < ActiveSupport::TestCase
+  context "SplitByAggregation" 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::SplitByAggregation.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 "#split_dimensions_by_aggregation" do
+      setup do
+        @entity = {"a" => :a, "b" => :b, "c" => :c, "d" => :d, "e" => :e}
+        @split = @handler.split_dimensions_by_aggregation(@agg,@entity)
+      end
+      should "create one entry per aggregate_by" do
+        assert_equal 2, @split.length
+      end
+      should "create a hash of key values for each aggregation" do
+        assert_equal( { "a" => { "a" => :a}, "b" => { "b"=>:b} }, @split[0] )
+        assert_equal( { "a" => { "a" => :a}, "b" => { "b"=>:b} , "c"=>{ "c"=>:c} }, @split[1] )
+      end
+    end
+
+    context "#process_aggregations" do
+      should "call process on each message in the batch" do
+        path = Wonkavision.join("wv", "analytics", "aggregation", "updated")
+        @handler.expects(:submit).with(path, { :hi => "there"})
+        @handler.process_aggregations [{ :hi => "there"}]
+      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","data"=>{}})
+
+        assert_equal false, @handler.process_event( { "aggregation"=>@agg.name,
+                                                     "action"=>"add"})
+
+        assert_equal false, @handler.process_event( { "aggregation"=>@agg.name,
+                                                     "data"=>{}})
+      end
+      context "with a valid message" do
+        setup do
+          @message = {
+            "aggregation" => @agg.name,
+            "action" => "add",
+            "data" => {
+              "a" => :a, "b" => :b, "c" => :c,
+              "d" => 1.0, "e" => 2.0
+            }
+          }
+        end
+
+        should "prepare a message for each aggregation" do
+          assert_equal 2, @handler.process_event(@message).length
+        end
+
+        should "submit each message for processing" do
+          @handler.expects(:submit).times(2)
+          @handler.process_event(@message)
+        end
+
+        should "not submit messages if the filter doesn't match" do
+          @agg.filter { |m|m["a"] != :a}
+          assert_equal 0, @handler.process_event(@message).length
+        end
+
+        should "copy the measures once for each aggregation" do
+          results =  @handler.process_event(@message)
+          results.each do |result|
+            assert_equal "add", result["action"]
+            assert_equal @agg.name, result["aggregation"]
+            assert_equal( { "d" => 1.0, "e" => 2.0} , result["measures"] )
+          end
+        end
+
+        should "key each message with a unique aggregation" do
+          results = @handler.process_event(@message)
+          results[0][:dimensions] = { "a" => :a, "b" => :b}
+          results[1][:dimensions] = { "a" => :a, "b" => :b, "c" => :c}
+        end
+
+      end
+      context "will listen for entity updated messages" do
+        should "respond to entity updated messages" do
+          Wonkavision::Analytics::SplitByAggregation.any_instance.expects(:process_event)
+          Wonkavision.event_coordinator.receive_event("wv/analytics/facts/updated",{ :a=>:b})
+        end
+      end
+
+    end
+  end
+
+end

data/test/store_test.rb

@@ -0,0 +1,71 @@
+require "test_helper"
+
+class StoreTest < ActiveSupport::TestCase
+  Store = Wonkavision::Analytics::Persistence::Store
+
+  context "Store" do
+    setup do
+      @facts = Class.new
+      @facts.class_eval do
+        include Wonkavision::Facts
+        record_id :tada
+      end
+      @store = Store.new(@facts)
+    end
+
+    should "provide access to the underlying owner" do
+      assert_equal @facts, @store.owner
+    end
+
+    should "be able to extract a record_id from a message" do
+      assert_equal 123, @store.send(:assert_record_id,{ "tada" => 123 })
+    end
+
+    should "raise an exception if a record_id is requested but not found" do
+      assert_raise(RuntimeError) {  @store.send(:assert_record_id,{ "haha" => 123})}
+    end
+
+    context "Public api" do
+      context "#update_facts" do
+        should "extract a record_id and delegate to update_facts_record" do
+          @store.expects(:update_facts_record).with(123,{ "tada"=>123})
+          @store.update_facts("tada"=>123)
+        end
+      end
+      context "#add_facts" do
+        should "extract a record_id and delegate to insert_facts_record" do
+          @store.expects(:insert_facts_record).with(123,{ "tada" => 123})
+          @store.add_facts("tada"=>123)
+        end
+      end
+      context "#remove_facts" do
+        should "extract a record_id and delegate to delete_facts_record" do
+          @store.expects(:delete_facts_record).with(123,{ "tada" => 123} )
+          @store.remove_facts("tada"=>123)
+        end
+      end
+      context "#execute_query" do
+        setup do
+          @query = Wonkavision::Analytics::Query.new
+          @query.select :a, :b, :on => :columns
+          @query.select :c, :on => :rows
+          @query.where :d=>:e
+        end
+        should "delegate to fetch tuples, passing the selected dimensions" do
+          @store.expects(:fetch_tuples).with([:a,:b,:c, :d],@query.filters)
+          @store.execute_query(@query)
+        end
+        should "pass an empty array of dimensions when nothing is selected" do
+          @store.expects(:fetch_tuples).with([],[])
+          @store.execute_query(Wonkavision::Analytics::Query.new)
+        end
+      end
+      context "Deriving from Store" do
+        should "register the derived class with the superclass" do
+          class NewStore < Store; end
+          assert_equal NewStore, Store[:new_store]
+        end
+      end
+    end
+  end
+end

data/test/symbol_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class SymbolTest < ActiveSupport::TestCase
+  context "Symbol extensions" do
+    setup do
+      @symbol = :member
+    end
+    context "#key, #caption and #sort" do
+      should "produce MemberFilters of type dimension" do
+        [:key,:caption,:sort].each do |method|
+          filter = @symbol.send(method)
+          assert_equal @symbol, filter.name
+          assert_equal :dimension, filter.member_type
+          assert_equal method, filter.attribute_name
+        end
+      end
+    end
+    context "#sum, #sum2, #count" do
+      should "produce MemberFilters of type measure" do
+        [:sum,:sum2,:count].each do |method|
+          filter = @symbol.send(method)
+          assert_equal @symbol, filter.name
+          assert_equal :measure, filter.member_type
+          assert_equal method, filter.attribute_name
+        end
+      end
+    end
+
+    context "#[]" do
+      should "produce a MemberFilter with the attribute name specified by the indexer" do
+        filter = @symbol[:an_attribute]
+        assert_equal @symbol, filter.name
+        assert_equal :an_attribute, filter.attribute_name
+      end
+    end
+    context "method_missing" do
+      should "produce a MemberFilter with an attribute name of the method called" do
+        filter = @symbol.an_attribute
+        assert_equal @symbol, filter.name
+        assert_equal :an_attribute, filter.attribute_name
+      end
+    end
+    context "when the symbol is ':dimensions'" do
+      should "produce a MemberFilter with a dimension name as specified and a default attribute name" do
+        filter = :dimensions.a_dimension
+        assert_equal :a_dimension, filter.name
+        assert_equal :key, filter.attribute_name
+        assert_equal :dimension, filter.member_type
+      end
+    end
+    context "when the symbol is ':measures'" do
+      should "produce a MemberFilter with a measure name as specified and a default attribute name" do
+        filter = :measures.a_measure
+        assert_equal :a_measure, filter.name
+        assert_equal :count, filter.attribute_name
+        assert_equal :measure, filter.member_type
+      end
+    end
+
+  end
+
+end

data/test/test_activity_models.rb

@@ -66,7 +66,7 @@ unless defined?(::TestEventHandler)
 
   Wonkavision::MessageMapper.register("evt4_test_map") do
     string 'test_id'
-    date 'event_time'
+    time 'event_time'
   end
 
 end

data/test/test_aggregation.rb

@@ -0,0 +1,42 @@
+class TestAggregation
+  include Wonkavision::Aggregation
+
+  store :hash_store
+
+  dimension :color, :size, :shape
+  measure :weight, :cost
+
+  aggregate_by :color
+  aggregate_by :size
+  aggregate_by :shape
+  aggregate_by :color, :size
+  aggregate_by :color, :shape
+  aggregate_by :size, :shape
+  aggregate_by :size, :color, :shape
+
+  @i = 0
+  def self.send_messages
+    colors = %w(red green red green yellow black black white red yellow)
+    sizes =  %w(large large small medium medium small large small medium small)
+    shapes = %w(square circle rectangle rectangle circle square circle rectangle square square)
+    weights =  [1.0, 2.0, 1.1, 2.1, 1.2, 2.2, 1.3, 2.3,4.5,6.5]
+    costs =    [5, 10, 15, 20, 15, 20, 5, 8, 9, 20]
+
+    (0..9).each do |idx|
+      Wonkavision.event_coordinator.submit_job "wv/analytics/entity/updated",  {
+        "aggregation" => "TestAggregation",
+        "action" => "add",
+        "entity" => {
+          "color" => colors[idx],
+          "size" => sizes[idx],
+          "shape" => shapes[idx],
+          "weight" => weights[idx],
+          "cost" => costs[idx]
+        }
+      }
+      @i+=1
+      print @i % 100 == 0 ? @i : "."
+    end
+
+  end
+end

data/test/test_data.tuples

@@ -0,0 +1,100 @@
+[{"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd89a'),
+  "dimension_keys"=>["red", "square", "large"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"large"},
+    "shape"=>{"shape"=>"square"},
+    "color"=>{"color"=>"red"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>50, "sum2"=>250},
+    "weight"=>{"count"=>10, "sum"=>10.0, "sum2"=>10.0}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8a0'),
+  "dimension_keys"=>["green", "circle", "large"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"large"},
+    "shape"=>{"shape"=>"circle"},
+    "color"=>{"color"=>"green"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>100, "sum2"=>1000},
+    "weight"=>{"count"=>10, "sum"=>20.0, "sum2"=>40.0}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8a6'),
+  "dimension_keys"=>["red", "rectangle", "small"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"small"},
+    "shape"=>{"shape"=>"rectangle"},
+    "color"=>{"color"=>"red"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>150, "sum2"=>2250},
+    "weight"=>{"count"=>10, "sum"=>11.0, "sum2"=>12.1}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8ab'),
+  "dimension_keys"=>["green", "rectangle", "medium"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"medium"},
+    "shape"=>{"shape"=>"rectangle"},
+    "color"=>{"color"=>"green"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>200, "sum2"=>4000},
+    "weight"=>{"count"=>10, "sum"=>21.0, "sum2"=>44.1}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8b0'),
+  "dimension_keys"=>["yellow", "circle", "medium"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"medium"},
+    "shape"=>{"shape"=>"circle"},
+    "color"=>{"color"=>"yellow"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>150, "sum2"=>2250},
+    "weight"=>{"count"=>10, "sum"=>12.0, "sum2"=>14.4}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8b5'),
+  "dimension_keys"=>["black", "square", "small"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"small"},
+    "shape"=>{"shape"=>"square"},
+    "color"=>{"color"=>"black"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>200, "sum2"=>4000},
+    "weight"=>{"count"=>10, "sum"=>22.0, "sum2"=>48.4}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8b8'),
+  "dimension_keys"=>["black", "circle", "large"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"large"},
+    "shape"=>{"shape"=>"circle"},
+    "color"=>{"color"=>"black"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>50, "sum2"=>250},
+    "weight"=>{"count"=>10, "sum"=>13.0, "sum2"=>16.9}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8bc'),
+  "dimension_keys"=>["white", "rectangle", "small"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"small"},
+    "shape"=>{"shape"=>"rectangle"},
+    "color"=>{"color"=>"white"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>80, "sum2"=>640},
+    "weight"=>{"count"=>10, "sum"=>23.0, "sum2"=>52.9}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8bf'),
+  "dimension_keys"=>["red", "square", "medium"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"medium"},
+    "shape"=>{"shape"=>"square"},
+    "color"=>{"color"=>"red"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>90, "sum2"=>810},
+    "weight"=>{"count"=>10, "sum"=>45.0, "sum2"=>202.5}}},
+ {"_id"=>BSON::ObjectId('4d470fb0ca248815e73bd8c2'),
+  "dimension_keys"=>["yellow", "square", "small"],
+  "dimension_names"=>["color", "shape", "size"],
+  "dimensions"=>
+   {"size"=>{"size"=>"small"},
+    "shape"=>{"shape"=>"square"},
+    "color"=>{"color"=>"yellow"}},
+  "measures"=>
+   {"cost"=>{"count"=>10, "sum"=>200, "sum2"=>4000},
+    "weight"=>{"count"=>10, "sum"=>65.0, "sum2"=>422.5}}}]