wonkavision 0.5.11 → 0.6.0

data/test/map_test.rb

@@ -112,7 +112,7 @@ class MapTest < ActiveSupport::TestCase
     should "accept a time unmolested" do
       time = Time.now
       m = Wonkavision::MessageMapper::Map.new(:a=>time)
-      m.date :a
+      m.time :a
       assert_equal time, m.a
     end
   end
@@ -311,5 +311,52 @@ class MapTest < ActiveSupport::TestCase
         assert_equal 4, m.new_collection[1].b
       end
     end
+
+    context "Map.duration" do
+      should "return nil if no :from or :to value is available" do
+        m = Wonkavision::MessageMapper::Map.new
+        m.duration :a_duration
+        assert_nil m.a_duration
+      end
+      should "return time from Time.now if only to is supplied" do
+        m = Wonkavision::MessageMapper::Map.new({ :a => "1/1/2001" })
+        m.time :a
+        m.duration :a_duration, :to => m.a
+        assert m.a_duration < 0
+      end
+      should "return time to Time.now if only from is supplied" do
+        m = Wonkavision::MessageMapper::Map.new({ :a=>"1/1/2001"})
+        m.time :a
+        m.duration :a_duration, :from => m.a
+        assert m.a_duration > 0
+      end
+      should "convert the duration to the desired time unit" do
+        m = Wonkavision::MessageMapper::Map.new
+        m.expects(:convert_seconds).with(1,:months)
+        m.time :a=>"1/1/2001 00:00:00"
+        m.time :b=>"1/1/2001 00:00:01"
+        m.duration :a_duration, :from=>m.a, :to=>m.b, :in=>:months
+      end
+    end
+    context "Map.convert_seconds" do
+      setup do
+        @m = Wonkavision::MessageMapper::Map.new
+      end
+      should "raise an exception for an invalid unit" do
+        assert_raise(RuntimeError) { @m.send(:convert_seconds,1,:wakka)}
+      end
+      should "should correctly calculate proper units" do
+        assert_equal 100, @m.send(:convert_seconds,100,:seconds)
+        assert_equal 1, @m.send(:convert_seconds,60,:minutes)
+        assert_equal 1, @m.send(:convert_seconds,60*60,:hours)
+        assert_equal 1, @m.send(:convert_seconds,60*60*24,:days)
+        assert_equal 1, @m.send(:convert_seconds,60*60*24*7,:weeks)
+        assert_equal 1, @m.send(:convert_seconds,60*60*24*30,:months)
+        assert_equal 1, @m.send(:convert_seconds,60*60*24*365,:years)
+      end
+
+    end
+
+
   end
 end

data/test/measure_test.rb

@@ -0,0 +1,146 @@
+require "test_helper"
+
+class MeasureTest < Test::Unit::TestCase
+
+  def setup
+    @stats = Wonkavision::Plugins::Aggregation::Measure.new(:log_buckets => 128)
+
+    @@DATA.each do |x|
+      @stats << x
+    end
+  end
+
+  def test_stats_count
+    assert_equal @@DATA.length, @stats.count
+  end
+
+  def test_stats_min_max
+    sorted_data = @@DATA.sort
+
+    assert_equal sorted_data[0], @stats.min
+    assert_equal sorted_data.last, @stats.max
+  end
+
+  def test_stats_mean
+    sum = 0
+    @@DATA.each do |x|
+      sum += x
+    end
+
+    assert_equal sum.to_f/@@DATA.length.to_f, @stats.mean
+  end
+
+  def test_bucket_counts
+
+    #Test each iterator
+    total_bucket_sum = 0
+    i = 0
+    @stats.each do |bucket, count|
+      assert_equal 2**i, bucket
+
+      total_bucket_sum += count
+      i += 1
+    end
+
+    assert_equal @@DATA.length, total_bucket_sum
+
+    #Test each_nonzero iterator
+    prev_bucket = 0
+    total_bucket_sum = 0
+    @stats.each_nonzero do |bucket, count|
+      assert bucket > prev_bucket
+      assert_not_equal count, 0
+
+      total_bucket_sum += count
+    end
+
+    assert_equal total_bucket_sum, @@DATA.length
+  end
+
+
+  #XXX: Update test_bucket_contents() if you muck with @@DATA
+   @@DATA = [ 1, 5, 4, 6, 1028, 1972, 16384, 16385, 16383]
+  def test_bucket_contents
+    #XXX: This is the only test so far that cares about the actual contents
+    # of @@DATA, so if you update that array ... update this method too
+    expected_buckets  = [1, 4, 1024, 8192, 16384]
+    expected_counts =   [1, 3,    2,    1,     2]
+
+    i = 0
+    @stats.each_nonzero do |bucket, count|
+      assert_equal expected_buckets[i], bucket
+      assert_equal expected_counts[i],  count
+      # Increment for the next test
+      i += 1
+    end
+  end
+
+  def test_outlier
+    assert_equal 0, @stats.outliers_low
+    assert_equal 0, @stats.outliers_high
+
+    @stats << -1
+    @stats << -2
+    @stats << 0
+
+    @stats << 2**128
+
+    # This should be the last value in the last bucket, but Ruby's native
+    # floats are not precise enough. Somewhere past 2^32 the log(x)/log(2)
+    # breaks down. So it shows up as 128 (outlier) instead of 127
+    #@stats << (2**128) - 1
+
+    assert_equal 3, @stats.outliers_low
+    assert_equal 1, @stats.outliers_high
+  end
+
+  def test_std_dev
+    @stats.std_dev
+  end
+end
+
+class LinearHistogramTest < Test::Unit::TestCase
+  def setup
+    @stats = Wonkavision::Plugins::Aggregation::Measure.new(:low => 0, :high => 32768, :width => 1024)
+
+    @@DATA.each do |x|
+      @stats << x
+    end
+  end
+
+  def test_validation
+
+    # Range cannot be 0
+    assert_raise(ArgumentError) {bad_stats = Wonkavision::Plugins::Aggregation::Measure.new(:low => 32,:high => 32, :width => 4)}
+
+    # Range cannot be negative
+    assert_raise(ArgumentError) {bad_stats = Wonkavision::Plugins::Aggregation::Measure.new(:low => 32, :high => 16, :width => 4)}
+
+    # Range cannot be < single bucket
+    assert_raise(ArgumentError) {bad_stats = Wonkavision::Plugins::Aggregation::Measure.new(:low => 16, :high => 32, :width => 17)}
+
+    # Range % width must equal 0 (for now)
+    assert_raise(ArgumentError) {bad_stats = Wonkavision::Plugins::Aggregation::Measure.new(:low => 1, :high => 16384, :width => 1024)}
+  end
+
+  #XXX: Update test_bucket_contents() if you muck with @@DATA
+  # 32768 is an outlier
+  @@DATA = [ 0, 1, 5, 4, 6, 1028, 1972, 16384, 16385, 16383, 32768]
+  def test_bucket_contents
+    #XXX: This is the only test so far that cares about the actual contents
+    # of @@DATA, so if you update that array ... update this method too
+    expected_buckets  = [0, 1024,  15360, 16384]
+    expected_counts =   [5, 2,     1,     2]
+
+    i = 0
+    @stats.each_nonzero do |bucket, count|
+      assert_equal expected_buckets[i], bucket
+      assert_equal expected_counts[i],  count
+      # Increment for the next test
+      i += 1
+    end
+  end
+
+
+
+end

data/test/member_filter_test.rb

@@ -0,0 +1,143 @@
+require "test_helper"
+
+class MemberFilterTest < ActiveSupport::TestCase
+  context "MemberFilter" do
+    setup do
+      @dimension = Wonkavision::Analytics::MemberFilter.new(:a_dim,   :member_type=>:dimension)
+      @measure = Wonkavision::Analytics::MemberFilter.new(:a_measure, :member_type=>:measure)
+    end
+    context "#attribute_name" do
+      should "default to key for dimension" do
+        assert_equal :key, @dimension.attribute_name
+      end
+      should "default to count for measure" do
+        assert_equal :count, @measure.attribute_name
+      end
+    end
+    context "#dimension?" do
+      should "be true for dimension" do
+        assert @dimension.dimension?
+      end
+      should "not be true for measure" do
+        assert !@measure.dimension?
+      end
+    end
+    context "#measure?" do
+      should "be true for measure" do
+        assert @measure.measure?
+      end
+      should "not be true for dimension" do
+        assert !@dimension.measure?
+      end
+    end
+    context "#operators" do
+      should "set the operator property appropriately" do
+        [:gt, :lt, :gte, :lte, :ne, :in, :nin].each do |op|
+          assert_equal op, @dimension.send(op).operator
+        end
+      end
+
+    end
+
+    context "#matches" do
+      setup do
+        @tuple = {
+          "measures" => { "a_measure" => { "sum" => 2.0, "count" => 5 } }
+        }
+        @aggregation = {}
+        @dimension = {}
+        @filter = Wonkavision::Analytics::MemberFilter.new(:a_measure, :member_type=>:measure,:value=>1)
+      end
+      should "return false for gt, lt, gte, lte if the data is nil" do
+        @tuple["measures"]["a_measure"]["count"] = nil
+        [:gt, :lt, :gte, :lte].each do |op|
+          @filter.send(op)
+          assert_equal false, @filter.matches(@aggregation, @tuple)
+        end
+      end
+      should "evaluate gt, gte" do
+        [:gt, :gte].each do |op|
+          @filter.send(op,4)
+          assert @filter.matches(@aggregation, @tuple)
+        end
+      end
+      should "evaluate lt, lte" do
+        [:lt, :lte].each do |op|
+          @filter.send(op,6)
+          assert @filter.matches(@aggregation, @tuple)
+        end
+      end
+      should "evaluate in" do
+        @filter.in([4,5,6])
+        assert @filter.matches(@aggregation, @tuple)
+      end
+      should "evalute nin" do
+        @filter.nin([6,7,8])
+        assert @filter.matches(@aggregation, @tuple)
+      end
+      should "evaluate eq" do
+        @filter.eq(5)
+        assert @filter.matches(@aggregation, @tuple)
+      end
+      should "evaluate ne" do
+        @filter.ne(6)
+        assert @filter.matches(@aggregation, @tuple)
+      end
+    end
+
+    context "#extract_attribute_value_from_tuple" do
+      setup do
+        @tuple = {
+          "dimensions" => { "a_dimension" => { "akey" => "abc" } },
+          "measures" => { "a_measure" => { "sum" => 2.0, "count" => 5 } }
+        }
+        @aggregation = {}
+        @dimension = {}
+      end
+      context "for a dimension filter" do
+        setup do
+          @filter = Wonkavision::Analytics::MemberFilter.new(:a_dimension)
+          @aggregation.expects(:dimensions).returns( { :a_dimension => @dimension } )
+        end
+        should "extract a dimension value from a tuple message" do
+          @dimension.expects(:key).returns(:akey)
+          assert_equal "abc", @filter.send(:extract_attribute_value_from_tuple,@aggregation,@tuple)
+        end
+        should "extract a dimension value with a custom attribute" do
+          @filter.instance_variable_set("@attribute_name","akey")
+          assert_equal "abc", @filter.send(:extract_attribute_value_from_tuple,@aggregation,@tuple)
+        end
+      end
+      context "for a measure filter" do
+        setup do
+          @filter = Wonkavision::Analytics::MemberFilter.new(:a_measure, :member_type=>:measure)
+        end
+        should "extract a measure value" do
+          assert_equal 5, @filter.send(:extract_attribute_value_from_tuple,@aggregation,@tuple)
+        end
+      end
+    end
+
+    context "#assert_operator_matches_value" do
+      should "raise an exception if inappropriately nil" do
+        filter = Wonkavision::Analytics::MemberFilter.new(:hi)
+        [:gt, :lt, :gte, :lte, :in, :nin].each do |op|
+          filter.send(op)
+          assert_raise(RuntimeError) {  filter.send :assert_operator_matches_value }
+        end
+      end
+      should "raise an exception if 'in' and 'nin' are not given an array" do
+        filter = Wonkavision::Analytics::MemberFilter.new(:hi, :value=>:ho)
+        [:in,:nin].each do |op|
+          filter.send(op)
+          assert_raise(RuntimeError) { filter.send :assert_operator_matches_value }
+        end
+      end
+      should "not raise an exception otherwise" do
+        filter = Wonkavision::Analytics::MemberFilter.new(:hi, :operator=>:gt, :value=>1)
+        filter.send(:assert_operator_matches_value)
+      end
+    end
+
+  end
+end

data/test/mongo_store_test.rb

@@ -0,0 +1,115 @@
+require "test_helper"
+
+class MongoStoreTest < ActiveSupport::TestCase
+  MongoStore = Wonkavision::Analytics::Persistence::MongoStore
+
+  context "MongoStore" do
+    setup do
+      @facts = Class.new
+      @facts.class_eval do
+        def self.name; "TestFacts"; end
+        include Wonkavision::Facts
+        record_id :tada
+      end
+      @store = MongoStore.new(@facts)
+    end
+
+    should "provide access to the underlying facts specification" do
+      assert_equal @facts, @store.owner
+    end
+
+    should "create a collection name based on the facts class name" do
+      assert_equal "wv.test_facts.facts", @store.facts_collection_name
+    end
+
+
+    context "Facts persistence" do
+      setup do
+        @doc_id = 123
+        @store.facts_collection.insert( {"_id" => @doc_id,
+                                    "tada" => @doc_id,
+                                    "todo" => "hoho",
+                                    "canttouchthis"=>"yo"} )
+      end
+      context "#update_facts_record" do
+        setup do
+          @prev,@cur = @store.send( :update_facts_record,
+                                    @doc_id, "tada"=>@doc_id, "todo"=>"heehee", "more"=>"4me?" )
+        end
+        should "return the previous version of the facts record" do
+          assert_equal( { "tada" => @doc_id, "todo" => "hoho", "canttouchthis"=>"yo"}, @prev  )
+        end
+        should "return the updated version of the facts record" do
+          assert_equal({ "tada" => @doc_id, "todo" => "heehee", "canttouchthis"=>"yo","more"=>"4me?"},
+                       @cur)
+        end
+        should "contain the upated version in the storage" do
+          assert_equal({ "_id"=>@doc_id, "tada" => @doc_id, "todo" => "heehee", "canttouchthis"=>"yo","more"=>"4me?"},
+                       @store[@doc_id])
+        end
+      end
+      context "#insert_facts_record" do
+        setup do
+          @cur = @store.send(:insert_facts_record,@doc_id,{ "tada"=>@doc_id,"i is"=>"new"})
+        end
+        should "return the current version of the facts record" do
+          assert_equal( { "tada"=>@doc_id,"i is"=>"new"}, @cur )
+        end
+        should "add the record to the storage" do
+          assert_equal @cur.merge("_id"=>@doc_id), @store[@doc_id]
+        end
+      end
+      context "#delete_facts_record" do
+        setup do
+          @prev = @store.send(:delete_facts_record,@doc_id,{"tada"=>@doc_id})
+        end
+        should "return the previous version of the facts record" do
+          assert_equal( { "tada" => @doc_id, "todo" => "hoho", "canttouchthis"=>"yo"}, @prev  )
+        end
+        should "remove the facts record from the storage" do
+          assert_nil @store[@doc_id]
+        end
+
+      end
+
+    end
+    context "Aggregations persistence" do
+      setup do
+        @tuple  = { :dimension_keys=>[1,2,3],
+          :dimension_names=>[:a,:b,:c],
+          :dimensions=>{"dims"=>"doms"},
+          :measures=>{ "measures.one"=>1} }
+      end
+      context "#update_tuple" do
+        should "insert a new tuple if not present" do
+          @store.send(:update_tuple, @tuple)
+          added = @store.aggregations_collection.find({ :dimension_names=>[:a,:b,:c] }).to_a[0]
+          added.delete("_id") #isn't present on the original, we know its there
+          assert_equal @tuple.merge({:measures=>{ "one" => 1}}).stringify_keys!, added
+        end
+      end
+      context "#append_filters" do
+        setup do
+          @dim_filter = Wonkavision::Analytics::MemberFilter.new("tada",:value=>[1,2,3])
+          @measure_filter = Wonkavision::Analytics::MemberFilter.new("haha",
+                                                                     :member_type=>:measure,
+                                                                     :op=>:gte,
+                                                                     :value=>100.0)
+          @criteria = {}
+          @dim_filter.expects(:attribute_key).returns "tada_key"
+          @store.send(:append_filters,@criteria,[@dim_filter,@measure_filter])
+        end
+        should "prepare the dimension filter for mongodb" do
+          assert_equal( [1,2,3], @criteria["dimensions.tada.tada_key"] )
+        end
+        should "prepare the measure filter for mongodb" do
+          assert_equal( { "$gte" => 100.0 }, @criteria["measures.haha.count"] )
+        end
+
+
+      end
+
+    end
+
+  end
+end