ablab 0.1.1 → 0.2.0

data/lib/ablab/engine.rb

@@ -0,0 +1,11 @@
+require 'rails'
+
+module Ablab
+  class Engine < ::Rails::Engine
+    isolate_namespace Ablab
+
+    initializer "ablab.assets.precompile" do |app|
+      app.config.assets.precompile += %w(tracker.js)
+    end
+  end
+end

data/lib/ablab/helper.rb

@@ -0,0 +1,27 @@
+require 'securerandom'
+
+module Ablab
+  module Helper
+    def self.included(klass)
+      if klass.respond_to? :helper_method
+        self.instance_methods(false).each do |method|
+          klass.send(:helper_method, method)
+          klass.send(:private, method)
+        end
+      end
+    end
+
+    def experiment(name)
+      @experiments ||= {}
+      unless Ablab.experiments.has_key?(name)
+        raise "No experiment with name #{name}"
+      end
+      @experiments[name] ||=
+        Ablab.experiments[name].run(ablab_session_id)
+    end
+
+    def ablab_session_id
+      cookies[:ablab_sid] || cookies[:ablab_sid] = SecureRandom.hex
+    end
+  end
+end

data/lib/ablab/store/memory.rb

@@ -1,29 +1,56 @@
-module ABLab
+require 'set'
+
+module Ablab
   module Store
     class Memory
       def initialize
         @views = Hash.new do |hash, key|
           hash[key] = Hash.new { |hash, key| hash[key] = 0 }
         end
-        @conversions = Hash.new do |hash, key|
+        @sessions = Hash.new do |hash, key|
+          hash[key] = Hash.new { |hash, key| hash[key] = Set.new }
+        end
+        @successes = Hash.new do |hash, key|
           hash[key] = Hash.new { |hash, key| hash[key] = 0 }
         end
+        @conversions = Hash.new do |hash, key|
+          hash[key] = Hash.new { |hash, key| hash[key] = Set.new }
+        end
       end
 
-      def track_view!(experiment, bucket)
+      def track_view!(experiment, bucket, session_id)
         @views[experiment][bucket] += 1
+        @sessions[experiment][bucket].add(session_id)
       end
 
-      def track_conversion!(experiment, bucket)
-        @conversions[experiment][bucket] += 1
+      def track_success!(experiment, bucket, session_id)
+        @successes[experiment][bucket] += 1
+        @conversions[experiment][bucket].add(session_id)
       end
 
       def views(experiment, bucket)
         @views[experiment][bucket]
       end
 
+      def sessions(experiment, bucket)
+        @sessions[experiment][bucket].size
+      end
+
+      def successes(experiment, bucket)
+        @successes[experiment][bucket]
+      end
+
       def conversions(experiment, bucket)
-        @conversions[experiment][bucket]
+        @conversions[experiment][bucket].size
+      end
+
+      def counts(experiment, bucket)
+        {
+          views:       views(experiment, bucket),
+          sessions:    sessions(experiment, bucket),
+          successes:   successes(experiment, bucket),
+          conversions: conversions(experiment, bucket)
+        }
       end
     end
   end

data/lib/ablab/store/redis.rb

@@ -1,6 +1,6 @@
 require 'redis'
 
-module ABLab
+module Ablab
   module Store
     class Redis
       attr_reader :redis
@@ -10,28 +10,54 @@ module ABLab
         @redis = ::Redis.new(opts)
       end
 
-      def track_view!(experiment, bucket)
-        redis.hincrby(key(:views), field(experiment, bucket), 1)
+      def track_view!(experiment, bucket, session_id)
+        redis.pipelined do
+          redis.incr(key(:views, experiment, bucket))
+          redis.pfadd(key(:sessions, experiment, bucket), session_id)
+        end
       end
 
-      def track_conversion!(experiment, bucket)
-        redis.hincrby(key(:conversions), field(experiment, bucket), 1)
+      def track_success!(experiment, bucket, session_id)
+        redis.pipelined do
+          redis.incr(key(:successes, experiment, bucket))
+          redis.pfadd(key(:conversions, experiment, bucket), session_id)
+        end
       end
 
       def views(experiment, bucket)
-        (redis.hget(key(:views), field(experiment, bucket)) || 0).to_i
+        (redis.get(key(:views, experiment, bucket)) || 0).to_i
+      end
+
+      def sessions(experiment, bucket)
+        (redis.pfcount(key(:sessions, experiment, bucket)) || 0).to_i
+      end
+
+      def successes(experiment, bucket)
+        (redis.get(key(:successes, experiment, bucket)) || 0).to_i
       end
 
       def conversions(experiment, bucket)
-        (redis.hget(key(:conversions), field(experiment, bucket)) || 0).to_i
+        (redis.pfcount(key(:conversions, experiment, bucket)) || 0).to_i
       end
 
-      private def key(type)
-        "#{@key_prefix}:#{type}"
+      def counts(experiment, bucket)
+        v, s, x, c = nil, nil, nil, nil
+        redis.multi do
+          v = redis.get(key(:views, experiment, bucket))
+          s = redis.pfcount(key(:sessions, experiment, bucket))
+          x = redis.get(key(:successes, experiment, bucket))
+          c = redis.pfcount(key(:conversions, experiment, bucket))
+        end
+        {
+          views:       (v.value || 0).to_i,
+          sessions:    (s.value || 0).to_i,
+          successes:   (x.value || 0).to_i,
+          conversions: (c.value || 0).to_i
+        }
       end
 
-      private def field(experiment, bucket)
-        "#{experiment}:#{bucket}"
+      private def key(type, experiment, bucket)
+        "#{@key_prefix}:#{type}:#{experiment}:#{bucket}"
       end
     end
   end

data/lib/ablab/version.rb

@@ -1,3 +1,3 @@
-module ABLab
-  VERSION = "0.1.1"
+module Ablab
+  VERSION = "0.2.0"
 end

data/lib/tasks/ablab_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :ablab do
+#   # Task goes here
+# end

data/spec/ablab/helper_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Ablab::Helper do
+  let(:cookies) { Hash.new }
+
+  let(:controller) do
+    Class.new do
+      include Ablab::Helper
+
+      def env
+        { 'rack.session' => OpenStruct.new(id: 'abc123') }
+      end
+    end.new
+  end
+
+  before do
+    Ablab.setup do
+      experiment :xxx do
+        group :a
+        group :b
+      end
+    end
+  end
+
+  it 'calls helper_method if the including class implements it' do
+    klass = Class.new do
+      def self.helper_method(_); end
+    end
+    expect(klass).to receive(:helper_method).with :experiment
+    expect(klass).to receive(:helper_method).with :ablab_session_id
+    klass.send(:include, Ablab::Helper)
+  end
+
+  describe '#experiment' do
+    it 'returns a Run for the given experiment name' do
+      allow(controller).to receive(:cookies).and_return(cookies)
+      run = controller.send(:experiment, :xxx)
+      expect(run).to be_a(Ablab::Run)
+      expect(run.experiment).to be(Ablab.experiments[:xxx])
+    end
+
+    it 'returns the same Run if called twice with the same name' do
+      allow(controller).to receive(:cookies).and_return(cookies)
+      run  = controller.send(:experiment, :xxx)
+      run2 = controller.send(:experiment, :xxx)
+      expect(run).to be(run2)
+    end
+  end
+end

data/spec/ablab/store/memory_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'ablab/store/store_examples'
+
+describe Ablab::Store::Memory do
+  let(:store) { Ablab::Store::Memory.new }
+  include_examples 'store', Ablab::Store::Memory.new
+end

data/spec/ablab/store/redis_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'ablab/store/store_examples'
+
+describe Ablab::Store::Redis do
+  def cleanup
+    redis = ::Redis.new(db: 2)
+    keys  = redis.keys('ablabtest:*')
+    redis.pipelined do
+      keys.each { |key| redis.del(key) }
+    end
+  end
+
+  around do |example|
+    begin
+      cleanup
+      example.run
+    ensure
+      cleanup
+    end
+  end
+
+  let(:store) { Ablab::Store::Redis.new(db: 2, key_prefix: 'ablabtest') }
+  include_examples 'store'
+end
+

data/spec/ablab/store/store_examples.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'store' do
+  describe '#track_view!' do
+    it 'tracks views' do
+      5.times { store.track_view!(:foo, :a, 'abc') }
+      7.times { store.track_view!(:foo, :b, 'abc') }
+      3.times { store.track_view!(:bar, :b, 'abc') }
+      expect(store.views(:foo, :a)).to eq(5)
+      expect(store.views(:foo, :b)).to eq(7)
+      expect(store.views(:bar, :b)).to eq(3)
+    end
+
+    it 'tracks unique sessions' do
+      2.times { store.track_view!(:foo, :a, 'foo') }
+      3.times { store.track_view!(:foo, :a, 'bar') }
+      3.times { store.track_view!(:foo, :b, 'foo') }
+      3.times { store.track_view!(:bar, :b, 'bar') }
+      expect(store.sessions(:foo, :a)).to eq(2)
+      expect(store.sessions(:foo, :b)).to eq(1)
+      expect(store.sessions(:bar, :b)).to eq(1)
+    end
+  end
+
+  describe '#track_success!' do
+    it 'tracks successes' do
+      5.times { store.track_success!(:foo, :a, 'abc') }
+      7.times { store.track_success!(:foo, :b, 'abc') }
+      3.times { store.track_success!(:bar, :b, 'abc') }
+      expect(store.successes(:foo, :a)).to eq(5)
+      expect(store.successes(:foo, :b)).to eq(7)
+      expect(store.successes(:bar, :b)).to eq(3)
+    end
+
+    it 'tracks unique conversions' do
+      5.times { |i| store.track_success!(:foo, :a, i) }
+      2.times { store.track_success!(:foo, :b, 'foo') }
+      3.times { store.track_success!(:foo, :b, 'bar') }
+      3.times { store.track_success!(:bar, :b, 'foo') }
+      expect(store.conversions(:foo, :a)).to eq(5)
+      expect(store.conversions(:foo, :b)).to eq(2)
+      expect(store.conversions(:bar, :b)).to eq(1)
+    end
+  end
+
+  describe '#views' do
+    it 'returns 0 if nothing was tracked' do
+      expect(store.views(:xxx, :a)).to eq(0)
+    end
+  end
+
+  describe '#conversions' do
+    it 'returns 0 if nothing was tracked' do
+      expect(store.conversions(:xxx, :a)).to eq(0)
+    end
+  end
+
+  describe '#sessions' do
+    it 'returns 0 if nothing was tracked' do
+      expect(store.sessions(:xxx, :a)).to eq(0)
+    end
+  end
+
+  describe '#counts' do
+    it 'returns all counts in one call' do
+      2.times { store.track_view!(:foo, :a, 'foo') }
+      3.times { store.track_view!(:foo, :a, 'bar') }
+      1.times { store.track_success!(:foo, :a, 'foo') }
+      5.times { store.track_success!(:foo, :a, 'bar') }
+      2.times { store.track_success!(:foo, :a, 'baz') }
+      expect(store.counts(:foo, :a)).to eq(views: 5, sessions: 2, successes: 8, conversions: 3)
+    end
+  end
+end

data/spec/ablab_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe Ablab do
+  let(:ab) do
+    Module.new { extend Ablab::ModuleMethods }
+  end
+
+  it 'has a version number' do
+    expect(Ablab::VERSION).not_to be nil
+  end
+
+  describe '.experiment' do
+    it 'creates an experiment' do
+      ab.experiment :foo_bar do; end
+      expect(ab.experiments[:foo_bar]).to be_a(Ablab::Experiment)
+    end
+  end
+
+  describe '.tracker' do
+    around do |example|
+      begin
+        Ablab::Store::Dummy = Class.new
+        example.run
+      ensure
+        Ablab::Store.send(:remove_const, :Dummy)
+      end
+    end
+
+    it 'returns a Ablab::Store::Memory instance if store was never set' do
+      expect(ab.tracker).to be_a(Ablab::Store::Memory)
+    end
+
+    it 'returns the store if it was set' do
+      ab.store :dummy
+      expect(ab.tracker).to be_a(Ablab::Store::Dummy)
+    end
+  end
+
+  describe '.dashboard_credentials' do
+    it 'raises if called without name or password' do
+      expect {
+        ab.dashboard_credentials(name: 'foo')
+      }.to raise_error(Ablab::InvalidCredentials)
+
+      expect {
+        ab.dashboard_credentials(password: 'foo')
+      }.to raise_error(Ablab::InvalidCredentials)
+    end
+
+    it 'sets and gets the credentials' do
+      ab.dashboard_credentials(name: 'foo', password: 'bar')
+      expect(ab.dashboard_credentials).to eq(name: 'foo', password: 'bar')
+    end
+  end
+
+  describe Ablab::Experiment do
+    let(:experiment) do
+      Ablab::Experiment.new('foo') do; end
+    end
+
+    it 'automatically creates a control group' do
+      expect(experiment.control).to be_a(Ablab::Group)
+      expect(experiment.groups).to_not be_empty
+    end
+
+    it 'symbolizes its name' do
+      expect(experiment.name).to eq(:foo)
+    end
+
+    describe '#description' do
+      it 'sets the description' do
+        experiment.description 'foo bar'
+        expect(experiment.description).to eq('foo bar')
+      end
+    end
+
+    describe '#description' do
+      it 'sets the experiment goal' do
+        experiment.goal 'foo bar'
+        expect(experiment.goal).to eq('foo bar')
+      end
+    end
+
+    describe '#group' do
+      it 'creates a group' do
+        experiment.group :a, description: 'foo bar baz'
+        expect(experiment.groups.last).to be_a(Ablab::Group)
+        expect(experiment.groups.last.description).to eq('foo bar baz')
+      end
+
+      it 'symbolizes the group name' do
+        experiment.group 'yeah'
+        expect(experiment.groups.last.name).to eq(:yeah)
+      end
+    end
+
+    describe '.results' do
+      it 'returns the results of the experiment' do
+        experiment.group :x, description: 'a test group'
+        allow(Ablab.tracker).to receive(:views) do |_, group|
+          { control: 201, x: 238 }[group]
+        end
+        allow(Ablab.tracker).to receive(:sessions) do |_, group|
+          { control: 182, x: 188 }[group]
+        end
+        allow(Ablab.tracker).to receive(:successes) do |_, group|
+          { control: 38, x: 70 }[group]
+        end
+        allow(Ablab.tracker).to receive(:conversions) do |_, group|
+          { control: 35, x: 61 }[group]
+        end
+        results = experiment.results
+        expect(results[:control]).to eq({
+          views:       201,
+          sessions:    182,
+          successes:   38,
+          conversions: 35,
+          control:     true,
+          description: 'control group'
+        })
+        expect(results[:x]).to eq({
+          views:       238,
+          sessions:    188,
+          successes:   70,
+          conversions: 61,
+          control:     false,
+          z_score:     2.9410157224928595,
+          description: 'a test group'
+        })
+      end
+    end
+  end
+
+  describe Ablab::Run do
+    let(:experiment) do
+      Ablab::Experiment.new(:foo) do
+        group :a
+        group :b
+      end
+    end
+
+    it 'gets assigned to the right group' do
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 0
+      expect(run).to be_in_group(:control)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 334
+      expect(run).to be_in_group(:a)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 999
+      expect(run).to be_in_group(:b)
+    end
+
+    it 'assigns the same session ID to the same group' do
+      run1 = Ablab::Run.new(experiment, 'foobar')
+      run2 = Ablab::Run.new(experiment, 'foobar')
+      expect(run1.group).to eq(run2.group)
+    end
+  end
+end