eeny-meeny 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e28ef5a3f25b3acf3e554f578623aab014bc8033
+  data.tar.gz: 017bf53a5cca472993e25c1d09cc514e3a0983b9
+SHA512:
+  metadata.gz: e188c4dd1ceeee62fdd3efc5ab445808d49b34cb75579dbe591c381c6fab73c2206261473ad27d7dd8df3e72ca4d5d86508ef5d97ad8aba2c2661e2dee926b58
+  data.tar.gz: e7f33467b3c326a158405a528e4ca787afc05061fca5e0fa4581a083f00f7523bc9ebbb6bb1e0d36e1274e41d09e712fef0685bc527c4630de6b89bb1d970437

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+### 1.0.0 (2016-07-03)
+
+Features:
+
+    - Initial version of split testing tool. Includes:
+        - Experiment helpers for Rails
+        - Run any number of experiments at the same time.
+        - Have any number of variations in each experiment.
+        - Set the weight (likelyhood of participants excountering) each experiment variation customly.
+        - Encrypt experiment cookies.
+        - Route constraint for full page split tests.

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'codeclimate-test-reporter', require: nil
+end
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Christian Orthmann
+
+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/README.md

@@ -0,0 +1,86 @@
+eeny-meeny
+==========================
+[![Code Climate](https://codeclimate.com/github/corthmann/eeny-meeny/badges/gpa.svg)](https://codeclimate.com/github/corthmann/eeny-meeny)
+[![Test Coverage](https://codeclimate.com/github/corthmann/eeny-meeny/badges/coverage.svg)](https://codeclimate.com/github/corthmann/eeny-meeny/coverage)
+
+Installation
+-------------
+You can install this gem by using the following command:
+```
+gem install eeny-meeny
+```
+or by adding the the following line to your Gemfile.
+```
+gem 'eeny-meeny'
+```
+
+Configuration
+-------------
+`eeny-meeny` should be configured in your Rails environment file. Preferably loaded through `secrets.yml`
+
+The following configurations are available:
+
+* `config.eeny_meeny.cookies.path` Defaults to `'/'`. Sets the `path` cookie attribute. If this configuartion is set to `nil` it means that each page will get its own cookie.
+* `config.eeny_meeny.cookies.same_site` Defaults to `:strict`. Accepts: `:strict`, `:lax` and `nil`. Sets the `SameSite` cookie attribute. Selecting `nil` will disable the header on the cookie.
+* `config.eeny_meeny.secure` Boolean value. Defaults to `true` and determines if experiment cookies should be encrypted or not.
+* `config.eeny_meeny.secret` sets the secret used for encrypting experiment cookies.
+* `config.eeny_meeny.experiments` list of experiment-data. It is easiest to load this from a `.yml` file with the following structure:
+
+```
+:experiment_1:
+  :name: Awesome Experiment
+  :version: 1
+  :variations:
+    :a:
+      :name: Variation A
+      :weight: 0.8
+      :options:
+        :message: A rocks, B sucks
+    :b:
+      :name: Variation B
+      :weight: 0.2
+      :options:
+        :message: B is an all-star!
+```
+
+Usage
+-------------
+`eeny-meeny` adds the following helpers to your controllers and views:
+
+* `participates_in?(experiement_id, variation_id: nil)` Returns the chosen variation for the current user if he participates in the experiment.
+
+Full page split tests
+-------------
+If you want to completely redesign a page but test it in production as a split test against your old page, using identical routes, then it can be achieved as follows:
+
+ 1. Create an experiment like this:
+
+    ```
+    :example_page:
+        :name: Test V1 vs. V2
+        :v1:
+            :name: First version of the page
+            :weight: 0.9
+        :v2:
+            :name: Second version of the page
+            :weight: 0.1
+    ```
+
+ 2. Namespace your controller and views (ex. `ExamplesController` becommes `V1::ExamplesController` )
+ 3. Copy the route(s) for `ExamplesController` and use `controller: 'v1/examples`
+ 4. Add `require 'eeny-meeny/route_constraint` to `routes.rb`
+ 4. Surround your `v1/examples` route(s) with the following constraint:
+
+    ```
+    constraints(EenyMeeny::RouteConstraint.new(:example_page, variation_id: :v1) do
+        # your v1 routes goes here.
+    end
+    ```
+
+Now 90% of the users will experience V1 and 10% will experience V2.
+
+Special thanks
+-------------
+As part of building this gem I borrowed the `Encryptor` class from the `encrypted_cookie` gem (https://github.com/cvonkleist/encrypted_cookie)
+
+All credits for the cookie encryption goes to that project.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => :spec

data/eeny-meeny.gemspec

@@ -0,0 +1,23 @@
+require File.expand_path('../lib/eeny-meeny/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'eeny-meeny'
+  s.version     = EenyMeeny::VERSION.dup
+  s.date        = '2016-07-03'
+  s.summary     = "A simple split testing tool for Rails"
+  s.authors     = ["Christian Orthmann"]
+  s.email       = 'christian.orthmann@gmail.com'
+  s.require_path = 'lib'
+  s.files       = `git ls-files`.split("\n") - %w(.rvmrc .gitignore)
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n") - %w(.rvmrc .gitignore)
+  s.homepage    = 'http://rubygems.org/gems/eeny-meeny'
+  s.license     = 'MIT'
+
+  s.add_development_dependency('rake', '~> 10')
+  s.add_development_dependency('rspec', '~> 3')
+  s.add_development_dependency('simplecov', '~> 0')
+  s.add_development_dependency('simplecov-rcov', '~> 0')
+  s.add_development_dependency('yard', '~> 0')
+  s.add_runtime_dependency('rack', '>= 1.2.1', '< 2')
+  s.add_runtime_dependency('activesupport', '>= 3.0.0', '< 5.0.0')
+end

data/lib/eeny-meeny.rb

@@ -0,0 +1,6 @@
+require 'eeny-meeny/version'
+require 'eeny-meeny/railtie' if defined?(Rails)
+
+module EenyMeeny
+  EENY_MEENY_COOKIE_PREFIX = 'eeny_meeny_'.freeze
+end

data/lib/eeny-meeny/encryptor.rb

@@ -0,0 +1,120 @@
+require 'openssl'
+require 'rack/utils'
+
+module EenyMeeny
+  # Encrypts messages with authentication
+  #
+  # The use of authentication is essential to avoid Chosen Ciphertext
+  # Attacks.  By using this in an encrypt then MAC form, we avoid some
+  # attacks such as e.g. being used as a CBC padding oracle to decrypt
+  # the ciphertext.
+  class Encryptor
+    # Create the encryptor
+    #
+    # Pass in the secret, which should be at least 32-bytes worth of
+    # entropy, e.g. a string generated by `SecureRandom.hex(32)`.
+    # This also allows specification of the algorithm for the cipher
+    # and MAC.  But don't change that unless you're very sure.
+    def initialize(secret, cipher = 'aes-256-cbc', hmac = 'SHA256')
+      @cipher = cipher
+      @hmac   = hmac
+
+      # use the HMAC to derive two independent keys for the encryption and
+      # authentication of ciphertexts It is bad practice to use the same key
+      # for encryption and authentication.  This also allows us to use all
+      # of the entropy in a long key (e.g. 64 hex bytes) when straight
+      # assignement would could result in assigning a key with a much
+      # reduced key space.  Also, the personalisation strings further help
+      # reduce the possibility of key reuse by ensuring it should be unique
+      # to this gem, even with shared secrets.
+      @encryption_key     = hmac("EncryptedCookie Encryption",     secret)
+      @authentication_key = hmac("EncryptedCookie Authentication", secret)
+    end
+
+    # Encrypts message
+    #
+    # Returns the base64 encoded ciphertext plus IV.  In addtion, the
+    # message is prepended with a MAC code to prevent chosen ciphertext
+    # attacks.
+    def encrypt(message)
+      # encrypt the message
+      encrypted = encrypt_message(message)
+
+      [authenticate_message(encrypted) +   encrypted].pack('m0')
+    end
+
+    # decrypts base64 encoded ciphertext
+    #
+    # First, it checks the message tag and returns nil if that fails to verify.
+    # Otherwise, the data is passed on to the AES function for decryption.
+    def decrypt(ciphertext)
+      ciphertext = ciphertext.unpack('m').first
+      tag        = ciphertext[0, hmac_length]
+      ciphertext = ciphertext[hmac_length..-1]
+
+      # make sure we actually had enough data for the tag too.
+      if tag && ciphertext && verify_message(tag, ciphertext)
+        decrypt_ciphertext(ciphertext)
+      else
+        nil
+      end
+    end
+
+    private
+
+    # HMAC digest of the message using the given secret
+    def hmac(secret, message)
+      OpenSSL::HMAC.digest(@hmac, secret, message)
+    end
+
+    def hmac_length
+      OpenSSL::Digest.new(@hmac).size
+    end
+
+    # returns the message authentication tag
+    #
+    # This is computed as HMAC(authentication_key, message)
+    def authenticate_message(message)
+      hmac(@authentication_key, message)
+    end
+
+    # verifies the message
+    #
+    # This does its best to be constant time, by use of the rack secure compare
+    # function.
+    def verify_message(tag, message)
+      own_tag = authenticate_message(message)
+      Rack::Utils.secure_compare(tag, own_tag)
+    end
+
+    # Encrypt
+    #
+    # Encrypts the given message with a random IV, then returns the ciphertext
+    # with the IV prepended.
+    def encrypt_message(message)
+      aes = OpenSSL::Cipher::Cipher.new(@cipher).encrypt
+      aes.key = @encryption_key
+      iv = aes.random_iv
+      aes.iv = iv
+      iv + (aes.update(message) << aes.final)
+    end
+
+    # Decrypt
+    #
+    # Pulls the IV off the front of the message and decrypts.  Catches
+    # OpenSSL errors and returns nil.  But this should never happen, as the
+    # verify method should catch all corrupted ciphertexts.
+    def decrypt_ciphertext(ciphertext)
+      aes = OpenSSL::Cipher::Cipher.new(@cipher).decrypt
+      aes.key = @encryption_key
+      iv = ciphertext[0, aes.iv_len]
+      aes.iv = iv
+      crypted_text = ciphertext[aes.iv_len..-1]
+      return nil if crypted_text.nil? || iv.nil?
+      aes.update(crypted_text) << aes.final
+    rescue
+      nil
+    end
+
+  end
+end

data/lib/eeny-meeny/experiment.rb

@@ -0,0 +1,30 @@
+require 'eeny-meeny/variation'
+require 'active_support/time'
+require 'active_support/core_ext/enumerable'
+
+module EenyMeeny
+  class Experiment
+    attr_reader :id, :name, :version, :variations, :total_weight, :end_at, :start_at
+
+    def initialize(id, name: '', version: 1, variations: {}, start_at: nil, end_at: nil)
+      @id = id
+      @name = name
+      @version = version
+      @variations = variations.map do |variation_id, variation|
+        Variation.new(variation_id, **variation)
+      end
+      @total_weight = (@variations.empty? ? 1.0 : @variations.sum { |variation| variation.weight.to_f })
+
+      @start_at = Time.zone.parse(start_at) if start_at
+      @end_at = Time.zone.parse(end_at) if end_at
+    end
+
+    def pick_variation
+      Hash[
+          @variations.map do |variation|
+            [variation, variation.weight]
+          end
+      ].max_by { |_, weight| rand ** (@total_weight / weight) }.first
+    end
+  end
+end

data/lib/eeny-meeny/experiment_helper.rb

@@ -0,0 +1,21 @@
+require 'eeny-meeny/shared_methods'
+
+module EenyMeeny::ExperimentHelper
+  @@eeny_meeny_encryptor = nil
+
+  def participates_in?(experiment_id, variation_id: nil)
+    cookie = eeny_meeny_cookie(experiment_id)
+    cookie[:variation] unless cookie.nil? || (variation_id.present? && variation_id != cookie[:variation].id)
+  end
+
+  private
+
+  def eeny_meeny_cookie(experiment_id)
+    cookie = cookies[EenyMeeny::EENY_MEENY_COOKIE_PREFIX+experiment_id.to_s+'_v'+experiment_version(experiment_id).to_s]
+    if cookie
+      Marshal.load(decrypt(cookie)) rescue nil
+    end
+  end
+
+  include EenyMeeny::SharedMethods
+end

data/lib/eeny-meeny/middleware.rb

@@ -0,0 +1,64 @@
+require 'rack'
+require 'time'
+require 'active_support/time'
+require 'eeny-meeny/middleware_helper'
+require 'eeny-meeny/experiment'
+require 'eeny-meeny/encryptor'
+
+module EenyMeeny
+  class Middleware
+    include EenyMeeny::MiddlewareHelper
+
+    def initialize(app, experiments, secure, secret, cookie_path, cookie_same_site)
+      @app = app
+      @experiments = experiments.map do |id, experiment|
+        EenyMeeny::Experiment.new(id, **experiment)
+      end
+      @secure = secure
+      @cookie_config = { path: cookie_path, same_site: cookie_same_site }
+      @encryptor = EenyMeeny::Encryptor.new(secret) if secure
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      cookies = request.cookies
+      now = Time.zone.now
+      new_cookies = {}
+      existing_set_cookie_header = env['Set-Cookie']
+      # Prepare for experiments.
+      @experiments.each do |experiment|
+        # Skip experiments that haven't started yet or if it ended
+        next if experiment.start_at && (now < experiment.start_at)
+        next if experiment.end_at && (now > experiment.end_at)
+        # skip experiments that already have a cookie
+        unless has_experiment_cookie?(cookies, experiment)
+          env['Set-Cookie'] = ''
+          cookie_value = generate_cookie_value(experiment, @cookie_config)
+          cookie_value[:value] = @encryptor.encrypt(cookie_value[:value]) if @secure
+          # Set HTTP_COOKIE header to enable experiment on first pageview
+          Rack::Utils.set_cookie_header!(env,
+                                         experiment_cookie_name(experiment),
+                                         cookie_value)
+          env['HTTP_COOKIE'] = '' if env['HTTP_COOKIE'].nil?
+          env['HTTP_COOKIE'] += '; ' unless env['HTTP_COOKIE'].empty?
+          env['HTTP_COOKIE'] += env['Set-Cookie']
+          new_cookies[experiment_cookie_name(experiment)] = cookie_value
+        end
+      end
+      # Clean up 'Set-Cookie' header.
+      if existing_set_cookie_header.nil?
+        env.delete('Set-Cookie')
+      else
+        env['Set-Cookie'] = existing_set_cookie_header
+      end
+      # Delegate to app
+      status, headers, body = @app.call(env)
+      response = Rack::Response.new(body, status, headers)
+      # Add new cookies to 'Set-Cookie' header
+      new_cookies.each do |key, value|
+        response.set_cookie(key,value)
+      end
+      response.finish
+    end
+  end
+end

data/lib/eeny-meeny/middleware_helper.rb

@@ -0,0 +1,25 @@
+module EenyMeeny::MiddlewareHelper
+  def has_experiment_cookie?(cookies, experiment)
+    cookies.has_key?(experiment_cookie_name(experiment))
+  end
+
+  def generate_cookie_value(experiment, cookie_config)
+    variation = experiment.pick_variation
+    cookie = {
+        expires: (experiment.end_at || 1.year.from_now),
+        httponly: true,
+        value: Marshal.dump({
+                                name: experiment.name,
+                                variation: variation,
+                            })
+    }
+    cookie[:same_site] = cookie_config[:same_site] unless cookie_config[:same_site].nil?
+    cookie[:path] = cookie_config[:path] unless cookie_config[:path].nil?
+    cookie
+  end
+
+  private
+  def experiment_cookie_name(experiment)
+    EenyMeeny::EENY_MEENY_COOKIE_PREFIX+experiment.id.to_s+'_v'+experiment.version.to_s
+  end
+end

data/lib/eeny-meeny/railtie.rb

@@ -0,0 +1,27 @@
+require 'eeny-meeny/experiment_helper'
+require 'eeny-meeny/middleware'
+
+module EenyMeeny
+  class Railtie < Rails::Railtie
+    config.eeny_meeny = ActiveSupport::OrderedOptions.new
+    # default config values. these can be changed in the rails environment configuration.
+    config.eeny_meeny.experiments = []
+    config.eeny_meeny.secure = true
+    config.eeny_meeny.secret = '9fc8b966eca7d03d55df40c01c10b8e02bf1f9d12d27b8968d53eb53e8c239902d00bf6afae5e726ce1111159eeb2f8f0e77233405db1d82dd71397f651a0a4f'
+    config.eeny_meeny.cookies = ActiveSupport::OrderedOptions.new
+    config.eeny_meeny.cookies.path = '/'
+    config.eeny_meeny.cookies.same_site = :strict
+
+    initializer 'eeny_meeny.initialize' do |app|
+      ActionController::Base.send :include, EenyMeeny::ExperimentHelper
+      ActionView::Base.send :include, EenyMeeny::ExperimentHelper
+
+      app.middleware.insert_before 'ActionDispatch::Cookies', EenyMeeny::Middleware,
+                                   config.eeny_meeny.experiments,
+                                   config.eeny_meeny.secure,
+                                   config.eeny_meeny.secret,
+                                   config.eeny_meeny.cookies.path,
+                                   config.eeny_meeny.cookies.same_site
+    end
+  end
+end

data/lib/eeny-meeny/route_constraint.rb

@@ -0,0 +1,33 @@
+require 'eeny-meeny/shared_methods'
+
+module EenyMeeny
+  class RouteConstraint
+    @@eeny_meeny_encryptor = nil
+
+    def initialize(experiment_id, variation_id: nil)
+      @experiment_id = experiment_id
+      @variation_id = variation_id
+      @version = experiment_version(experiment_id)
+    end
+
+    def matches?(request)
+      !participates_in?(request).nil?
+    end
+
+    private
+
+    def participates_in?(request)
+      cookie = eeny_meeny_cookie(request)
+      cookie[:variation] unless cookie.nil? || (!cookie.nil? && @variation_id.present? && @variation_id != cookie[:variation].id)
+    end
+
+    def eeny_meeny_cookie(request)
+      cookie = request.cookie_jar[EenyMeeny::EENY_MEENY_COOKIE_PREFIX+@experiment_id.to_s+'_v'+@version.to_s]
+      if cookie
+        Marshal.load(decrypt(cookie)) rescue nil
+      end
+    end
+
+    include EenyMeeny::SharedMethods
+  end
+end

data/lib/eeny-meeny/shared_methods.rb

@@ -0,0 +1,23 @@
+module EenyMeeny::SharedMethods
+
+  private
+
+  def experiment_version(experiment_id)
+    (Rails.application.config.eeny_meeny.experiments.
+        try(:[], experiment_id.to_sym).try(:[], :version) || 1) rescue 1
+  end
+
+  def decrypt(cookie)
+    begin
+      if Rails.application.config.eeny_meeny.secure
+        # Memoize encryptor to avoid creating new instances on every request.
+        @@eeny_meeny_encryptor ||= EenyMeeny::Encryptor.new(Rails.application.config.eeny_meeny.secret)
+        @@eeny_meeny_encryptor.decrypt(cookie)
+      else
+        cookie
+      end
+    rescue
+      nil
+    end
+  end
+end

data/lib/eeny-meeny/variation.rb

@@ -0,0 +1,20 @@
+module EenyMeeny
+  class Variation
+    attr_reader :id, :name, :weight, :options
+
+    def initialize(id, name: '', weight: 1, **options)
+      @id = id
+      @name = name
+      @weight = weight
+      @options = options
+    end
+
+    def marshal_dump
+      [@id, { name: @name, weight: @weight, **@options }]
+    end
+
+    def marshal_load(array)
+      send :initialize, array[0], **array[1]
+    end
+  end
+end

data/lib/eeny-meeny/version.rb

@@ -0,0 +1,3 @@
+module EenyMeeny
+  VERSION = '1.0.0'
+end

data/spec/eeny-meeny/experiment_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'eeny-meeny/experiment'
+require 'eeny-meeny/variation'
+
+describe EenyMeeny::Experiment do
+  describe 'when initialized' do
+
+    context 'with weighted variations' do
+      subject do
+        described_class.new(:experiment_1,
+                            name: 'Test 1',
+                            variations: {
+                                a: { name: 'A', weight: 0.5 },
+                                b: { name: 'B', weight: 0.3 }})
+      end
+
+      it 'sets the instance variables' do
+        expect(subject.id).to eq(:experiment_1)
+        expect(subject.name).to eq('Test 1')
+        expect(subject.variations).to be_a Array
+        expect(subject.variations.size).to eq(2)
+      end
+
+      it "has a 'total_weight' equal to the sum of the variation weights" do
+        expect(subject.total_weight).to eq(0.8)
+      end
+
+      describe '#pick_variation' do
+        it 'picks a variation' do
+          expect(subject.pick_variation).to be_a EenyMeeny::Variation
+        end
+      end
+    end
+
+    context 'with non-weighted variations' do
+      subject do
+        described_class.new(:experiment_1,
+                            name: 'Test 1',
+                            variations: {
+                                a: { name: 'A' },
+                                b: { name: 'B' }})
+      end
+
+      it 'sets the instance variables' do
+        expect(subject.id).to eq(:experiment_1)
+        expect(subject.name).to eq('Test 1')
+        expect(subject.variations).to be_a Array
+        expect(subject.variations.size).to eq(2)
+      end
+
+      it "has a 'total_weight' equal to the number of the variation weights" do
+        expect(subject.total_weight).to eq(2)
+      end
+
+      describe '#pick_variation' do
+        it 'picks a variation' do
+          expect(subject.pick_variation).to be_a EenyMeeny::Variation
+        end
+      end
+    end
+  end
+end

data/spec/eeny-meeny/middleware_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'eeny-meeny/encryptor'
+require 'eeny-meeny/middleware'
+
+def initialize_app(secure: true, secret: 'test', path: '/', same_site: :strict)
+  experiments = YAML.load_file(File.join('spec','fixtures','experiments.yml'))
+  described_class.new(app, experiments, secure, secret, path, same_site)
+end
+
+describe EenyMeeny::Middleware do
+
+  let(:app) { MockRackApp.new }
+  before(:example) do
+    allow(Time).to receive_message_chain(:zone, :now) { Time.now }
+  end
+
+  describe 'when initialized' do
+
+    context "with 'config.eeny_meeny.secure = true'" do
+      it 'creates an instance of EenyMeeny::Encryptor' do
+        instance = initialize_app
+        expect(instance.instance_variable_get(:@secure)).to be true
+        expect(instance.instance_variable_get(:@encryptor)).to be_a EenyMeeny::Encryptor
+      end
+    end
+
+    context "with 'config.eeny_meeny.secure = false'" do
+      it 'does not have an instance of EenyMeeny::Encryptor' do
+        instance = initialize_app(secure: false)
+        expect(instance.instance_variable_get(:@secure)).to be false
+        expect(instance.instance_variable_get(:@encryptor)).to be nil
+      end
+    end
+  end
+
+  describe 'when called with a GET request' do
+    subject { initialize_app }
+
+    context "and the request doesn't contain the experiment cookie" do
+      let(:request) { Rack::MockRequest.new(subject) }
+
+      before(:example) do
+        @response = request.get('/test', 'CONTENT_TYPE' => 'text/plain')
+      end
+
+      it "sets the 'HTTP_COOKIE' header on the request" do
+        expect(app['HTTP_COOKIE']).to be
+        expect(app['HTTP_COOKIE'].length).to be > 0
+      end
+
+      it "sets the 'Set-Cookie' header on the response" do
+        expect(@response['Set-Cookie']).to be
+        expect(@response['Set-Cookie'].length).to be > 0
+      end
+    end
+
+    context 'and the request already contains the experiment cookie' do
+      let(:request) { Rack::MockRequest.new(subject) }
+
+      before(:example) do
+        @original_request_cookies = 'test=abc;eeny_meeny_my_page_v1=on1tOQ5hiKdA0biVZVwvTUQcmkODacwdpi%2FedQJIYQz9KdWYAXqzCafF5Dqqa6xtHFBdXYVmz%2Bp4%2FigmKz4hBVYZbJU%2FMwBbvYG%2BIoBelk10PxwtyxbA%2BiDzFT4jZeiTkNOmZ3rp1Gzz74JjT4aocqB187p7SrpeM2jfyZ8ZKPOiZs6tXf0QoXkV%2BZbtxJLRPr5lgmGxslfM8vCIm1%2F0HQ%3D%3D;'
+        @response = request.get('/test',
+                                'CONTENT_TYPE' => 'text/plain',
+                                'HTTP_COOKIE' => @original_request_cookies)
+      end
+
+      it "does not change the 'HTTP_COOKIE' header on the request" do
+        expect(app['HTTP_COOKIE']).to eq(@original_request_cookies)
+      end
+
+      it "does not set the 'Set-Cookie' header on the response" do
+        expect(@response['Set-Cookie']).to be nil
+      end
+    end
+  end
+
+end

data/spec/eeny-meeny/variation_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'eeny-meeny/variation'
+
+describe EenyMeeny::Variation do
+  describe 'when initialized' do
+
+    subject do
+      described_class.new(:a,
+                          name: 'A',
+                          weight: 0.5,
+                          custom_option_1: 'asd1',
+                          custom_option_2: 'asd2')
+    end
+
+    it "sets the 'id'" do
+      expect(subject.id).to eq(:a)
+    end
+
+    it "sets the 'name'" do
+      expect(subject.name).to eq('A')
+    end
+
+    it "sets the 'weight'" do
+      expect(subject.weight).to eq(0.5)
+    end
+
+    it "sets the custom 'options'" do
+      expect(subject.options).to be_a Hash
+      expect(subject.options[:custom_option_1]).to eq('asd1')
+      expect(subject.options[:custom_option_2]).to eq('asd2')
+    end
+
+    describe '#marshal_dump' do
+      it 'can load a marshal dump correctly' do
+        dump = Marshal.dump(subject)
+        expect(dump).to be_a String
+        loaded_object = Marshal.load(dump)
+        expect(loaded_object).to_not be_a String
+        expect(loaded_object).to be_a EenyMeeny::Variation
+        expect(loaded_object.id).to eql(:a)
+        expect(loaded_object.name).to eq('A')
+        expect(loaded_object.weight).to eq(0.5)
+        expect(loaded_object.options[:custom_option_1]).to eq('asd1')
+      end
+    end
+  end
+
+
+end

data/spec/fixtures/experiments.yml

@@ -0,0 +1,10 @@
+:my_page:
+  :name: My Page
+  :version: 1
+  :variations:
+    :old:
+      :name: Old My Page
+      :weight: 0.02
+    :new:
+      :name: New My Page
+      :weight: 0.98

data/spec/mock_rack_app.rb

@@ -0,0 +1,19 @@
+class MockRackApp
+
+  attr_reader :request_body
+
+  def initialize
+    @request_headers = {}
+  end
+
+  def call(env)
+    @env = env
+    @request_body = env['rack.input'].read
+    [200, {'Content-Type' => 'text/plain'}, ['OK']]
+  end
+
+  def [](key)
+    @env[key]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'simplecov'
+require 'simplecov-rcov'
+require 'codeclimate-test-reporter'
+
+SimpleCov.start do
+  formatter SimpleCov::Formatter::MultiFormatter[
+                SimpleCov::Formatter::HTMLFormatter,
+                SimpleCov::Formatter::RcovFormatter,
+                CodeClimate::TestReporter::Formatter
+            ]
+  add_group('EenyMeeny', 'lib/eeny-meeny')
+  add_group('Specs', 'spec')
+end
+
+require 'rspec'
+require 'yaml'
+require 'eeny-meeny'
+require 'mock_rack_app'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = "random"
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: eeny-meeny
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Christian Orthmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: 
+email: christian.orthmann@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- eeny-meeny.gemspec
+- lib/eeny-meeny.rb
+- lib/eeny-meeny/encryptor.rb
+- lib/eeny-meeny/experiment.rb
+- lib/eeny-meeny/experiment_helper.rb
+- lib/eeny-meeny/middleware.rb
+- lib/eeny-meeny/middleware_helper.rb
+- lib/eeny-meeny/railtie.rb
+- lib/eeny-meeny/route_constraint.rb
+- lib/eeny-meeny/shared_methods.rb
+- lib/eeny-meeny/variation.rb
+- lib/eeny-meeny/version.rb
+- spec/eeny-meeny/experiment_spec.rb
+- spec/eeny-meeny/middleware_spec.rb
+- spec/eeny-meeny/variation_spec.rb
+- spec/fixtures/experiments.yml
+- spec/mock_rack_app.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/eeny-meeny
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A simple split testing tool for Rails
+test_files: []
+has_rdoc: