absurdity 0.2.5

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.sw?
+dump.rdb

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2@absurdity

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in absurdity.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,117 @@
+=Absurdity
+
+A rails gem for absurdly simple a/b testing
+
+http://github.com/xing/absurdity
+
+==Prerequisites
+
+Redis (tested with 1.2.6, 2.2.2)
+Rails (tested with 3.0.10, 3.1.0)
+
+==Installation
+
+  gem "absurdity"
+
+==Usage
+
+===Instantiate a Redis client
+
+  Put this in an initializer, for expample config/initializers/redis_absurdity.rb:
+
+  Absurdity.redis = Redis.new(:host => "localhost", :port => 6379)
+
+Note: More often you will use a redis.conf to set up your redis client, the important part is to assign your
+redis client instance to Absurdity.redis .
+Don't forget to start your Redis server.
+
+===Define Experiments
+
+  mkdir "absurdity" in your rails app root directory
+  touch "absurdity/experiments.yml"
+
+  define your experiments in this file:
+  :experiments:
+    :wild_side:
+      :metrics:
+          - :fun
+          - :hangover
+      :variants:
+          - :with_music
+          - :without_music
+    :walk:
+      :metrics:
+          - :sun
+          - :rain
+      :variants:
+          - :slow
+          - :fast
+      :completed:
+        :fast
+
+  :wild_side will be the name of your experiment
+  [:fun, :hangover] will be the metrics you wish to track
+  [:with_music, :without_music] will be the variants you wish to vary
+
+  the :walk has been marked as completed.
+  You should identify which variant to show here (:fast).
+  Now everyone will only see the :fast variant.
+  And, no one will produce any metric tracking.
+
+  Note: You can't use the shortform for declaring an array of symbols in ruby 1.9.2 and Psych.
+  So instead of using :metrics: [:fun, :hangover] use the longer form shown above.
+
+===Usage in a controller
+
+  def create
+    Absurdity.track! :fun, :wild_side, current_user.id
+  end
+
+===Usage in view/helpers
+
+  def my_helper
+    variant = Absurdity.variant :wild_side, current_user.id
+    if variant == :with_music
+      Play.music
+    else
+      Play.nothing
+    end
+  end
+
+===View Metrics
+
+  /absurdities                 => linked list of experiments
+  /absurdities/experiment_name => show experiment
+
+==Authors
+
+{Tim Payton}[http://github.com/dizzy42]
+{Ömür Özkir}[http://github.com/oem]
+
+Please find out more about our work in our
+{tech blog}[http://blog.xing.com/category/english/tech-blog].
+
+
+==License
+
+The MIT License
+
+Copyright (c) 2011 {XING AG}[http://www.xing.com/]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+desc "Run tests"
+task :default => :test
+

data/absurdity.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "absurdity/version"
+
+Gem::Specification.new do |s|
+  s.name        = "absurdity"
+  s.version     = Absurdity::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Tim Payton", "Ömür Özkir"]
+  s.email       = "opensource@xing.com"
+  s.homepage    = "http://xing.github.com/absurdity/"
+  s.summary     = %q{Absurdly simple a/b testing}
+  s.description = %q{See summary}
+
+  s.rubyforge_project = "absurdity"
+
+  s.add_dependency("redis", ">= 0")
+  s.add_dependency("rake", ">= 0.8.7")
+
+  s.add_development_dependency("mock_redis", ">= 0")
+  s.add_development_dependency("mocha", ">= 0")
+  s.add_development_dependency("minitest", ">= 0")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/app/controllers/absurdities_controller.rb

@@ -0,0 +1,18 @@
+class AbsurditiesController < ApplicationController
+  helper :absurdity
+  layout "absurdities"
+
+  def index
+    @reports = Absurdity::Experiment.reports
+  end
+
+  def show
+    @report = Absurdity::Experiment.find(params[:id].to_sym).report
+  end
+
+  def create
+    Absurdity.track!(params[:metric], params[:experiment], params[:identity_id])
+    render nothing: true
+  end
+
+end

data/app/helpers/absurdity_helper.rb

@@ -0,0 +1,31 @@
+module AbsurdityHelper
+
+  def metric_info(metrics, metric, count)
+    content_tag(:span, "#{metric.to_s.humanize}: ", class: "metric")
+    .concat "#{count} "
+    # str += metric_ratios(metrics, metric, count)
+  end
+
+  def completed_text(completed)
+    if completed == :completed
+      content_tag(:span, "Completed")
+    elsif completed
+      content_tag(:span, "Completed: #{completed}")
+    else
+      ""
+    end
+  end
+
+  private
+
+  def metric_ratios(metrics, metric, count)
+    ratios = metrics.map do |other_metric, other_count|
+      if metric != other_metric && count != 0 && other_count != 0
+        str = "#{metric.to_s.humanize}/#{other_metric.to_s.humanize} :"
+        str += " #{number_to_percentage((count.to_f/other_count.to_f) * 100, precision: 3)}"
+        str
+      end
+    end.compact
+    ratios.present? ? "(" + ratios.join(",") + ")" : ""
+  end
+end

data/app/views/absurdities/index.html.erb

@@ -0,0 +1,12 @@
+<header>
+  <h1>Experiments</h1>
+</header>
+
+<ul class="reports">
+<% @reports.each do |report| %>
+  <li>
+    <%= link_to report[:name].to_s.humanize, absurdity_path(report[:name]) %>
+    <%= completed_text(report[:completed]) %>
+  </li>
+<% end %>
+</ul>

data/app/views/absurdities/show.html.erb

@@ -0,0 +1,22 @@
+<header>
+  <h1>Experiment</h1>
+
+  <h2>
+    <%= @report[:name].to_s.humanize %>
+  </h2>
+
+  <h3>
+    <%= completed_text(@report[:completed]) %>
+  </h3>
+</header>
+
+<ul>
+  <% @report[:data].each do |variant, metrics| %>
+    <li class="variant">
+      <h3><%= variant.to_s.humanize %></h3>
+      <% metrics.each do |metric, count| %>
+        <p><%= metric_info(metrics, metric, count) %></p>
+      <% end %>
+    </li>
+  <% end %>
+</ul>

data/app/views/layouts/absurdities.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="<%= I18n.locale %>">
+  <head>
+    <title>Absurdity - A/B Testing</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, minimum-scale=1, maximum-scale=1, user-scalable=0">
+    <link rel="apple-touch-icon" href="/images/iphone_favicon.png">
+    <link rel="prev" href="/">
+
+    <link rel="stylesheet" href="/stylesheets/absurdity.css" media="screen">
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+
+</html>

data/config/routes.rb

@@ -0,0 +1,7 @@
+Rails.application.routes.draw do
+
+  resources :absurdities,
+            :format => :html,
+            :only   => [:index, :show, :create]
+
+end

data/lib/absurdity.rb

@@ -0,0 +1,26 @@
+require 'json'
+require 'absurdity/railtie.rb' if defined?(Rails)
+require 'absurdity/engine' if defined?(Rails)
+
+module Absurdity
+  class MissingIdentityIDError < RuntimeError; end
+
+  autoload :Config,     "absurdity/config"
+  autoload :Experiment, "absurdity/experiment"
+  autoload :Metric,     "absurdity/metric"
+  autoload :Variant,    "absurdity/variant"
+  autoload :Datastore,  "absurdity/datastore"
+
+  def self.redis=(redis)
+    Config.instance.redis = redis
+  end
+
+  def self.track!(metric_slug, experiment_slug, identity_id=nil)
+    Experiment.find(experiment_slug).track!(metric_slug, identity_id)
+  end
+
+  def self.variant(experiment_slug, identity_id)
+    Experiment.find(experiment_slug).variant_for(identity_id)
+  end
+
+end

data/lib/absurdity/config.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+require 'logger'
+
+module Absurdity
+  class Config
+    include Singleton
+
+    def redis
+      @redis
+    end
+
+    def redis=(redis)
+      @redis = redis
+    end
+
+    def logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+end

data/lib/absurdity/datastore.rb

@@ -0,0 +1,172 @@
+module Absurdity
+  class Datastore
+    PARSE_AS_JSON = [
+      :metrics_list,
+      :variants_list,
+      :experiments_list
+    ]
+
+    def self.save(object)
+      klass = object.class
+      if klass == Absurdity::Experiment
+        save_experiment(object)
+      elsif klass == Absurdity::Metric
+        save_metric(object)
+      elsif klass == Absurdity::Variant
+        save_variant(object)
+      end
+    end
+
+    def self.all(klass)
+      if klass == Absurdity::Experiment
+        all_experiments
+      elsif klass == Absurdity::Metric
+        all_metrics
+      elsif klass == Absurdity::Variant
+        all_variants
+      end
+    end
+
+    def self.find(klass, options)
+      if klass == Absurdity::Experiment
+        find_experiment(options[:slug])
+      elsif klass == Absurdity::Metric
+        find_metric(options[:slug], options[:experiment_slug], options[:variant_slug])
+      elsif klass == Absurdity::Variant
+        find_variant(options[:identity_id], options[:experiment_slug])
+      end
+    end
+
+    private
+
+    def self.redis
+      Config.instance.redis
+    end
+
+
+    # FINDERS
+
+    def self.find_experiment(experiment_slug)
+      return nil unless slug = experiments_list.find { |e| e == experiment_slug }
+      experiment = Experiment.new(slug)
+      experiment.attributes[:metrics_list]  = get(:metrics_list, experiment: experiment)
+      experiment.attributes[:variants_list] = get(:variants_list, experiment: experiment)
+      experiment.attributes[:completed]     = get(:completed, experiment: experiment)
+      experiment
+    end
+
+    def self.find_metric(metric_slug, experiment_slug, variant_slug)
+      experiment = find_experiment(experiment_slug)
+      return nil unless experiment && experiment.metrics_list.find { |sl| sl == metric_slug }
+      metric = Metric.new(metric_slug, experiment_slug, variant_slug)
+      metric.instance_variable_set(:@count, metric_count(metric))
+      metric
+    end
+
+    def self.find_variant(identity_id, experiment_slug)
+      experiment = find_experiment(experiment_slug)
+      return nil unless slug = get(variant_key(identity_id), experiment: experiment)
+      Variant.new(slug, experiment_slug, identity_id)
+    end
+
+    def self.all_experiments
+      experiments_list.map { |exp| find_experiment(exp) }
+    end
+
+
+    # SAVERS
+
+    def self.save_metric(metric)
+      set(metric_key(metric), metric.count.to_i, experiment: find_experiment(metric.experiment_slug))
+    end
+
+    def self.save_experiment(experiment)
+      unless find_experiment(experiment.slug)
+        add_to_experiments_list(experiment.slug)
+        create_variants(experiment)
+        create_metrics(experiment)
+      end
+      mark_completed(experiment) if experiment.completed
+    end
+
+    def self.save_variant(variant)
+      set(variant_key(variant.identity_id), variant.slug, experiment: find_experiment(variant.experiment_slug))
+    end
+
+    def self.get(key, options={})
+      if experiment = options[:experiment]
+        store_key = "experiments:#{experiment.slug}:#{key}"
+      else
+        store_key = "experiments:#{key}"
+      end
+      string = redis.get(store_key)
+      if string.to_i.to_s == string
+        string.to_i
+      elsif PARSE_AS_JSON.include?(key)
+        string && JSON.parse(string).map { |v| v.to_sym }
+      else
+        string && string.to_sym
+      end
+    end
+
+    def self.set(key, value, options={})
+      if experiment = options[:experiment]
+        store_key = "experiments:#{experiment.slug}:#{key}"
+      else
+        store_key = "experiments:#{key}"
+      end
+      redis.set(store_key, value)
+    end
+
+    def self.metric_count(metric)
+      experiment = find_experiment(metric.experiment_slug)
+      get(metric_key(metric), experiment: experiment).to_i
+    end
+
+    def self.metric_key(metric)
+      key = metric.variant_slug ? "#{metric.variant_slug}" : ""
+      key += ":#{metric.slug}:count"
+      key
+    end
+
+    def self.variant_key(identity_id)
+      "identity_id:#{identity_id}:variant"
+    end
+
+    def self.experiments_list
+      get(:experiments_list) || []
+    end
+
+    def self.add_to_experiments_list(slug)
+      set(:experiments_list, (experiments_list << slug).to_json)
+    end
+
+    def self.create_metrics(experiment)
+      set(:metrics_list, experiment.metrics_list.to_json, experiment: experiment)
+      experiment.metrics_list.each do |metric_slug|
+        if experiment.variants?
+          experiment.variants_list.each do |variant_slug|
+            Metric.create(metric_slug, experiment.slug, variant_slug)
+          end
+        else
+          Metric.create(metric_slug, experiment.slug)
+        end
+      end
+    end
+
+    def self.create_variants(experiment)
+      if !experiment.variants_list.nil?
+        set(:variants_list, experiment.variants_list.to_json, experiment: experiment)
+      end
+    end
+
+    def self.mark_completed(experiment)
+      set(:completed, experiment.completed, experiment: experiment)
+    end
+
+    def self.logger
+      Config.instance.logger
+    end
+
+  end
+end

data/lib/absurdity/datastore/redis.rb

@@ -0,0 +1,5 @@
+module Absurdity
+  class Redis < Datastore
+
+  end
+end

data/lib/absurdity/engine.rb

@@ -0,0 +1,9 @@
+module Absurdity
+  class Engine < Rails::Engine
+
+    initializer "static assets" do |app|
+      app.middleware.insert_before ::Rack::Lock, ::ActionDispatch::Static, "#{root}/public"
+    end
+
+  end
+end

data/lib/absurdity/experiment.rb

@@ -0,0 +1,135 @@
+module Absurdity
+  class Experiment
+    class NotFoundError < RuntimeError; end
+    class FoundError < RuntimeError; end
+
+    def self.create(slug, metrics_list, variants_list=nil)
+      raise FoundError if Datastore.find(self, slug: slug)
+      experiment = new(slug, metrics_list: metrics_list, variants_list: variants_list)
+      experiment.save
+      experiment
+    end
+
+    def self.find(slug)
+      raise NotFoundError unless experiment = Datastore.find(self, slug: slug)
+      experiment
+    end
+
+    def self.reports
+      all.map { |exp| exp.report }
+    end
+
+    def self.all
+      Datastore.all_experiments
+    end
+
+    attr_reader :slug, :attributes
+    def initialize(slug, attributes = {})
+      @slug       = slug
+      @attributes = attributes
+    end
+
+    def report
+      report = { name: slug, completed: completed, data: {} }
+      if variants?
+        variants_list.each do |variant|
+          report[:data][variant] = {}
+          metrics_list.each do |metric_slug|
+            report[:data][variant][metric_slug] = metric(metric_slug, variant).count
+          end
+        end
+      else
+        metrics_list.each do |metric_slug|
+          report[:data][metric_slug] = metric(metric_slug).count
+        end
+      end
+      report
+    end
+
+    def save
+      Datastore.save_experiment(self)
+    end
+
+    def track!(metric_slug, identity_id=nil)
+      raise Absurdity::MissingIdentityIDError if variants? && identity_id.nil?
+      variant = variants? ? variant_for(identity_id) : nil
+      metric(metric_slug, variant).track! unless completed
+    end
+
+    def complete(variant_slug)
+      @attributes[:completed] = variant_slug
+      save
+    end
+
+    def completed
+      @attributes[:completed]
+    end
+
+    def count(metric_slug)
+      if variants?
+        count = {}
+        variants_list.each do |variant|
+          count[variant] = metric(metric_slug, variant).count
+        end
+      else
+        count = metric(metric_slug).count
+      end
+      count
+    end
+
+    def metric(metric_slug, variant=nil)
+      Metric.find(metric_slug, slug, variant)
+    end
+
+    def ==(other_experiment)
+      slug            == other_experiment.slug         &&
+      metrics_list    == other_experiment.metrics_list &&
+      variants_list   == other_experiment.variants_list
+    end
+
+    def metrics
+      return @metrics unless @metrics.nil?
+      @metrics = []
+      metrics_list.each do |metric_slug|
+        if variants?
+          variants_list.each { |variant| @metrics << metric(metric_slug, variant) }
+        else
+          @metrics << metric(metric_slug)
+        end
+      end
+      @metrics
+    end
+
+    def variant_for(identity_id)
+      if completed
+        variant = Variant.new(completed, slug, identity_id)
+      else
+        variant = Variant.find(identity_id, slug)
+        if variant.nil?
+          variant = Variant.new(random_variant, slug, identity_id)
+          variant.save
+        end
+      end
+      variant.slug
+    end
+
+    def metrics_list
+      attributes[:metrics_list]
+    end
+
+    def variants_list
+      attributes[:variants_list]
+    end
+
+    def variants?
+      variants_list
+    end
+
+    private
+
+    def random_variant
+      variants_list.sort_by { rand }[0]
+    end
+
+  end
+end

data/lib/absurdity/metric.rb

@@ -0,0 +1,46 @@
+module Absurdity
+  class Metric
+    class NotFoundError < RuntimeError; end
+
+    def self.create(slug, experiment_slug, variant_slug=nil)
+      metric = new(slug, experiment_slug, variant_slug)
+      metric.save
+      metric
+    end
+
+    def self.find(slug, experiment_slug, variant_slug=nil)
+      raise NotFoundError unless metric = Datastore.find(self,
+                                                         slug:            slug,
+                                                         experiment_slug: experiment_slug,
+                                                         variant_slug:    variant_slug)
+      metric
+    end
+
+    attr_reader :slug, :experiment_slug, :variant_slug
+    def initialize(slug, experiment_slug, variant_slug=nil)
+      @slug            = slug
+      @experiment_slug = experiment_slug
+      @variant_slug    = variant_slug
+    end
+
+    def save
+      Datastore.save(self)
+    end
+
+    def track!
+      @count += 1
+      save
+    end
+
+    def count
+      @count ||= 0
+    end
+
+    def ==(other_metric)
+      slug            == other_metric.slug            &&
+      experiment_slug == other_metric.experiment_slug &&
+      variant_slug    == other_metric.variant_slug
+    end
+
+  end
+end

data/lib/absurdity/railtie.rb

@@ -0,0 +1,32 @@
+module Absurdity
+  class Railtie < ::Rails::Railtie
+    config.after_initialize do
+      Config.instance.logger = ::Rails.logger
+      load_experiments
+    end
+
+    def self.load_experiments
+      experiments_to_create = YAML.load_file("absurdity/experiments.yml")[:experiments]
+      experiments_to_create.each do |experiment_slug, values|
+        metrics_list = values[:metrics]
+        variants_list = values[:variants]
+        experiment = new_experiment(experiment_slug, metrics_list, variants_list)
+        complete(experiment_slug, values[:completed]) if values[:completed] && !experiment.completed
+      end
+    end
+
+    def self.new_experiment(experiment_slug, metrics_list, variants_list=nil)
+      begin
+        experiment = Experiment.find(experiment_slug)
+      rescue Experiment::NotFoundError
+        Experiment.create(experiment_slug, metrics_list, variants_list)
+      end
+    end
+
+    def self.complete(experiment_slug, variant_slug)
+      experiment = Experiment.find(experiment_slug)
+      experiment.complete(variant_slug)
+    end
+
+  end
+end

data/lib/absurdity/variant.rb

@@ -0,0 +1,20 @@
+module Absurdity
+  class Variant
+
+    def self.find(identity_id, experiment_slug)
+      Datastore.find(self, experiment_slug: experiment_slug, identity_id: identity_id)
+    end
+
+    attr_reader :slug, :experiment_slug, :identity_id
+    def initialize(slug, experiment_slug, identity_id)
+      @slug            = slug
+      @experiment_slug = experiment_slug
+      @identity_id     = identity_id
+    end
+
+    def save
+      Datastore.save(self)
+    end
+
+  end
+end

data/lib/absurdity/version.rb

@@ -0,0 +1,3 @@
+module Absurdity
+  VERSION = "0.2.5"
+end

data/public/stylesheets/absurdity.css

@@ -0,0 +1,96 @@
+body {
+  background-color: #fff;
+  font: 12px Helvetica, Arial, sans-serif;
+  margin: 0 auto;
+  padding: 12px 0;
+  width: 1000px;
+}
+
+h1, h2, h3 {
+  color: #bbb;
+  display: inline;
+  font-size: 2em;
+  font-weight: normal;
+  margin: 0;
+  padding: 0;
+  text-transform: uppercase;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+h1 {
+  color: #333;
+  font-weight: bold;
+  padding-right: 12px;
+}
+
+h2 {
+  font-size: 2em;
+  font-weight: normal;
+}
+
+h3 {
+  font-size: 1.8em;
+  display: block;
+}
+
+ul {
+  list-style: none;
+  padding: 0;
+}
+
+.reports li {
+  color: #aaa;
+  background-color: #333;
+  border-radius: 10px;
+  -moz-box-shadow: 0 5px 5px #999;
+  -webkit-box-shadow: 0 5px 5px #999;
+  box-shadow: 0 5px 5px #999;
+  display: inline-block;
+  font-weight: bold;
+  padding: 10px 10px;
+  margin: 10px 10px 10px 0;
+  position: relative;
+  height: 80px;
+  width: 170px;
+}
+
+.reports li span {
+  font-weight: normal;
+  position: absolute;
+  bottom: 10px;
+  left: 10px;
+  width: 160px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.reports li a, .reports li a:visited {
+  color: #f8f8f8;
+  display: inline-block;
+  text-decoration: none;
+  position: absolute;
+  top: 10px;
+  height: 80px;
+  width: 170px;
+}
+
+li.variant {
+  border-left: 3px solid #eee;
+  color: #333;
+  display: inline-block;
+  margin-top: 12px;
+  padding-left: 12px;
+  width: 25%;
+}
+
+li.variant:first-child {
+  border-left: none;
+  padding: 0 12px 0 0;
+}
+
+.metric {
+  font-weight: bold;
+}
+

data/test/absurdity_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class AbsurdityTest < MiniTest::Unit::TestCase
+
+  def test_redis_setter_and_getter
+    a_redis = MockRedis.new
+    Absurdity.redis = a_redis
+    assert_equal a_redis, Absurdity.redis
+  end
+
+  def test_track_missing_experiment
+    Absurdity.redis = MockRedis.new
+
+    assert_raises Absurdity::Experiment::NotFoundError do
+      Absurdity.track! :clicked, :shared_contacts_link
+    end
+  end
+
+  def test_track_missing_metric
+    Absurdity.redis = MockRedis.new
+    Absurdity::Experiment.create(:shared_contacts_link,
+                                 [:clicked])
+
+    assert_raises Absurdity::Metric::NotFoundError do
+      Absurdity.track! :seen, :shared_contacts_link
+    end
+  end
+
+  def test_track_missing_identity_id
+    Absurdity.redis = MockRedis.new
+    Absurdity::Experiment.create(:shared_contacts_link,
+                                 [:clicked],
+                                 [:with_photos, :without_photos])
+
+    assert_raises Absurdity::MissingIdentityIDError do
+      Absurdity.track! :seen, :shared_contacts_link
+    end
+  end
+
+  def test_track_experiment_metric_without_variants
+    Absurdity.redis = MockRedis.new
+    Absurdity::Experiment.create(:shared_contacts_link,
+                                 [:clicked])
+
+    Absurdity.track! :clicked, :shared_contacts_link
+    assert_equal 1, Absurdity::Experiment.find(:shared_contacts_link).count(:clicked)
+  end
+
+  def test_track_experiment_metric_with_variants
+    Absurdity.redis = MockRedis.new
+    Absurdity::Experiment.any_instance.expects(:random_variant).returns(:with_photos)
+
+    Absurdity::Experiment.create(:shared_contacts_link,
+                                [:clicked],
+                                [:with_photos, :without_photos])
+
+    Absurdity.track! :clicked, :shared_contacts_link, 1
+    count = Absurdity::Experiment.find(:shared_contacts_link).count(:clicked)
+
+    assert_equal 1, count[:with_photos]
+    assert_equal 0, count[:without_photos]
+  end
+
+  def test_track_experiment_with_multiple_metrics_with_variants
+    Absurdity.redis = MockRedis.new
+    Absurdity::Experiment.any_instance.expects(:random_variant).returns(:with_photos)
+
+    Absurdity::Experiment.create(:shared_contacts_link,
+                                 [:clicked, :seen],
+                                 [:with_photos, :without_photos])
+
+    Absurdity.track! :clicked, :shared_contacts_link, 1
+    Absurdity.track! :seen, :shared_contacts_link, 1
+    count = Absurdity::Experiment.find(:shared_contacts_link).count(:clicked)
+
+    assert_equal 1, count[:with_photos]
+    assert_equal 0, count[:without_photos]
+
+    count = Absurdity::Experiment.find(:shared_contacts_link).count(:seen)
+    assert_equal 1, count[:with_photos]
+    assert_equal 0, count[:without_photos]
+  end
+
+  def test_variant
+    Absurdity.redis = MockRedis.new
+    Absurdity::Experiment.any_instance.expects(:random_variant).returns(:with_photos)
+
+    Absurdity::Experiment.create(:shared_contacts_link,
+                                 [:clicked, :seen],
+                                 [:with_photos, :without_photos])
+
+    assert_equal :with_photos, Absurdity.variant(:shared_contacts_link, 1)
+  end
+
+end
+

data/test/config_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class AbsurdityTest < MiniTest::Unit::TestCase
+
+  def test_redis_setter_and_getter
+    a_redis = MockRedis.new
+    Absurdity::Config.instance.redis = a_redis
+
+    assert_equal a_redis, Absurdity::Config.instance.redis
+  end
+
+end
+

data/test/experiment_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class ExperimentTest < MiniTest::Unit::TestCase
+
+  def setup
+    @experiment_slug = :shared_contacts_link
+    @metrics_list    = [:clicked, :seen]
+    @variants_list   = [:with_photos, :without_photos]
+    Absurdity.redis  = MockRedis.new
+  end
+
+  def test_find_and_test_create
+    experiment = Absurdity::Experiment.create(@experiment_slug,
+                                              @metrics_list,
+                                              @variants_list)
+
+    assert_equal experiment, Absurdity::Experiment.find(@experiment_slug)
+  end
+
+  def test_initialize
+    # crappy test
+    experiment = Absurdity::Experiment.new(@experiment_slug,
+                                           metrics_list:  @metrics_list,
+                                           variants_list: @variants_list)
+  end
+
+  def test_save
+
+  end
+
+  def test_metric
+
+  end
+
+end
+

data/test/metric_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+class MetricTest < MiniTest::Unit::TestCase
+
+  def setup
+    Absurdity.redis = MockRedis.new
+  end
+
+  def test_find_and_create
+    experiment_slug  = :shared_contacts_link
+    metric_slug      = :clicked
+    experiment = stub(slug: experiment_slug, metrics_list: [metric_slug])
+    Absurdity::Datastore.stubs(:find_experiment).returns(experiment)
+
+    metric = Absurdity::Metric.create(metric_slug, experiment_slug)
+
+    assert_equal metric, Absurdity::Metric.find(metric_slug, experiment_slug)
+  end
+
+  def test_find_not_found
+    assert_raises Absurdity::Metric::NotFoundError do
+      Absurdity::Metric.find(:blah, :boo)
+    end
+  end
+
+  def test_save_first_time
+    experiment_slug  = :shared_contacts_link
+    metric_slug      = :clicked
+    experiment = stub(slug: experiment_slug, metrics_list: [metric_slug])
+    Absurdity::Datastore.stubs(:find_experiment).returns(experiment)
+
+    metric = Absurdity::Metric.new(metric_slug, experiment_slug)
+
+    metric.save
+    assert_equal metric, Absurdity::Metric.find(metric_slug, experiment_slug)
+  end
+
+  def test_save_after_first_time
+    experiment_slug  = :shared_contacts_link
+    metric_slug      = :clicked
+    metric = Absurdity::Metric.create(metric_slug, experiment_slug)
+
+    assert_equal 0, metric.count
+    metric.track!
+    assert_equal 1, metric.count
+    metric.save
+    assert_equal 1, metric.count
+  end
+
+  def test_count
+    experiment_slug  = :shared_contacts_link
+    metric_slug      = :clicked
+    metric = Absurdity::Metric.create(metric_slug, experiment_slug)
+
+    assert_equal 0, metric.count
+    metric.track!
+    assert_equal 1, metric.count
+  end
+
+  def test_track_metric
+    experiment_slug = :shared_contacts_link
+    metric_slug     = :clicked
+
+    metric = Absurdity::Metric.new(metric_slug, experiment_slug)
+
+    assert_equal 0, metric.count
+    metric.track!
+    assert_equal 1, metric.count
+  end
+
+  def test_track_variant_metric
+    experiment_slug = :shared_contacts_link
+    metric_slug     = :clicked
+    variant_slug    = :with_photos
+    metric = Absurdity::Metric.new(metric_slug, experiment_slug, variant_slug)
+
+    assert_equal 0, metric.count
+    metric.track!
+    assert_equal 1, metric.count
+  end
+
+end
+

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'mock_redis'
+require 'absurdity'
+require 'redis'
+require 'mocha'
+
+class MiniTest::Unit::TestCase
+
+  def teardown
+  	config = Absurdity::Config.instance
+    config.redis && config.redis.flushdb
+    config.instance_variable_set(:@redis, nil)
+  end
+
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: absurdity
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.5
+platform: ruby
+authors: 
+- Tim Payton
+- "\xC3\x96m\xC3\xBCr \xC3\x96zkir"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.7
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mock_redis
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: See summary
+email: opensource@xing.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- absurdity.gemspec
+- app/controllers/absurdities_controller.rb
+- app/helpers/absurdity_helper.rb
+- app/views/absurdities/index.html.erb
+- app/views/absurdities/show.html.erb
+- app/views/layouts/absurdities.html.erb
+- config/routes.rb
+- lib/absurdity.rb
+- lib/absurdity/config.rb
+- lib/absurdity/datastore.rb
+- lib/absurdity/datastore/redis.rb
+- lib/absurdity/engine.rb
+- lib/absurdity/experiment.rb
+- lib/absurdity/metric.rb
+- lib/absurdity/railtie.rb
+- lib/absurdity/variant.rb
+- lib/absurdity/version.rb
+- public/stylesheets/absurdity.css
+- test/absurdity_test.rb
+- test/config_test.rb
+- test/experiment_test.rb
+- test/metric_test.rb
+- test/test_helper.rb
+homepage: http://xing.github.com/absurdity/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: absurdity
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Absurdly simple a/b testing
+test_files: 
+- test/absurdity_test.rb
+- test/config_test.rb
+- test/experiment_test.rb
+- test/metric_test.rb
+- test/test_helper.rb