test_track_rails_client 0.9.0

data/app/models/test_track/vary_dsl.rb

@@ -0,0 +1,88 @@
+class TestTrack::VaryDSL
+  include TestTrack::RequiredOptions
+
+  attr_reader :defaulted, :default_variant
+  alias defaulted? defaulted
+
+  def initialize(opts = {})
+    @assignment = require_option!(opts, :assignment)
+    @context = require_option!(opts, :context)
+    @split_registry = require_option!(opts, :split_registry, allow_nil: true)
+    raise ArgumentError, "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+    raise ArgumentError, "unknown split: #{split_name}" if @split_registry && !split
+  end
+
+  def when(*variants, &block)
+    raise ArgumentError, "must provide at least one variant" unless variants.present?
+    variants.each do |variant|
+      assign_behavior_to_variant(variant, block)
+    end
+  end
+
+  def default(variant, &block)
+    raise ArgumentError, "cannot provide more than one `default`" unless default_variant.nil?
+    @default_variant = assign_behavior_to_variant(variant, block)
+  end
+
+  private
+
+  attr_reader :split_registry, :assignment, :context
+  delegate :split_name, to: :assignment
+
+  def split
+    split_registry && split_registry[split_name]
+  end
+
+  def split_variants
+    @split_variants ||= split.keys if split_registry
+  end
+
+  def airbrake_because_vary(msg)
+    Rails.logger.error(msg)
+    Airbrake.notify_or_ignore("vary for \"#{split_name}\" #{msg}")
+  end
+
+  def variant_behaviors
+    @variant_behaviors ||= {}
+  end
+
+  def assign_behavior_to_variant(variant, behavior_proc)
+    variant = variant.to_s
+
+    raise ArgumentError, "must provide block for #{variant}" unless behavior_proc
+    airbrake_because_vary "configures unknown variant \"#{variant}\"" unless variant_acceptable?(variant)
+
+    variant_behaviors[variant] = behavior_proc
+    variant
+  end
+
+  def variant_acceptable?(variant)
+    split_variants ? split_variants.include?(variant) : true # If we're flying blind (with no split registry), assume the dev is correct
+  end
+
+  def default_proc
+    variant_behaviors[default_variant]
+  end
+
+  def run # rubocop:disable Metrics/AbcSize
+    validate!
+
+    if variant_behaviors[assignment.variant]
+      chosen_proc = variant_behaviors[assignment.variant]
+    else
+      chosen_proc = default_proc
+      assignment.variant = default_variant
+      @defaulted = true
+    end
+    assignment.context = context
+    chosen_proc.call
+  end
+
+  def validate!
+    raise ArgumentError, "must provide exactly one `default`" unless default_variant
+    raise ArgumentError, "must provide at least one `when`" unless variant_behaviors.size >= 2
+    return true unless split_variants
+    missing_variants = split_variants - variant_behaviors.keys
+    airbrake_because_vary("does not configure variants #{missing_variants.to_sentence}") && false unless missing_variants.empty?
+  end
+end

data/app/models/test_track/visitor.rb

@@ -0,0 +1,129 @@
+class TestTrack::Visitor
+  include TestTrack::RequiredOptions
+
+  attr_reader :id
+
+  def initialize(opts = {})
+    opts = opts.dup
+    @id = opts.delete(:id)
+    @assignments = opts.delete(:assignments)
+    unless id
+      @id = SecureRandom.uuid
+      @assignments ||= [] # If we're generating a visitor, we don't need to fetch the assignments
+    end
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+  end
+
+  def vary(split_name, opts = {})
+    opts = opts.dup
+    split_name = split_name.to_s
+    context = require_option!(opts, :context)
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+
+    raise ArgumentError, "must provide block to `vary` for #{split_name}" unless block_given?
+    v = TestTrack::VaryDSL.new(assignment: assignment_for(split_name), context: context, split_registry: split_registry)
+    yield v
+    v.send :run
+  end
+
+  def ab(split_name, opts = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    opts = opts.dup
+    split_name = split_name.to_s
+    true_variant = opts.delete(:true_variant)
+    context = require_option!(opts, :context)
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+
+    ab_configuration = TestTrack::ABConfiguration.new split_name: split_name, true_variant: true_variant, split_registry: split_registry
+
+    vary(split_name, context: context) do |v|
+      v.when ab_configuration.variants[:true] do
+        true
+      end
+      v.default ab_configuration.variants[:false] do
+        false
+      end
+    end
+  end
+
+  def assignment_registry
+    @assignment_registry ||= assignments.each_with_object({}) do |assignment, hsh|
+      hsh[assignment.split_name] = assignment
+    end
+  end
+
+  def unsynced_assignments
+    @unsynced_assignments ||= assignment_registry.values.select(&:unsynced?)
+  end
+
+  def assignment_json
+    assignment_registry.values.each_with_object({}) do |assignment, hsh|
+      hsh[assignment.split_name] = assignment.variant
+    end
+  end
+
+  def split_registry
+    @split_registry ||= TestTrack::Remote::SplitRegistry.to_hash
+  end
+
+  def link_identifier!(identifier_type, identifier_value)
+    identifier_opts = { identifier_type: identifier_type, visitor_id: id, value: identifier_value.to_s }
+    begin
+      identifier = TestTrack::Remote::Identifier.create!(identifier_opts)
+      merge!(identifier.visitor)
+    rescue *TestTrack::SERVER_ERRORS
+      # If at first you don't succeed, async it - we may not display 100% consistent UX this time,
+      # but subsequent requests will be better off
+      TestTrack::Remote::Identifier.delay.create!(identifier_opts)
+    end
+  end
+
+  def self.backfill_identity(opts)
+    remote_identifier_visitor = TestTrack::Remote::Visitor.from_identifier(opts[:identifier_type], opts[:identifier_value])
+    visitor = new(
+      id: remote_identifier_visitor.id,
+      assignments: remote_identifier_visitor.assignments
+    )
+
+    TestTrack::CreateAliasJob.new(existing_id: opts[:existing_id], alias_id: visitor.id).perform
+    visitor
+  end
+
+  def offline?
+    @tt_offline
+  end
+
+  private
+
+  def assignments
+    @assignments ||= (remote_visitor && remote_visitor.assignments) || []
+  end
+
+  def remote_visitor
+    @remote_visitor ||= TestTrack::Remote::Visitor.find(id) unless tt_offline?
+  rescue *TestTrack::SERVER_ERRORS
+    @tt_offline = true
+    nil
+  end
+
+  def merge!(other)
+    @id = other.id
+    @assignment_registry = assignment_registry.merge(other.assignment_registry)
+    @unsynced_assignments = nil
+  end
+
+  def tt_offline?
+    @tt_offline || false
+  end
+
+  def assignment_for(split_name)
+    fetch_assignment_for(split_name) || generate_assignment_for(split_name)
+  end
+
+  def fetch_assignment_for(split_name)
+    assignment_registry[split_name] if assignment_registry
+  end
+
+  def generate_assignment_for(split_name)
+    assignment_registry[split_name] = TestTrack::Assignment.new(visitor: self, split_name: split_name)
+  end
+end

data/app/models/test_track/visitor_dsl.rb

@@ -0,0 +1,11 @@
+class TestTrack::VisitorDSL
+  def initialize(visitor)
+    @visitor = visitor
+  end
+
+  delegate :vary, :ab, :id, to: :visitor
+
+  private
+
+  attr_reader :visitor
+end

data/app/views/tt/api/v1/identifier_visitors/show.json.jbuilder

@@ -0,0 +1 @@
+json.partial! 'tt/api/v1/visitors/show', visitor: @visitor

data/app/views/tt/api/v1/identifiers/create.json.jbuilder

@@ -0,0 +1,3 @@
+json.visitor do
+  json.partial!('tt/api/v1/visitors/show', visitor: @visitor)
+end

data/app/views/tt/api/v1/split_registries/show.json.jbuilder

@@ -0,0 +1,3 @@
+@active_splits.each do |split|
+  json.set! split.name, split.registry
+end

data/app/views/tt/api/v1/visitors/_show.json.jbuilder

@@ -0,0 +1,2 @@
+json.(visitor, :id)
+json.assignments visitor.assignments, :split_name, :variant, :unsynced

data/app/views/tt/api/v1/visitors/show.json.jbuilder

@@ -0,0 +1 @@
+json.partial! 'tt/api/v1/visitors/show', visitor: @visitor

data/config/initializers/test_track_api.rb

@@ -0,0 +1,15 @@
+require 'faraday_middleware'
+
+TestTrack::TestTrackApi = Her::API.new.setup url: ENV['TEST_TRACK_API_URL'] do |c|
+  # request
+  c.request :json
+
+  # response
+  c.use Her::Middleware::DefaultParseJSON
+
+  c.adapter Faraday.default_adapter
+
+  # Set aggressive HTTP timeouts because TestTrack needs to be fast
+  c.options[:open_timeout] = (ENV['TEST_TRACK_OPEN_TIMEOUT'] || 2).to_i # Number of seconds to wait for the connection to open.
+  c.options[:timeout] = (ENV['TEST_TRACK_TIMEOUT'] || 4).to_i # Number of seconds to wait for one block to be read (via one read(2) call).
+end

data/config/routes.rb

@@ -0,0 +1,28 @@
+Rails.application.routes.draw do
+  unless TestTrack.enabled?
+    namespace :tt do
+      namespace :api do
+        namespace :v1 do
+          resource :split_registry, only: :show
+
+          resource :assignment, only: :create
+
+          resource :identifier, only: :create
+
+          resources :visitors, only: :show
+
+          resources :identifier_types, only: [], param: :name do
+            resources :identifiers, only: [], param: :value do
+              resource :visitor, only: :show, controller: 'identifier_visitors'
+            end
+          end
+
+          resources :split_configs, only: [:create, :destroy]
+          resource :identifier_type, only: :create
+
+          resource :reset, only: :update
+        end
+      end
+    end
+  end
+end

data/lib/generators/test_track/migration_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators/named_base'
+
+module TestTrack
+  module Generators
+    class MigrationGenerator < Rails::Generators::NamedBase
+      desc "Creates a test track migration file. Files that start with retire or finish will create migrations that finish a split."
+
+      def create_test_track_migration_file
+        create_file "db/migrate/#{formatted_time_stamp}_#{file_name}.rb", <<-FILE.strip_heredoc
+          class #{file_name.camelize} < ActiveRecord::Migration
+            def change
+              TestTrack.update_config do |c|
+                #{split_command} :#{split_name}
+              end
+            end
+          end
+        FILE
+      end
+
+      private
+
+      def formatted_time_stamp
+        Time.zone.now.strftime('%Y%m%d%H%M%S')
+      end
+
+      def split_command
+        @split_command ||= finish_split? ? 'c.finish_split' : 'c.split'
+      end
+
+      def finish_split?
+        file_name.start_with?('retire', 'finish')
+      end
+
+      def split_name
+        file_name.split('_').slice(1, file_name.length).join('_')
+      end
+    end
+  end
+end

data/lib/tasks/pull_in_js_client.rake

@@ -0,0 +1,7 @@
+namespace :js_client do
+  desc 'pull in testTrack JS Client and move to app/assets/javascripts'
+  task :pull do
+    sh 'bower install'
+    sh 'mv', 'bower_components/test_track_js_client/dist/testTrack.bundle.min.js', 'app/assets/javascripts'
+  end
+end

data/lib/tasks/test_track_rails_client_tasks.rake

@@ -0,0 +1,15 @@
+namespace :test_track do
+  namespace :schema do
+    desc 'Load all Identifier Types and Splits into TestTrack from the schema file'
+    task load: :environment do
+      TestTrack.update_config do |c|
+        c.load_schema
+      end
+    end
+  end
+end
+
+unless Rails.env.test?
+  task 'db:schema:load' => ['test_track:schema:load']
+  task 'db:structure:load' => ['test_track:schema:load']
+end

data/lib/tasks/vendor_deps.rake

@@ -0,0 +1,36 @@
+namespace :test_track_rails_client do
+  task :vendor_deps do
+    FileUtils.module_eval do
+      cd "vendor/gems" do
+        rm_r Dir.glob('*')
+        %w(ruby_spec_helpers her fakeable_her).each do |repo|
+          `git clone --depth=1 git@github.com:Betterment/#{repo}.git && rm -rf #{repo}/.git`
+        end
+      end
+
+      cd "vendor/gems/ruby_spec_helpers" do
+        rm_r(Dir.glob('.*') - %w(. ..))
+        rm_r Dir.glob('*.md')
+        rm_r %w(
+          Gemfile
+          Gemfile.lock
+          spec
+        ), force: true
+        `sed -E -i '' '/license/d' ruby_spec_helpers.gemspec`
+      end
+
+      cd "vendor/gems/fakeable_her" do
+        rm_r(Dir.glob('.*') - %w(. ..))
+        rm_r Dir.glob('*.md')
+        rm_r %w(
+          Gemfile
+          Gemfile.lock
+          Rakefile
+          bin
+          spec
+        ), force: true
+        `sed -E -i '' '/license/d' fakeable_her.gemspec`
+      end
+    end
+  end
+end

data/lib/test_track.rb

@@ -0,0 +1,64 @@
+# Source vendored gems the hard way in all environments
+%w(her fakeable_her).each do |gem_name|
+  lib = File.expand_path("../../vendor/gems/#{gem_name}/lib", __FILE__)
+  $LOAD_PATH.push(lib) unless $LOAD_PATH.include?(lib)
+  require gem_name
+end
+
+require 'public_suffix'
+require 'mixpanel-ruby'
+require 'resolv'
+require 'faraday_middleware'
+require 'request_store'
+
+module TestTrack
+  module_function
+
+  SERVER_ERRORS = [Faraday::TimeoutError, Her::Errors::RemoteServerError].freeze
+
+  mattr_accessor :enabled_override
+
+  class << self
+    def analytics
+      @analytics ||= wrapper(mixpanel)
+    end
+
+    def analytics=(client)
+      @analytics = client.is_a?(TestTrack::Analytics::SafeWrapper) ? client : wrapper(client)
+    end
+
+    private
+
+    def wrapper(client)
+      TestTrack::Analytics::SafeWrapper.new(client)
+    end
+
+    def mixpanel
+      TestTrack::Analytics::MixpanelClient.new
+    end
+  end
+
+  def update_config
+    yield(ConfigUpdater.new)
+  end
+
+  def url
+    return nil unless private_url
+    full_uri = URI.parse(private_url)
+    full_uri.user = nil
+    full_uri.password = nil
+    full_uri.to_s
+  end
+
+  def private_url
+    ENV['TEST_TRACK_API_URL']
+  end
+
+  def enabled?
+    enabled_override.nil? ? !Rails.env.test? : enabled_override
+  end
+
+  def fully_qualified_cookie_domain_enabled?
+    ENV['TEST_TRACK_FULLY_QUALIFIED_COOKIE_DOMAIN_ENABLED'] == '1'
+  end
+end