test_track_rails_client 0.9.0

data/app/models/concerns/test_track/remote_model.rb

@@ -0,0 +1,14 @@
+module TestTrack::RemoteModel
+  extend ActiveSupport::Concern
+  include FakeableHer::Model
+
+  included do
+    use_api TestTrack::TestTrackApi
+  end
+
+  module ClassMethods
+    def faked?
+      !TestTrack.enabled?
+    end
+  end
+end

data/app/models/concerns/test_track/required_options.rb

@@ -0,0 +1,11 @@
+module TestTrack::RequiredOptions
+  extend ActiveSupport::Concern
+
+  private
+
+  def require_option!(opts, opt_name, my_opts = {})
+    opt_provided = my_opts[:allow_nil] ? opts.key?(opt_name) : opts[opt_name]
+    raise(ArgumentError, "Must provide #{opt_name}") unless opt_provided
+    opts.delete(opt_name)
+  end
+end

data/app/models/test_track/ab_configuration.rb

@@ -0,0 +1,53 @@
+class TestTrack::ABConfiguration
+  include TestTrack::RequiredOptions
+
+  def initialize(opts)
+    @split_name = require_option!(opts, :split_name).to_s
+    true_variant = require_option!(opts, :true_variant, allow_nil: true)
+    @split_registry = require_option!(opts, :split_registry, allow_nil: true)
+    raise ArgumentError, "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+
+    @true_variant = true_variant.to_s if true_variant
+
+    raise ArgumentError, "unknown split: #{split_name}" if @split_registry && !split
+  end
+
+  def variants
+    @variants ||= build_variant_hash
+  end
+
+  private
+
+  def build_variant_hash
+    airbrake_because_ab("configures split with more than 2 variants") if split_variants && split_variants.size > 2
+    { true: true_variant, false: false_variant }
+  end
+
+  def true_variant
+    @true_variant ||= true
+  end
+
+  def false_variant
+    @false_variant ||= non_true_variants.present? ? non_true_variants.sort.first : false
+  end
+
+  attr_reader :split_name, :split_registry
+
+  def split
+    split_registry && split_registry[split_name]
+  end
+
+  def split_variants
+    @split_variants ||= split.keys if split_registry
+  end
+
+  def non_true_variants
+    split_variants - [true_variant.to_s] if split_variants
+  end
+
+  def airbrake_because_ab(msg)
+    msg = "A/B for \"#{split_name}\" #{msg}"
+    Rails.logger.error(msg)
+    Airbrake.notify_or_ignore(msg)
+  end
+end

data/app/models/test_track/analytics/mixpanel_client.rb

@@ -0,0 +1,25 @@
+module TestTrack::Analytics
+  class MixpanelClient
+    delegate :alias, to: :mixpanel
+
+    def track_assignment(visitor_id, assignment, params = {})
+      distinct_id = params.delete(:mixpanel_distinct_id) || visitor_id
+      mixpanel.track(distinct_id, 'SplitAssigned', split_properties(assignment).merge(TTVisitorID: visitor_id))
+    end
+
+    private
+
+    def mixpanel
+      raise "ENV['MIXPANEL_TOKEN'] must be set" unless ENV['MIXPANEL_TOKEN']
+      @mixpanel ||= Mixpanel::Tracker.new(ENV['MIXPANEL_TOKEN'])
+    end
+
+    def split_properties(assignment)
+      {
+        SplitName: assignment.split_name,
+        SplitVariant: assignment.variant,
+        SplitContext: assignment.context
+      }
+    end
+  end
+end

data/app/models/test_track/analytics/safe_wrapper.rb

@@ -0,0 +1,43 @@
+module TestTrack::Analytics
+  class SafeWrapper
+    attr_reader :underlying
+
+    def initialize(underlying)
+      @underlying = underlying
+    end
+
+    def error_handler=(handler)
+      raise ArgumentError, "error_handler must be a lambda" unless handler.lambda?
+      raise ArgumentError, "error_handler must accept 1 argument" unless handler.arity == 1
+      @error_handler = handler
+    end
+
+    def track_assignment(visitor_id, assignment, params = {})
+      safe_action { underlying.track_assignment(visitor_id, assignment, params) }
+    end
+
+    def alias(visitor_id, existing_id)
+      safe_action { underlying.alias(visitor_id, existing_id) }
+    end
+
+    private
+
+    def error_handler
+      @error_handler || ->(e) do
+        if Object.const_defined?(:Airbrake)
+          Airbrake.notify e
+        else
+          Rails.logger.error e
+        end
+      end
+    end
+
+    def safe_action
+      yield
+      true
+    rescue StandardError => e
+      error_handler.call e
+      false
+    end
+  end
+end

data/app/models/test_track/assignment.rb

@@ -0,0 +1,29 @@
+class TestTrack::Assignment
+  include TestTrack::RequiredOptions
+
+  attr_accessor :context
+  attr_reader :visitor, :split_name
+  attr_writer :variant
+
+  def initialize(opts = {})
+    @visitor = require_option!(opts, :visitor)
+    @split_name = require_option!(opts, :split_name).to_s
+    raise ArgumentError, "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+  end
+
+  def variant
+    @variant ||= _variant
+  end
+
+  def unsynced?
+    true
+  end
+
+  private
+
+  def _variant
+    return if visitor.offline?
+    variant = TestTrack::VariantCalculator.new(visitor: visitor, split_name: split_name).variant
+    variant && variant.to_s
+  end
+end

data/app/models/test_track/config_updater.rb

@@ -0,0 +1,99 @@
+class TestTrack::ConfigUpdater
+  def initialize(schema_file_path = "#{Rails.root}/db/test_track_schema.yml")
+    @schema_file_path = schema_file_path
+  end
+
+  def split(name, weighting_registry)
+    create_split(name, weighting_registry)
+
+    name = name.to_s
+    splits[name] = weighting_registry.stringify_keys
+    splits.except!(*(splits.keys - remote_splits.keys - [name]))
+
+    persist_schema!
+  end
+
+  def drop_split(name)
+    TestTrack::Remote::SplitConfig.destroy_existing(name)
+
+    splits.except!(name.to_s)
+
+    persist_schema!
+  end
+  alias finish_split drop_split # to support older migrations written with `finish_split`
+
+  def identifier_type(name)
+    create_identifier_type(name)
+
+    identifier_types << name.to_s
+
+    persist_schema!
+  end
+
+  def load_schema
+    identifier_types.each do |name|
+      create_identifier_type(name)
+    end
+
+    splits.each do |name, weighting_registry|
+      create_split(name, weighting_registry)
+    end
+  end
+
+  private
+
+  attr_reader :schema_file_path
+
+  def create_split(name, weighting_registry)
+    TestTrack::Remote::SplitConfig.new(name: name, weighting_registry: weighting_registry).tap do |split_config|
+      raise split_config.errors.full_messages.join("\n") unless split_config.save
+    end
+  end
+
+  def create_identifier_type(name)
+    TestTrack::Remote::IdentifierType.new(name: name).tap do |identifier_type|
+      raise identifier_type.errors.full_messages.join("\n") unless identifier_type.save
+    end
+  end
+
+  def remote_splits
+    unless @remote_splits
+      TestTrack::Remote::SplitRegistry.reset
+      @remote_splits = TestTrack::Remote::SplitRegistry.to_hash
+    end
+    @remote_splits
+  end
+
+  def persist_schema!
+    File.open(schema_file_path, "w") do |f|
+      f.write YAML.dump("identifier_types" => identifier_types.sort, "splits" => sorted_splits)
+    end
+  end
+
+  def identifier_types
+    @identifier_types ||= Set.new(schema_file_hash["identifier_types"] || [])
+  end
+
+  def splits
+    @splits ||= schema_file_hash["splits"] || {}
+  end
+
+  def sorted_splits
+    sorted = Hash[splits.sort]
+    sorted.each do |split_name, weighting_registry|
+      sorted[split_name] = Hash[weighting_registry.sort]
+    end
+  end
+
+  def schema_file_hash
+    @schema_hash ||= YAML.load(schema_file_contents) || {}
+  end
+
+  def schema_file_contents
+    @schema_file_contents ||= schema_file_exists? ? File.open(schema_file_path, "r").read : ""
+  end
+
+  def schema_file_exists?
+    File.exist?(schema_file_path)
+  end
+end

data/app/models/test_track/create_alias_job.rb

@@ -0,0 +1,18 @@
+class TestTrack::CreateAliasJob
+  attr_reader :existing_id, :alias_id
+
+  def initialize(opts)
+    @existing_id = opts.delete(:existing_id)
+    @alias_id = opts.delete(:alias_id)
+
+    %w(existing_id alias_id).each do |param_name|
+      raise "#{param_name} must be present" unless send(param_name).present?
+    end
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+  end
+
+  def perform
+    return unless TestTrack.enabled?
+    TestTrack.analytics.alias(alias_id, existing_id)
+  end
+end

data/app/models/test_track/fake/split_registry.rb

@@ -0,0 +1,36 @@
+class TestTrack::Fake::SplitRegistry
+  Split = Struct.new(:name, :registry)
+
+  def self.instance
+    @instance ||= new
+  end
+
+  def to_h
+    if test_track_schema_yml.present?
+      test_track_schema_yml[:splits]
+    else
+      {}
+    end
+  end
+
+  def splits
+    to_h.map do |split, registry|
+      Split.new(split, registry)
+    end
+  end
+
+  private
+
+  def test_track_schema_yml
+    unless instance_variable_defined?(:@test_track_schema_yml)
+      @test_track_schema_yml = _test_track_schema_yml
+    end
+    @test_track_schema_yml
+  end
+
+  def _test_track_schema_yml
+    YAML.load_file("#{Rails.root}/db/test_track_schema.yml").with_indifferent_access
+  rescue
+    nil
+  end
+end

data/app/models/test_track/fake/visitor.rb

@@ -0,0 +1,41 @@
+require 'digest'
+
+class TestTrack::Fake::Visitor
+  attr_reader :id
+
+  Assignment = Struct.new(:split_name, :variant, :unsynced, :context)
+
+  def self.instance
+    @instance ||= new(TestTrack::FakeServer.seed)
+  end
+
+  def self.reset!
+    @instance = nil
+  end
+
+  def initialize(id)
+    @id = id
+  end
+
+  def assignments
+    @assignments ||= _assignments
+  end
+
+  private
+
+  def _assignments
+    TestTrack::Fake::SplitRegistry.instance.splits.map do |split|
+      index = hash_fixnum(split.name) % split.registry.keys.size
+      variant = split.registry.keys[index]
+      Assignment.new(split.name, variant, false, "the_context")
+    end
+  end
+
+  def hash_fixnum(split_name)
+    split_visitor_hash(split_name).slice(0, 8).to_i(16)
+  end
+
+  def split_visitor_hash(split_name)
+    Digest::MD5.new.update(split_name.to_s + id.to_s).hexdigest
+  end
+end

data/app/models/test_track/fake_server.rb

@@ -0,0 +1,24 @@
+class TestTrack::FakeServer
+  class << self
+    def split_registry
+      TestTrack::Fake::SplitRegistry.instance.splits
+    end
+
+    def visitor
+      TestTrack::Fake::Visitor.instance
+    end
+
+    def assignments
+      TestTrack::Fake::Visitor.instance.assignments
+    end
+
+    def reset!(seed)
+      TestTrack::Fake::Visitor.reset!
+      @seed = Integer(seed)
+    end
+
+    def seed
+      @seed || raise('TestTrack::FakeServer seed not set. Call TestTrack::FakeServer.reset!(seed) to set seed.')
+    end
+  end
+end

data/app/models/test_track/identity_session_discriminator.rb

@@ -0,0 +1,34 @@
+class TestTrack::IdentitySessionDiscriminator
+  attr_reader :identity
+
+  def initialize(identity)
+    @identity = identity
+  end
+
+  def controller
+    @controller ||= RequestStore[:test_track_controller]
+  end
+
+  def participate_in_online_session?
+    authenticated_resource_matches_identity?
+  end
+
+  private
+
+  def authenticated_resource_matches_identity?
+    controller_has_authenticated_resource? && controller.send(authenticated_resource_method_name) == identity
+  end
+
+  def controller_has_authenticated_resource?
+    # pass true to `respond_to?` to include private methods
+    web_context? && controller.respond_to?(authenticated_resource_method_name, true)
+  end
+
+  def web_context?
+    controller.present?
+  end
+
+  def authenticated_resource_method_name
+    @authenticated_resource_method_name ||= "current_#{identity.class.model_name.element}"
+  end
+end

data/app/models/test_track/notify_assignment_job.rb

@@ -0,0 +1,31 @@
+class TestTrack::NotifyAssignmentJob
+  attr_reader :mixpanel_distinct_id, :visitor_id, :assignment
+
+  def initialize(opts)
+    @visitor_id = opts.delete(:visitor_id)
+    @mixpanel_distinct_id = opts.delete(:mixpanel_distinct_id)
+    @assignment = opts.delete(:assignment)
+
+    %w(visitor_id assignment).each do |param_name|
+      raise "#{param_name} must be present" unless send(param_name).present?
+    end
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+  end
+
+  def perform
+    TestTrack::Remote::AssignmentEvent.create!(
+      visitor_id: visitor_id,
+      split_name: assignment.split_name,
+      context: assignment.context,
+      mixpanel_result: track
+    )
+  end
+
+  private
+
+  def track
+    return "failure" unless TestTrack.enabled?
+    result = TestTrack.analytics.track_assignment(visitor_id, assignment, mixpanel_distinct_id: mixpanel_distinct_id)
+    result ? "success" : "failure"
+  end
+end