fabes 0.0.1

data/lib/fabes/helper.rb

@@ -0,0 +1,67 @@
+module Fabes
+  module Helper
+    def fabes(name, control, *alternatives)
+      experiment = Fabes::Experiment.find_or_create(name, *([control] + alternatives))
+      if trackable_for experiment.name
+        alternative = experiment.select_alternative!
+        set_cookie_for experiment, alternative
+        alternative.increment_participants!
+        alternative.update_weight
+      else
+        alternative = current_alternative_for experiment
+      end
+
+      alternative.payload
+    rescue
+      control
+    end
+
+    def score!(name)
+      experiment = Fabes::Experiment.find name
+      alternative = current_alternative_for experiment
+      if scorable? experiment.name
+        alternative.increment_hits!
+        alternative.update_weight
+        mark_as_scored experiment.name
+      end
+    rescue
+      #Failed scoring, do nothin'
+      nil
+    end
+
+    private
+
+    def tracking
+      session[:fabes] ||= {}
+    end
+
+    def set_cookie_for(experiment, alternative)
+      tracking[experiment.name] = alternative.id
+    end
+
+    def current_alternative_for(experiment)
+      id = tracking[experiment.name]
+      experiment.find_alternative id
+    end
+
+    def trackable_for(name)
+      !has_cookie_for(name) && !marked_as_scored?(name)
+    end
+
+    def has_cookie_for(name)
+      !tracking[name].nil?
+    end
+
+    def scorable?(name)
+      has_cookie_for(name) && !marked_as_scored?(name)
+    end
+
+    def marked_as_scored?(name)
+      tracking[name] == :done
+    end
+
+    def mark_as_scored(name)
+      tracking[name] = :done
+    end
+  end
+end

data/lib/fabes/utils.rb

@@ -0,0 +1,6 @@
+#TODO: improve this
+class Object
+  def log(msg)
+    puts msg
+  end
+end

data/lib/fabes.rb

@@ -0,0 +1,31 @@
+require 'fabes/utils'
+require 'fabes/configuration'
+require 'fabes/experiment'
+require 'fabes/alternative'
+require 'fabes/connection_handling'
+require 'fabes/helper'
+require 'fabes/admin'
+
+module Fabes
+  extend self
+  attr_accessor :configuration
+
+  def configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+    configuration
+  end
+
+  def db
+    @db ||= ConnectionHandling.establish_connection Fabes.configuration.db, Fabes.configuration.adapter
+  end
+end
+
+Fabes.configure
+
+if defined? Rails
+  ActionController::Base.send :include, Fabes::Helper
+  ActionController::Base.helper Fabes::Helper
+  #TODO: Autoadd route to admin panel
+  #TODO: Railtie???
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/test/'
+end
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'fabes'
+
+def session
+    @session ||= {}
+end
+
+class Test::Unit::TestCase
+  def setup
+    Redis.new.flushdb
+  end
+end

data/test/test_abstract_adapter.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class TestAbstractAdapter < Test::Unit::TestCase
+  context 'establish_connection' do
+    should 'raise if no suitable adapter' do
+      assert_raise RuntimeError do
+        adapter = 'caca'
+        db = ''
+        Fabes::ConnectionHandling.establish_connection(db, adapter)
+      end
+    end
+
+    should 'work if suitable adapter (redis)' do
+      adapter = 'redis'
+      db = ''
+      Fabes::ConnectionHandling.expects :redis_connection
+      Fabes::ConnectionHandling.establish_connection(db, adapter)
+    end
+  end
+end

data/test/test_alternative.rb

@@ -0,0 +1,92 @@
+require 'helper'
+
+class TestAlternative < Test::Unit::TestCase
+  context 'initialization' do
+    should 'have an id' do
+      alternative = Fabes::Alternative.new 'abc'
+      assert_not_nil alternative.id
+    end
+
+    should 'have a weight' do
+      alternative = Fabes::Alternative.new 'abc'
+      assert_not_nil alternative.weight
+      assert_equal alternative.weight, 0
+    end
+
+    should 'have a payload' do
+      alternative = Fabes::Alternative.new 'abc'
+      assert_not_nil alternative.payload
+      assert_equal alternative.payload, 'abc'
+    end
+
+    should 'have participants' do
+      alternative = Fabes::Alternative.new 'abc'
+      assert_not_nil alternative.participants
+      assert_equal alternative.participants, 0
+    end
+
+    should 'have hits' do
+      alternative = Fabes::Alternative.new 'abc'
+      assert_not_nil alternative.hits
+      assert_equal alternative.hits, 0
+    end
+  end
+
+  context 'increment_participants!' do
+    should 'be able to increment its participants' do
+      alternative = Fabes::Alternative.new 'abc'
+
+      assert_equal alternative.participants, 0
+      alternative.increment_participants!
+      assert_equal alternative.participants, 1
+    end
+  end
+
+  context 'increment_hits!' do
+    should 'be able to increment its hits' do
+      alternative = Fabes::Alternative.new 'abc'
+
+      assert_equal alternative.hits, 0
+      alternative.increment_hits!
+      assert_equal alternative.hits, 1
+    end
+  end
+
+  context 'update_weight' do
+    should 'be able to update the weight'
+
+    should 'calculate the new weight' do
+      alternative = Fabes::Alternative.new 'abc'
+      alternative.participants = 10
+      alternative.hits = 1
+      alternative.update_weight
+
+      assert_equal alternative.weight, 0.1
+    end
+  end
+
+  context 'create_from' do
+    should 'create a new alternative from the required data' do
+      hash = {payload: 1}
+      alternative = Fabes::Alternative.create_from(hash)
+      assert_not_nil alternative
+      assert_equal alternative.class, Fabes::Alternative
+    end
+
+    should 'create the new alternative with the given data' do
+      hash = {payload: 1, id: 'abc', weight: 0.5, participants: 9, hits: 2}
+      alternative = Fabes::Alternative.create_from(hash)
+      assert_equal alternative.payload, 1
+      assert_equal alternative.id, 'abc'
+      assert_equal alternative.weight, 0.5
+      assert_equal alternative.participants, 9
+      assert_equal alternative.hits, 2
+    end
+
+    should 'fail creating a new alternative if not enough data' do
+      assert_raise RuntimeError do
+        Fabes::Alternative.create_from(caca: 1)
+      end
+    end
+  end
+end

data/test/test_configuration.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestConfiguration < Test::Unit::TestCase
+  context 'initialization' do
+    should 'have an adapter' do
+      configuration = Fabes::Configuration.new
+      assert configuration.respond_to? :adapter
+    end
+  end
+
+  context 'dsl' do
+    should 'have a use command' do
+      configuration = Fabes::Configuration.new
+      assert configuration.respond_to? :use
+    end
+
+    should 'set the adapter' do
+      configuration = Fabes.configure do |c|
+        c.use db: 'abc', adapter: :redis
+      end
+      assert_not_nil configuration.instance_variable_get :@adapter
+      assert_equal configuration.instance_variable_get(:@adapter), 'redis'
+    end
+
+    should 'set the db' do
+      configuration = Fabes.configure do |c|
+        c.use db: 'abc', adapter: :redis
+      end
+      assert_not_nil configuration.instance_variable_get(:@db)
+      assert_equal configuration.instance_variable_get(:@db), 'abc'
+    end
+  end
+end

data/test/test_experiment.rb

@@ -0,0 +1,112 @@
+require 'helper'
+
+class TestExperiment < Test::Unit::TestCase
+
+  context 'initialization' do
+    should "have a name" do
+      experiment = Fabes::Experiment.new 'test', 'yay'
+      assert experiment.respond_to? :name
+    end
+
+    should "set a name" do
+      experiment = Fabes::Experiment.new 'test', 'yay'
+      experiment.name = 'Test name'
+      assert_equal experiment.name, 'Test name'
+    end
+
+    should "set a description" do
+      experiment = Fabes::Experiment.new 'test', 'yay'
+      experiment.description = 'yay'
+      assert_equal experiment.description, 'yay'
+    end
+
+    should "raise error if no name given" do
+      assert_raise ArgumentError do
+        experiment = Fabes::Experiment.new
+      end
+    end
+
+    should "be initialized with a name" do
+      experiment = Fabes::Experiment.new 'test', 'yay'
+      assert_not_nil experiment
+      assert_equal experiment.name, 'test'
+    end
+  end
+
+  context 'alternative' do
+    setup do
+      @experiment = Fabes::Experiment.new 'test', 'yay', 'yey'
+    end
+
+    should 'be able to select an alternative' do
+      assert @experiment.respond_to? :select_alternative!
+    end
+
+    should 'return an alternative' do
+      alternative = @experiment.select_alternative!
+      assert_equal alternative.class, Fabes::Alternative
+    end
+
+    should 'return a valid alternative' do
+      alternative = @experiment.select_alternative!
+      assert alternative.payload.match /y?y/
+    end
+
+    should 'shuffle when exploration'
+
+    should 'select the heaviest when exploitation' do
+      @experiment.alternatives.first.weight = 0.1
+      @experiment.stubs(:exploration?).returns(:false)
+      alternative = @experiment.select_alternative!
+      assert_not_equal alternative.id, @experiment.alternatives.first
+    end
+  end
+
+  context 'save' do
+    should 'save the experiment' do
+      experiment = Fabes::Experiment.new 'test', 'yay'
+      Fabes.stubs(db: mock(:save_experiment))
+
+      experiment.save
+    end
+  end
+
+  context 'find' do
+    should 'find the given experiment' do
+      Fabes::Experiment.new 'test', 'yay'
+      experiment = Fabes::Experiment.find 'test'
+      assert_not_nil experiment
+      assert_equal experiment.name, 'test'
+    end
+
+    should 'return nil when experiment not found' do
+      Fabes::Experiment.new 'test', 'yay'
+      experiment = Fabes::Experiment.find 'not_found'
+      assert_nil experiment
+    end
+  end
+
+  context 'all' do
+    setup do
+      Fabes::Experiment.new 'test', 'a', 'b', 'c'
+      Fabes::Experiment.new 'test2', 1, 2, 3
+      @experiments = Fabes::Experiment.all
+    end
+
+    should 'find all experiments (class)' do
+      @experiments.each do |exp|
+        assert_equal exp.class, Fabes::Experiment
+      end
+    end
+
+    should 'find all experiments (name)' do
+      @experiments.map(&:name).each do |name|
+        assert %w(test test2).include?(name)
+      end
+    end
+
+    should 'find all experiments (count)' do
+      assert_equal @experiments.count, 2
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,82 @@
+require 'helper'
+
+class TestHelper < Test::Unit::TestCase
+  include  Fabes::Helper
+
+  def tracking
+    session[:fabes] ||= {}
+  end
+
+  context 'fabes' do
+    should 'be able to start an experiment' do
+      assert self.respond_to? :fabes
+    end
+
+    should 'return a valid alternative' do
+      alternative = fabes 'test', 1, 2, 3
+      assert_not_nil alternative
+      assert %w(1 2 3).include?(alternative.to_s)
+    end
+
+    should 'return control when error' do
+      Fabes::Experiment.expects(:find_or_create).then.raises(StandardError)
+      alternative = fabes 'test', 1, 2, 3
+      assert_not_nil alternative
+      assert_equal alternative, 1
+    end
+
+    should 'memorize options' do
+      alternative = fabes 'test', 'a', 'b', 'c'
+      second_alternative = fabes 'test', 'a', 'b', 'c'
+      assert_equal alternative, second_alternative
+    end
+
+    should 'increment the participant count if trackable' do
+      self.expects(:trackable_for).returns(true)
+      Fabes::Alternative.any_instance.expects :increment_participants!
+      alternative = fabes 'test', 1, 2, 3
+    end
+
+    should 'not increment the participant count if already participated' do
+      self.expects(:trackable_for).returns(false)
+      Fabes::Alternative.any_instance.expects(:increment_participants!).times(0)
+      alternative = fabes 'test', 1, 2, 3
+    end
+  end
+
+  context 'score' do
+    setup do
+      @experiment = Fabes::Experiment.new('test', 1, 2, 3)
+      @alternative = @experiment.alternatives.first
+      tracking['test'] = @alternative.id
+    end
+    should 'be able to finish an experiment' do
+      assert self.respond_to? :score!
+    end
+
+    should 'increment hits for an experiment' do
+      Fabes::Alternative.any_instance.expects :increment_hits!
+      score! 'test'
+    end
+
+    should 'not score twice the same person/experiment' do
+      Fabes::Alternative.any_instance.expects(:increment_hits!).once
+      score! 'test'
+      score! 'test'
+    end
+
+    should 'not score if not a participant' do
+      self.expects(:scorable?).returns(false)
+      Fabes::Alternative.any_instance.expects(:increment_hits!).times(0)
+      score! 'test'
+    end
+
+    should 'score two different experiments' do
+      @experiment2 = Fabes::Experiment.new('test2', 4, 5, 6)
+      tracking['test2'] = @experiment2.alternatives.first.id
+      Fabes::Alternative.any_instance.expects(:increment_hits!).twice
+      score! 'test'
+      score! 'test2'
+    end
+  end
+end

data/test/test_redis_adapter.rb

@@ -0,0 +1,67 @@
+require 'helper'
+require 'redis'
+
+class TestRedisAdapter < Test::Unit::TestCase
+  context 'ConnectionHandling' do
+    context 'redis_connection' do
+      should 'create a new adapter' do
+        Fabes::ConnectionAdapters::RedisAdapter.expects :new
+        Fabes::ConnectionHandling.redis_connection({})
+      end
+    end
+  end
+
+  context 'ConnectionAdapters' do
+    setup do
+      @db = Redis.new
+      @adapter = Fabes::ConnectionAdapters::RedisAdapter.new(@db)
+      @experiment = Fabes::Experiment.new 'test', 'a', 'b', 'c'
+      @adapter.save_experiment(@experiment)
+    end
+
+    should 'clear the db' do
+      @db.set 'test', 'yay'
+      @adapter.clear!
+      assert_not_equal @db.get('test'), 'yay'
+    end
+
+    should 'save an experiment to the db' do
+      assert_equal @db.scard('fabes:experiments'), 1
+      assert @db.sismember 'fabes:experiments', 'test'
+    end
+
+    should 'save the alternatives to the db' do
+      @experiment.alternatives.each do |alt|
+        assert @db.exists "fabes:alternatives_pool:#{alt.id}"
+        data = @db.hgetall "fabes:alternatives_pool:#{alt.id}"
+        data.each do |field, value|
+          assert_equal alt.send(field).to_s, value
+        end
+      end
+    end
+
+    should 'not find an inexistant experiment' do
+      assert_nil @adapter.find_experiment('not_foundable')
+    end
+
+    should 'find an experiment' do
+      found_experiment = @adapter.find_experiment('test')
+      assert_not_nil found_experiment
+      assert_equal found_experiment.name, @experiment.name
+    end
+
+    should 'find an experiment with the correct data' do
+      found_experiment = @adapter.find_experiment('test')
+      found_experiment.alternatives.each do |alt|
+        %w(a b c).each do |expected_payload|
+          expected_payload.include? alt.payload
+        end
+      end
+    end
+
+    should 'find an experiment with the correct control' do
+      found_experiment = @adapter.find_experiment('test')
+      assert_equal found_experiment.control.payload, 'a'
+    end
+  end
+end