conductor 0.2.16 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.16
+0.3.0

data/lib/conductor.rb

@@ -4,6 +4,7 @@ require 'conductor/weights'
 require 'conductor/experiment/raw'
 require 'conductor/experiment/daily'
 require 'conductor/experiment/weight'
+require 'conductor/experiment/history'
 
 class Conductor
   MAX_WEIGHTING_FACTOR = 1.25
@@ -34,6 +35,14 @@ class Conductor
       puts msg if DBG
     end
   end
+  
+  # class Rails
+  #    cattr_writer :cache
+  # 
+  #    def self.cache
+  #      []
+  #    end
+  #  end
 end
 
 

data/lib/conductor/experiment.rb

@@ -1,7 +1,7 @@
 class Conductor
   class Experiment
     class << self
-      # Selects the best option for a given group
+      # Selects the best alternative for a given group
       #
       # Method also saves the selection to the
       # database so everything happens in one move
@@ -25,8 +25,8 @@ class Conductor
         selection = Conductor.cache.read("Conductor::#{Conductor.identity}::Experience::#{group_name}")
 
         unless selection
-          selection = select_option_for_group(group_name, alternatives)
-          Conductor::RawExperiment.create!({:identity_id => Conductor.identity.to_s, :group_name => group_name, :option_name => selection}.merge!(options))
+          selection = select_alternative_for_group(group_name, alternatives)
+          Conductor::Experiment::Raw.create!({:identity_id => Conductor.identity.to_s, :group_name => group_name, :alternative => selection}.merge!(options))
           Conductor.cache.write("Conductor::#{Conductor.identity}::Experience::#{group_name}", selection)
         end
 
@@ -69,13 +69,13 @@ class Conductor
       #
       def track!(options={})
         value = (options.delete(:value) || 1) # => pull the conversion value and remove from hash or set value to 1
-        experiments = Conductor::RawExperiment.find(:all, :conditions => {:identity_id => Conductor.identity}.merge!(options))
+        experiments = Conductor::Experiment::Raw.find(:all, :conditions => {:identity_id => Conductor.identity}.merge!(options))
         experiments.each {|x| x.update_attributes(:conversion_value => value)} if experiments
       end
 
       private
 
-        def select_option_for_group(group_name, alternatives)
+        def select_alternative_for_group(group_name, alternatives)
           # create weighting table
           weighting_table = generate_weighting_table(group_name, alternatives)
 
@@ -88,26 +88,26 @@ class Conductor
         #
         # Note: We create sql where statement that includes the list of
         # alternatives to select from in case an existing group
-        # has an option you no longer want to include in the result set
+        # has an alternative you no longer want to include in the result set
         #
         # TODO: store all weights for a group in cache and then weed out 
         # those not in the alternatives list
         #
         def generate_weighting_table(group_name, alternatives)
           # create the conditions after sanitizing sql.
-          option_conditions = alternatives.inject([]) {|res,x| res << "option_name = '#{sanitize(x)}'"}.join(' OR ')
+          alternative_filter = alternatives.inject([]) {|res,x| res << "alternative = '#{sanitize(x)}'"}.join(' OR ')
 
-          conditions = "group_name = '#{group_name}' AND (#{option_conditions})"
+          conditions = "group_name = '#{group_name}' AND (#{alternative_filter})"
 
-          # get the options from the database
-          weights ||= Conductor::WeightedExperiment.find(:all, :conditions => conditions)
+          # get the alternatives from the database
+          weights ||= Conductor::Experiment::Weight.find(:all, :conditions => conditions)
 
           # create selection hash
-          weighting_table = weights.inject({}) {|res, x| res.merge!({x.option_name => x.weight})}
+          weighting_table = weights.inject({}) {|res, x| res.merge!({x.alternative => x.weight})}
 
           # is anything missing?
-          options_names = weights.map(&:option_name)
-          missing = alternatives - options_names
+          alternative_names = weights.map(&:alternative)
+          missing = alternatives - alternative_names
 
           # if anything is missing, add it to the weighted list
           unless missing.empty?
@@ -126,7 +126,7 @@ class Conductor
           return (rand*width)+start_num
         end
 
-        # choose a random option based on weights
+        # choose a random alternative based on weights
         # from recipe 5.11 in ruby cookbook
         def choose_weighted(weighted)
           sum = weighted.inject(0) do |sum, item_and_weight|

data/lib/conductor/experiment/raw.rb

@@ -14,7 +14,7 @@
 class Conductor::Experiment::Raw < ActiveRecord::Base
   set_table_name "conductor_raw_experiments"
   
-  validates_presence_of :group_name, :option_name
+  validates_presence_of :group_name, :alternative
   
   def created_date
     self.created_at.strftime('%Y-%m-%d')

data/lib/conductor/roll_up.rb

@@ -1,19 +1,19 @@
 class Conductor
   class RollUp
     def self.process
-      Conductor::RawExperiment.all.group_by(&:created_date).each do |day, daily_rows|
+      Conductor::Experiment::Raw.all.group_by(&:created_date).each do |day, daily_rows|
 
         # remove all the existing data for that day
-        Conductor::DailyExperiment.delete_all(:activity_date => day)
+        Conductor::Experiment::Daily.delete_all(:activity_date => day)
 
         daily_rows.group_by(&:group_name).each do |group_name, group_rows|
-          group_rows.group_by(&:option_name).each do |option_name, option_rows|
-            conversion_value = option_rows.select {|x| !x.conversion_value.nil?}.inject(0) {|res, x| res += x.conversion_value}
-            views = option_rows.count
-            conversions = option_rows.count {|x| !x.conversion_value.nil?}
-            Conductor::DailyExperiment.create!(:activity_date => day,
+          group_rows.group_by(&:alternative).each do |alternative_name, alternatives|
+            conversion_value = alternatives.select {|x| !x.conversion_value.nil?}.inject(0) {|res, x| res += x.conversion_value}
+            views = alternatives.count
+            conversions = alternatives.count {|x| !x.conversion_value.nil?}
+            Conductor::Experiment::Daily.create!(:activity_date => day,
                                          :group_name => group_name,
-                                         :option_name => option_name,
+                                         :alternative => alternative_name,
                                          :conversion_value => conversion_value,
                                          :views => views,
                                          :conversions => conversions )

data/lib/conductor/weights.rb

@@ -2,10 +2,10 @@ class Conductor
   class Weights
     class << self
       def compute
-        Conductor::WeightedExperiment.delete_all # => remove all old data
+        Conductor::Experiment::Weight.delete_all # => remove all old data
 
-        # loop through each group and determing weight of options
-        Conductor::DailyExperiment.since(14.days.ago).group_by(&:group_name).each do |group_name, group_rows|
+        # loop through each group and determing weight of alternatives
+        Conductor::Experiment::Daily.since(14.days.ago).group_by(&:group_name).each do |group_name, group_rows|
           total = group_rows.sum_it(:conversion_value)
           data = total ? compute_weights_for_group(group_name, group_rows, total) : assign_equal_weights(group_rows)
           update_weights_in_db(group_name, data)
@@ -14,7 +14,7 @@ class Conductor
 
       private
 
-        # loops through all the options for a given group and computes the weights for
+        # loops through all the alternatives for a given group and computes the weights for
         # each alternative
         def compute_weights_for_group(group_name, group_rows, total)
           Conductor.log('compute_weights_for_group')
@@ -23,15 +23,15 @@ class Conductor
           recently_launched = []
           max_weight = 0
 
-          group_rows.group_by(&:option_name).each do |option_name, option_rows|
-            first_found_date = option_rows.map(&:activity_date).sort.first
+          group_rows.group_by(&:alternative).each do |alternative_name, alternatives|
+            first_found_date = alternatives.map(&:activity_date).sort.first
             days_ago = Date.today - first_found_date
 
             if days_ago >= MINIMUM_LAUNCH_DAYS
-              data << compute_weight_for_option(option_name, option_rows, max_weight, total)
+              data << compute_weight_for_alternative(alternative_name, alternatives, max_weight, total)
             else
-              Conductor.log("adding #{option_name} to recently launched array")
-              recently_launched << {:name => option_name, :days_ago => days_ago}
+              Conductor.log("adding #{alternative_name} to recently launched array")
+              recently_launched << {:name => alternative_name, :days_ago => days_ago}
             end
           end
 
@@ -39,12 +39,12 @@ class Conductor
           return data
         end
 
-        def compute_weight_for_option(option_name, option_rows, max_weight, total)
-          Conductor.log("compute_weight_for_option for #{option_name}")
+        def compute_weight_for_alternative(alternative_name, alternatives, max_weight, total)
+          Conductor.log("compute_weight_for_alternative for #{alternative_name}")
 
-          aggregates = {:name => option_name}
+          aggregates = {:name => alternative_name}
 
-          weight = option_rows.sum_it(:conversion_value) / total
+          weight = alternatives.sum_it(:conversion_value) / total
           max_weight = weight if weight > max_weight
           aggregates.merge!({:weight => weight})
 
@@ -58,11 +58,11 @@ class Conductor
           data = []
           max_weight = 0 ? 1 : max_weight # => if a max weight could not be computed, set it to 1
           Conductor.log("max weight: #{max_weight}")
-          recently_launched.each do |option|
-            handicap = (option[:days_ago].to_f / MINIMUM_LAUNCH_DAYS)
-            launch_window = (MINIMUM_LAUNCH_DAYS - option[:days_ago]) if MINIMUM_LAUNCH_DAYS > option[:days_ago]
-            Conductor.log("Handicap for #{option[:name]} is #{handicap} (#{option[:days_ago]} days ago)")
-            data << {:name => option[:name], :weight => max_weight * MAX_WEIGHTING_FACTOR * (1 - handicap), :launch_window => launch_window}
+          recently_launched.each do |alternative|
+            handicap = (alternative[:days_ago].to_f / MINIMUM_LAUNCH_DAYS)
+            launch_window = (MINIMUM_LAUNCH_DAYS - alternative[:days_ago]) if MINIMUM_LAUNCH_DAYS > alternative[:days_ago]
+            Conductor.log("Handicap for #{alternative[:name]} is #{handicap} (#{alternative[:days_ago]} days ago)")
+            data << {:name => alternative[:name], :weight => max_weight * MAX_WEIGHTING_FACTOR * (1 - handicap), :launch_window => launch_window}
           end
           data
         end
@@ -72,17 +72,17 @@ class Conductor
 
           # weight everything the same since there were no conversions
           data = []
-          group_rows.group_by(&:option_name).each do |option_name, option_rows|
-            data << {:name => option_name, :weight => 1}
+          group_rows.group_by(&:alternative).each do |alternative_name, alternatives|
+            data << {:name => alternative_name, :weight => 1}
           end
           data
         end
 
         # creates new records in weights table and adds weights to weight history for reporting
         def update_weights_in_db(group_name, data)
-          data.each { |option|
-            Conductor::WeightedExperiment.create!(:group_name => group_name, :option_name => option[:name], :weight => option[:weight])
-            Conductor::WeightHistory.create!(:group_name => group_name, :option_name => option[:name], :weight => option[:weight], :launch_window => option[:launch_window], :computed_at => Time.now)
+          data.each { |alternative|
+            Conductor::Experiment::Weight.create!(:group_name => group_name, :alternative => alternative[:name], :weight => alternative[:weight])
+            Conductor::Experiment::History.create!(:group_name => group_name, :alternative => alternative[:name], :weight => alternative[:weight], :launch_window => alternative[:launch_window], :computed_at => Time.now)
           }
         end
 

data/test/db/schema.rb

@@ -0,0 +1,43 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table "conductor_daily_experiments", :force => true do |t|
+    t.date    "activity_date"
+    t.string  "group_name"
+    t.string  "alternative"
+    t.decimal "conversion_value", :precision => 8, :scale => 2
+    t.integer "views"
+    t.integer "conversions"
+  end
+
+  add_index "conductor_daily_experiments", ["activity_date"], :name => "index_conductor_daily_experiments_on_activity_date"
+  add_index "conductor_daily_experiments", ["group_name"], :name => "index_conductor_daily_experiments_on_group_name"
+
+  create_table "conductor_raw_experiments", :force => true do |t|
+    t.string   "identity_id"
+    t.string   "group_name"
+    t.string   "alternative"
+    t.decimal  "conversion_value", :precision => 8, :scale => 2
+    t.datetime "created_at"
+    t.datetime "updated_at"
+    t.string   "goal"
+  end
+
+  create_table "conductor_weight_histories", :force => true do |t|
+    t.string   "group_name"
+    t.string   "alternative"
+    t.decimal  "weight",        :precision => 8, :scale => 2
+    t.datetime "computed_at"
+    t.integer  "launch_window"
+  end
+
+  add_index "conductor_weight_histories", ["computed_at", "group_name"], :name => "conductor_wh_date_and_group_ndx"
+
+  create_table "conductor_weighted_experiments", :force => true do |t|
+    t.string   "group_name"
+    t.string   "alternative"
+    t.decimal  "weight",      :precision => 8, :scale => 2
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  add_index "conductor_weighted_experiments", ["group_name"], :name => "index_conductor_weighted_experiments_on_group_name"
+end

data/test/test_conductor.rb

@@ -1,225 +1,219 @@
-require 'helper'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class TestConductor < Test::Unit::TestCase
-  #Wipes cache, D/B prior to doing a test run.
-   VectorSixteen.cache.clear
+  # Wipes cache, D/B prior to doing a test run.
+  def setup
+    Conductor.cache.clear
+    wipe
+  end
+
+  context "conductor" do
+    should "assign an identity if none is specified" do
+      assert Conductor.identity != nil
+    end
 
-   test "will automatically assign an identity if none is specified" do
-     assert VectorSixteen.identity != nil
-   end
+    should "select one of the specified options randomly" do
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+      assert ["a", "b", "c"].include? selected
+    end
 
-   test "will select one of the specified options randomly" do
-     selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
-     assert ["a", "b", "c"].include? selected
-   end
+    should "almost equally select each option if no weights exist" do
+      a = 0
+      b = 0
+      c = 0
+      (1..1000).each do |x|
+        Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+        selected_lander = Conductor::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+        case selected_lander
+        when 'a' then
+          a += 1
+        when 'b' then
+          b += 1
+        when 'c' then
+          c += 1
+        end
+      end
+
+      nums = [] << a << b << c
+      nums.sort!
+      range = nums.last - nums.first
+
+      assert (nums.first * 0.20) >= range
+    end
+  end
 
-   test "will always select the same option using the cache" do
-     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+  context "a single site visitor" do
+    setup do
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+    end
 
-     selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
-     different = false
+    should "always select the same alternative when using the cache" do
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+      different = false
 
-     (1..100).each do |x|
-       different = true if selected != VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"])
-     end
+      (1..100).each do |x|
+        different = true if selected != Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      end
 
-     assert !different
-   end
+      assert !different
+    end
 
-   test "will select a lander and then successfully record a conversion" do
-     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
-     selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+    should "select a lander and then successfully record a conversion" do
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
 
-     VectorSixteen::Experiment.track!
+      Conductor::Experiment.track!
 
-     experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
-     assert_equal 1, experiments.count
-     assert_equal 1, experiments.first.conversion_value
-   end
+      experiments = Conductor::Experiment::Raw.find_all_by_identity_id(Conductor.identity)
+      assert_equal 1, experiments.count
+      assert_equal 1, experiments.first.conversion_value
+    end
 
-   test "will select a lander and then successfully record custom conversion value" do
-      VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
-      selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+    should "select a lander and then successfully record custom conversion value" do
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
 
-      VectorSixteen::Experiment.track!({:value => 12.34})
+      Conductor::Experiment.track!({:value => 12.34})
 
-      experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
+      experiments = Conductor::Experiment::Raw.find_all_by_identity_id(Conductor.identity)
       assert_equal 1, experiments.count
       assert_equal 12.34, experiments.first.conversion_value
     end
 
+    should "record three different experiments with two goals but a single conversion for all goals for the same identity" do
+      first = Conductor::Experiment.pick('a_group', ["a", "b", "c"], {:goal => 'goal_1'}) # => value must be unique
+      second = Conductor::Experiment.pick('b_group', ["1", "2", "3"], {:goal => 'goal_2'}) # => value must be unique
+      third = Conductor::Experiment.pick('c_group', ["zz", "xx", "yy"], {:goal => 'goal_1'}) # => value must be unique
 
+      Conductor::Experiment.track!
 
-   test "will record three different experiments with two goals but a single conversion for all goals for the same identity" do
-     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
-     first = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"], {:goal => 'goal_1'}) # => value must be unique
-     second = VectorSixteen::Experiment.pick('b_group', ["1", "2", "3"], {:goal => 'goal_2'}) # => value must be unique
-     third = VectorSixteen::Experiment.pick('c_group', ["zz", "xx", "yy"], {:goal => 'goal_1'}) # => value must be unique
-
-     VectorSixteen::Experiment.track!
-
-     experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
-     assert_equal 3, experiments.count
-     assert_equal 2, experiments.count {|x| x.goal == 'goal_1'}
-     assert_equal 3, experiments.sum_it(:conversion_value)
-   end
+      experiments = Conductor::Experiment::Raw.find_all_by_identity_id(Conductor.identity)
+      assert_equal 3, experiments.count
+      assert_equal 2, experiments.count {|x| x.goal == 'goal_1'}
+      assert_equal 3, experiments.sum_it(:conversion_value)
+    end
 
-   test "will record three different experiments with two goals but only track a conversion for goal_1" do
-     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
-     first = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"], {:goal => 'goal_1'}) # => value must be unique
-     second = VectorSixteen::Experiment.pick('b_group', ["1", "2", "3"], {:goal => 'goal_2'}) # => value must be unique
-     third = VectorSixteen::Experiment.pick('c_group', ["zz", "xx", "yy"], {:goal => 'goal_1'}) # => value must be unique
+    should "record three different experiments with two goals but only track a conversion for goal_1" do
+      first = Conductor::Experiment.pick('a_group', ["a", "b", "c"], {:goal => 'goal_1'}) # => value must be unique
+      second = Conductor::Experiment.pick('b_group', ["1", "2", "3"], {:goal => 'goal_2'}) # => value must be unique
+      third = Conductor::Experiment.pick('c_group', ["zz", "xx", "yy"], {:goal => 'goal_1'}) # => value must be unique
 
-     VectorSixteen::Experiment.track!({:goal => 'goal_1'})
+      Conductor::Experiment.track!({:goal => 'goal_1'})
 
-     experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
-     assert_equal 3, experiments.count
-     assert_equal 2, experiments.count {|x| x.goal == 'goal_1'}
-     assert_equal 2, experiments.sum_it(:conversion_value)
-   end
+      experiments = Conductor::Experiment::Raw.find_all_by_identity_id(Conductor.identity)
+      assert_equal 3, experiments.count
+      assert_equal 2, experiments.count {|x| x.goal == 'goal_1'}
+      assert_equal 2, experiments.sum_it(:conversion_value)
+    end
+  end
 
+  context "conductor" do
+    setup do
+      seed_raw_data(100)
+      Conductor::RollUp.process
+    end
 
-   test "will almost equally select each option if no weights exist" do
-     a = 0
-     b = 0
-     c = 0
-     (1..1000).each do |x|
-       selected_lander = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
-       case selected_lander
-       when 'a' then
-         a += 1
-       when 'b' then
-         b += 1
-       when 'c' then
-         c += 1
-       end
-     end
+    should "correctly RollUp daily data" do
+      assert Conductor::Experiment::Daily.count > 2
+      assert Conductor::Experiment::Daily.all.detect {|x| x.conversions > 0}
+      assert Conductor::Experiment::Daily.all.detect {|x| x.views > 0}
+      assert Conductor::Experiment::Daily.all.detect {|x| x.conversion_value > 0}
+    end
 
-     nums = [] << a << b << c
-     nums.sort!
-     range = nums.last - nums.first
+    should "correctly populate weighting table" do
+      Conductor::Weights.compute
+    end
+  end
 
-     assert (nums.first * 0.20) >= range
-   end
+  context "conductor" do
+    should "populate the weighting table with equal weights if all new options are launched" do
+      seed_raw_data(100, 7)
 
-   test "will correctly RollUp daily data" do
-     # seed
-     seed_raw_data(100)
+      # rollup
+      Conductor::RollUp.process
 
-     # rollup
-     VectorSixteen::RollUp.process
+      # compute weights
+      Conductor::Weights.compute
 
-     # do some checks
-     assert V16::DailyExperiment.count > 2
-     assert V16::DailyExperiment.all.detect {|x| x.conversions > 0}
-     assert V16::DailyExperiment.all.detect {|x| x.views > 0}
-     assert V16::DailyExperiment.all.detect {|x| x.conversion_value > 0}
-   end
+      # this makes the following assumptions:
+      # MINIMUM_LAUNCH_DAYS = 7
+      # each weight will be equal to 0.18
+      assert_equal 0.54, Conductor::Experiment::Weight.all.sum_it(:weight).to_f
+    end
+  end
 
-   test "will correctly populate weighting table" do
-     # seed
-     seed_raw_data(100)
+  context "conductor" do
+    setup do
+      seed_raw_data(100, 14);
 
-     # rollup
-     VectorSixteen::RollUp.process
+      # rollup
+      Conductor::RollUp.process
 
-     # compute weights
-     VectorSixteen::Weights.compute
-   end
+      # compute weights
+      Conductor::Weights.compute
+    end
 
-   test "will populate the weighting table with equal weights if all new options are launched" do
-     wipe
-     seed_raw_data(100, 7)
+    should "populate the weighting table with different weights" do
+      # if this DOES NOT work then each weight will be equal to 0.18
+      assert_not_equal 0.54, Conductor::Experiment::Weight.all.sum_it(:weight).to_f
+    end
 
-     # rollup
-     VectorSixteen::RollUp.process
+    should "record the new weights in the weight history table in database" do
+      assert Conductor::Experiment::History.count > 1
+    end
 
-     # compute weights
-     VectorSixteen::Weights.compute
+    should "return a weight 1.25 times higher than the highest weight for a newly launched and non-recorded alernative" do
+      seed_raw_data(100, 14)
 
-     # this makes the following assumptions:
-     # MINIMUM_LAUNCH_DAYS = 7
-     # each weight will be equal to 0.18
-     assert_equal 0.54, V16::WeightedExperiment.all.sum_it(:weight).to_f
-   end
+      # rollup
+      Conductor::RollUp.process
 
-   test "will populate the weighting table with different weights" do
-     wipe
-     seed_raw_data(100, 14)
+      # compute weights
+      Conductor::Weights.compute
 
-     # rollup
-     VectorSixteen::RollUp.process
-
-     # compute weights
-     VectorSixteen::Weights.compute
-
-     # if this DOES NOT work then each weight will be equal to 0.18
-     assert_not_equal 0.54, V16::WeightedExperiment.all.sum_it(:weight).to_f
-   end
-
-   test "will record the new weights in the weight history table in database" do
-     wipe
-     seed_raw_data(100, 14)
-
-     # rollup
-     VectorSixteen::RollUp.process
+      # get the highest weight
+      max_weight = Conductor::Experiment::Weight.maximum(:weight)
 
-     # compute weights
-     VectorSixteen::Weights.compute
-
-     assert V16::WeightHistory.count > 1
-   end
+      # pick something
+      weights = Conductor::Experiment.weights('a_group', ["a", "b", "c", "f"]) # => value must be unique
 
-   test "will correctly record the launch window in the weight histories table" do
-     wipe
-     seed_raw_data(10, 6)
-
-     # rollup
-     VectorSixteen::RollUp.process
+      assert_equal weights['f'], (max_weight * 1.25)
+    end
+  end
 
-     # compute weights
-     VectorSixteen::Weights.compute
-
-     # make sure that launch_window values can be detected
-     assert_not_nil V16::WeightHistory.find(:all, :conditions => 'launch_window > 0')
-   end
+  context "conductor" do
+    should "correctly record the launch window in the weight histories table" do
+      seed_raw_data(10, 6)
 
-   test "will return a weight 1.25 times higher than the highest weight for a newly launched and non-recorded alernative" do
-     wipe
-     seed_raw_data(100, 14)
+      # rollup
+      Conductor::RollUp.process
 
-     # rollup
-     VectorSixteen::RollUp.process
+      # compute weights
+      Conductor::Weights.compute
 
-     # compute weights
-     VectorSixteen::Weights.compute
+      # make sure that launch_window values can be detected
+      assert_not_nil Conductor::Experiment::History.find(:all, :conditions => 'launch_window > 0')
+    end
+  end
 
-     # get the highest weight
-     max_weight = V16::WeightedExperiment.maximum(:weight)
 
-     # pick something
-     weights = VectorSixteen::Experiment.weights('a_group', ["a", "b", "c", "f"]) # => value must be unique
 
-     assert_equal weights['f'], (max_weight * 1.25)
-   end
 
-   private
+  private
 
-   def wipe
-     V16::DailyExperiment.delete_all
-     V16::RawExperiment.delete_all
-     V16::WeightedExperiment.delete_all
-     V16::WeightHistory.delete_all
-   end
+    def wipe
+      Conductor::Experiment::Daily.delete_all
+      Conductor::Experiment::Raw.delete_all
+      Conductor::Experiment::Weight.delete_all
+      Conductor::Experiment::History.delete_all
+    end
 
-   def seed_raw_data(num, days_ago=14)
-     # seed the raw data
-     (1..num).each do |x|
-       VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+    def seed_raw_data(num, days_ago=14)
+      # seed the raw data
+      (1..num).each do |x|
+        Conductor.identity = ActiveSupport::SecureRandom.hex(16)
 
-       options = {:created_at => rand(days_ago).days.ago}
-       options.merge!({:conversion_value => rand(100)}) if rand() < 0.20 # => convert 20% of traffic
-       selected_lander = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"], options) # => value must be unique
-     end
-   end
+        options = {:created_at => rand(days_ago).days.ago}
+        options.merge!({:conversion_value => rand(100)}) if rand() < 0.20 # => convert 20% of traffic
+        selected_lander = Conductor::Experiment.pick('a_group', ["a", "b", "c"], options) # => value must be unique
+      end
+    end
 end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+ENV["RAILS_ENV"] = "test"
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'active_record'
+require 'active_record/version'
+require 'active_record/fixtures'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'action_view'
+require 'active_support'
+require 'test/unit'
+require 'conductor'
+require 'shoulda'
+
+require File.dirname(__FILE__) + '/../init.rb'
+
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/db/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'postgresql'])
+ActiveRecord::Migration.verbose = false
+load(File.dirname(__FILE__) + "/db/schema.rb")
+
+@@cache = ActiveSupport::Cache::MemoryStore.new
+
+class Test::Unit::TestCase
+  
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 16
-  version: 0.2.16
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Noctivity
@@ -43,8 +43,9 @@ files:
 - lib/conductor/experiment/weight.rb
 - lib/conductor/roll_up.rb
 - lib/conductor/weights.rb
-- test/helper.rb
+- test/db/schema.rb
 - test/test_conductor.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/noctivityinc/conductor
 licenses: []
@@ -78,5 +79,6 @@ signing_key:
 specification_version: 3
 summary: lets you just try things while always maximizing towards a goal (e.g. purchase, signups, etc)
 test_files: 
-- test/helper.rb
+- test/db/schema.rb
 - test/test_conductor.rb
+- test/test_helper.rb

data/test/helper.rb

@@ -1,9 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'conductor'
-
-class Test::Unit::TestCase
-end