modesty 0.1.0

data/spec/redis_spec.rb

@@ -0,0 +1,29 @@
+require 'modesty'
+
+describe "Real Redis" do
+  before :each do
+    Modesty.metrics.clear
+    Modesty.experiments.clear
+  end
+
+  it "can connect to redis" do
+    lambda { Modesty.set_store :redis }.should_not raise_error
+    Modesty.data.store.should be_an_instance_of Redis
+    lambda { Modesty.data.flushdb }.should_not raise_error
+  end
+
+  it "can track metrics in real redis" do
+    Modesty.new_metric :foo
+    lambda do
+      (1..100).each do |i|
+        Modesty.track! :foo, 2
+        Modesty.metrics[:foo].count.should == i*2
+      end
+    end.should_not raise_error
+  end
+
+  after :all do
+    Modesty.data.flushdb
+    Modesty.set_store :redis, :mock => true
+  end
+end

data/spec/significance_spec.rb

@@ -0,0 +1,147 @@
+require 'modesty'
+
+describe "Significance" do
+  before :each do
+    Modesty.data.flushdb
+    Modesty.experiments.clear
+    Modesty.metrics.clear
+
+    @foo = Modesty.new_metric :foo
+    @bar = Modesty.new_metric :bar
+
+    @e = Modesty.new_experiment :baz do |e|
+      e.metrics :foo, :bar
+
+      e.conversion :foo_conv, :on => [:foo, :bar]
+      e.distribution :foo_dist, :on => :foo
+    end
+
+    @foo_dist = @e.stats[:foo_dist]
+    @foo_conv = @e.stats[:foo_conv]
+
+    Modesty.identify! 1
+  end
+
+  it "handles significant distribution data" do
+    250.times do |uid|
+      @e.chooses :experiment, :for => uid
+      Modesty.track! :foo, rand(200), :with => {:user => uid}
+    end
+
+    250.times do |uid|
+      uid = 251 + uid
+      @e.chooses :control, :for => uid
+      Modesty.track! :foo, rand(100), :with => {:user => uid}
+    end
+
+    @foo_dist.should be_a Modesty::Experiment::DistributionStat
+    an = @foo_dist.analysis
+    an.should be_a Hash
+    an[:control][:mean].should be_close(50, 10)
+    an[:experiment][:mean].should be_close(100, 20)
+    an[:control][:size].should == 250
+    an[:experiment][:size].should == 250
+
+    sig = @foo_dist.significance
+    sig.should be_a Float
+    sig.should be < 0.01
+    @foo_dist.should be_significant
+  end
+
+  it "handles insignificant distribution data" do
+    @e.chooses :experiment
+    250.times do
+      Modesty.track! :foo, 1+rand(10)
+    end
+    @e.chooses :control
+    250.times do
+      Modesty.track! :foo, 1+rand(10)
+    end
+
+    sig = @foo_dist.significance
+    sig.should be_nil
+    @foo_dist.should_not be_significant
+  end
+
+  it "handles significant conversion data" do
+    @e.chooses :experiment
+    500.times do
+      Modesty.track! :foo, 1+rand(5)
+      Modesty.track! :bar, 100
+    end
+
+    @e.chooses :control
+    500.times do
+      Modesty.track! :foo, 1+rand(100)
+      Modesty.track! :bar, 100
+    end
+
+    @foo_conv.should be_a Modesty::Experiment::ConversionStat
+    sig = @foo_conv.significance
+    sig.should_not be_nil
+  end
+end
+
+describe "Statistics with blocks" do
+  before :each do
+    Modesty.data.flushdb
+    Modesty.metrics.clear
+    Modesty.experiments.clear
+
+    Modesty.new_metric :foo
+    Modesty.new_metric :bar
+
+    @e = Modesty.new_experiment :baz do |e|
+      e.metrics :foo, :bar
+
+      e.distribution :special_dist do |metrics|
+        metrics[:foo].distribution + metrics[:bar].distribution
+      end
+
+      e.conversion :special_conv do |metrics|
+        [
+          metrics[:foo].unique(:users),
+          metrics[:foo].count
+        ]
+      end
+    end
+
+    (1..500).each do |i|
+      Modesty.identify!(i)
+      Modesty.group :baz
+      Modesty.track! :foo, 1+rand(i)
+      Modesty.track! :bar, 1+rand(501-i)
+    end
+
+  end
+
+  it "uses the blocks for distribution" do
+    three_days = @e.stats[:special_dist].data(3.days.ago..Date.today)
+    three_days.should == {
+      :control => (
+        @e.metrics(:control)[:foo].distribution(3.days.ago..Date.today).sum +
+        @e.metrics(:control)[:bar].distribution(3.days.ago, Date.today).sum
+      ),
+      :experiment => (
+        @e.metrics(:experiment)[:foo].distribution(3.days.ago, :today).sum +
+        @e.metrics(:experiment)[:bar].distribution(3.days.ago..Date.today).sum
+      )
+    }
+
+    three_days.should == @e.stats[:special_dist].data(3.days.ago, :today)
+  end
+
+  it "uses the blocks for conversion" do
+    three_days = @e.stats[:special_conv].data(3.days.ago..Date.today)
+    three_days.sort.should == [
+      [
+        @e.metrics(:experiment)[:foo].unique(:users, 3.days.ago, :today).sum,
+        @e.metrics(:experiment)[:foo].count(3.days.ago, Date.today).sum
+      ],
+      [
+        @e.metrics(:control)[:foo].unique(:users, 3.days.ago..Date.today).sum,
+        @e.metrics(:control)[:foo].count(3.days.ago, :today).sum
+      ],
+    ].sort
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/test/myapp/config/modesty.yml

@@ -0,0 +1,9 @@
+test:
+  datastore:
+    type: redis
+    port: 6379
+    host: localhost
+
+  paths:
+    experiments: experiments
+    metrics: metrics

data/test/myapp/modesty/experiments/cookbook.rb

@@ -0,0 +1,4 @@
+Modesty.new_experiment :cookbook do |e|
+  e.alternatives :big, :medium, :small
+  e.metrics :baked_goods/:cookies, :baked_goods/:brownies, :baked_goods/:cake
+end

data/test/myapp/modesty/metrics/kitchen_metrics.rb

@@ -0,0 +1,9 @@
+Modesty.new_metric :baked_goods do |m|
+  m.description "Yummy baked things"
+  m.submetric :cookies
+  m.submetric :brownies
+  m.submetric :cake do |m|
+    m.submetric :chocolate
+    m.submetric :ice_cream
+  end
+end

data/test/myapp/modesty/metrics/stove/burner_metrics.rb

@@ -0,0 +1,2 @@
+Modesty.new_metric :burner
+Modesty.new_metric :griddle

data/vendor/.piston.yml

@@ -0,0 +1,8 @@
+--- 
+repository_url: git://github.com/ezmobius/redis-rb.git
+lock: false
+repository_class: Piston::Git::Repository
+format: 1
+handler: 
+  commit: 283b58be1fbbed401dba36e1b9f4fa0d8be7904d
+  branch: master

data/vendor/mock_redis/.gitignore

@@ -0,0 +1,2 @@
+.*.swo
+.*.swp

data/vendor/mock_redis/README

@@ -0,0 +1,8 @@
+Usage:
+
+r = MockRedis.new(:some, :cool => :options)
+
+now pretend r is a redis client.  see github.com/ezmobius/redis-rb.
+DO NOT USE IN PRODUCTION. PLZ. KTHX
+
+This was based on a random file in assaf's "vanity", but as I extended it, it seemed like it needed its own repo.

data/vendor/mock_redis/lib/mock_redis.rb

@@ -0,0 +1,10 @@
+class MockRedis
+  LIB_DIR = File.dirname(__FILE__)
+end
+
+$:.unshift MockRedis::LIB_DIR
+require 'mock_redis/misc.rb'
+require 'mock_redis/string.rb'
+require 'mock_redis/set.rb'
+require 'mock_redis/hash.rb'
+$:.shift

data/vendor/mock_redis/lib/mock_redis/hash.rb

@@ -0,0 +1,61 @@
+class MockRedis
+  module HashMethods
+    def hset(key, hkey, val)
+      case h = self.hash[key]
+      when nil then self.hash[key] = {hkey => val.to_s}
+      when Hash then h[hkey] = val.to_s
+      else fail "Not a hash"
+      end
+    end
+
+    def hget(key, hkey)
+      case h = self.hash[key]
+      when nil then nil
+      when Hash then h[hkey]
+      else fail "Not a hash"
+      end
+    end
+
+    def hincrby(key, hkey, val)
+      case h = self.hash[key]
+      when nil then self.hash[key] = {hkey => val.to_s}
+      when Hash then h[hkey] = (h[hkey].to_i + val).to_s
+      else fail "Not a hash"
+      end
+    end
+
+    def hgetall(key)
+      case h = self.hash[key]
+      when nil then {}
+      when Hash then h
+      else fail "Not a hash"
+      end
+    end
+
+    def hkeys(key)
+      case h = self.hash[key]
+      when nil then []
+      when Hash then h.keys
+      else fail "Not a hash"
+      end
+    end
+
+    def hvals(key)
+      case h = self.hash[key]
+      when nil then []
+      when Hash then h.values
+      else fail "Not a hash"
+      end
+    end
+
+    def hlen(key)
+      case h = self.hash[key]
+      when nil then 0
+      when Hash then h.keys.count
+      else fail "Not a hash"
+      end
+    end
+  end
+
+  include HashMethods
+end

data/vendor/mock_redis/lib/mock_redis/list.rb

@@ -0,0 +1,6 @@
+class MockRedis
+  module ListMethods
+  end
+
+  include ListMethods
+end

data/vendor/mock_redis/lib/mock_redis/misc.rb

@@ -0,0 +1,69 @@
+class MockRedis
+  module MiscMethods
+    def hash
+      @@hash ||= {}
+    end
+
+    def del(*keys)
+      keys.flatten.each do |key|
+        self.hash.delete key
+      end
+      "OK"
+    end
+
+    def exists(key)
+      self.hash.has_key?(key)
+    end
+
+    def type(key)
+      case thing = self.hash[key]
+        when nil then "none"
+        when String then "string"
+        when Array then "list"
+        when Set then "set"
+        when Hash then "hash"
+      end
+    end
+
+    def rename(old, new)
+      self.hash[new] = self.hash[old]
+      self.hash.delete(old)
+    end
+
+    def renamenx(old, new)
+      rename(old, new) unless exists(new)
+    end
+
+    def keys(pattern)
+      regexp = Regexp.new(pattern.split("*").map { |r| Regexp.escape(r) }.join(".*"))
+      self.hash.keys.select { |key| key =~ regexp }
+    end
+
+    def randomkey
+      self.hash.keys[rand(dbsize)]
+    end
+
+    def dbsize
+      self.hash.keys.count
+    end
+
+    def flushdb
+      self.hash.clear
+    end
+    alias flushall flushdb
+
+    def multi
+      yield if block_given?
+    end
+
+    def ping
+      "PONG"
+    end
+
+    def pipelined
+      yield
+    end
+  end
+
+  include MiscMethods
+end

data/vendor/mock_redis/lib/mock_redis/set.rb

@@ -0,0 +1,108 @@
+class MockRedis
+  require 'set'
+
+  module SetMethods
+    def sadd(key, value)
+      fail_unless_set(key)
+      value = value.to_s
+      case set = self.hash[key]
+        when nil then self.hash[key] = Set.new([value])
+        when Set then set.add value
+      end
+    end
+
+    def srem(key, value)
+      value = value.to_s
+      fail_unless_set(key)
+      case set = self.hash[key]
+        when nil then return
+        when Set then set.delete(value)
+      end
+    end
+
+    def sismember(key, value)
+      fail_unless_set(key)
+      case set = self.hash[key]
+        when nil then return false ; puts "no set here"
+        when Set then set.include?(value.to_s)
+      end
+    end
+
+    def spop(key, val)
+      fail_unless_set(key)
+      case set = self.hash[key]
+        when nil then nil
+        when Set
+          el = set.to_a[rand(set.size)]
+          set.delete el
+          el
+      end
+    end
+
+    def smove(src_key, dst_key, member)
+      fail_unless_set(dst_key)
+      if el = self.srem(src_key, member)
+        self.sadd(dst_key, member)
+      end
+    end
+
+    def srandmember(key)
+      fail_unless_set(key)
+      case set = self.hash[key]
+        when nil then nil
+        when Set then set.to_a[rand(set.size)]
+      end
+    end
+
+    def smembers(key)
+      fail_unless_set(key)
+      case set = self.hash[key]
+      when nil then []
+      when Set then set.to_a
+      end
+    end
+
+    def scard(key)
+      fail_unless_set(key)
+      case set = self.hash[key]
+      when nil then 0
+      when Set then set.size
+      end
+    end
+
+    def sinter(*keys)
+      keys.each { |k| fail_unless_set(k) }
+      return Set.new if keys.any? { |k| self.hash[k].nil? }
+      keys.inject do |set, key|
+        set & self.hash[key]
+      end
+    end
+
+    def sunion(*keys)
+      keys.each { |k| fail_unless_set(k) }
+      keys.inject(Set.new) do |set, key|
+        return set if self.hash[key].nil?
+        set | self.hash[key]
+      end
+    end
+
+    def sdiff(first, *others)
+      [first, *others].each { |k| fail_unless_set(k) }
+      others = others.map { |k| self.hash[k] || Set.new }
+      others.inject(first) do |memo, set|
+        memo - self.hash[set]
+      end
+    end
+
+    private
+    def is_a_set?(key)
+      self.hash[key].is_a?(Set) || self.hash[key].nil?
+    end
+
+    def fail_unless_set(key)
+      fail "Not a set" unless is_a_set?(key)
+    end
+  end
+  
+  include SetMethods
+end