betterplace-bi 0.7.0

data/spec/bi/ab_test_helper_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe BI::ABTestHelper do
+  before do
+    allow(Rails).to receive(:logger).and_return(double('logger').as_null_object)
+  end
+
+  let :helper do
+    double('helper').extend described_class
+  end
+
+  let :session do
+    double(id: 'deadbeef' * 5, loaded?: true)
+  end
+
+  let :request do
+    double(session: session, headers: {}, params: {}, user_agent: nil)
+  end
+
+  let :alternatives do
+    %w[ alt1 alt2 alt3 ]
+  end
+
+  describe '#ab_test' do
+    it 'can be overriden' do
+      allow(helper).to receive(:ab_test_override?).and_return 'alt2'
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt2'
+    end
+
+    it 'can ignore certain users' do
+      expect(helper).to receive(:ab_test_ignore_user?).and_return true
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt1'
+    end
+
+    it 'triggers loading of session unless loaded' do
+      unloaded_session = double(id: 'deadbeef' * 5, loaded?: false)
+      expect(unloaded_session).to receive(:load!)
+      allow(request).to receive(:session).and_return unloaded_session
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt2'
+    end
+
+    it 'can choose alternatives based on session id' do
+      allow(helper).to receive(:session).and_return session
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt2'
+    end
+
+    it 'does not default even without session_id' do
+      allow(request.session).to receive(:id)
+      allow(helper).to receive(:rand).and_return(666)
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt1'
+      allow(helper).to receive(:rand).and_return(667)
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt2'
+    end
+
+    it 'does not default even without session' do
+      allow(request).to receive(:session)
+      allow(helper).to receive(:rand).and_return(666)
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt1'
+      allow(helper).to receive(:rand).and_return(667)
+      expect(helper.ab_test('foo', alternatives, request: request)).to eq 'alt2'
+    end
+
+    it 'can be called with block' do
+      allow(helper).to receive(:session).and_return session
+      chosen = nil
+      expect(helper.ab_test('foo', *alternatives, request: request) {
+        |choice| chosen = choice; :result
+      }).to eq :result
+      expect(chosen).to eq 'alt2'
+    end
+  end
+
+  describe '#ab_test_ignore_user?' do
+    it 'does not ignore users by default' do
+      expect(helper).not_to be_ab_test_ignore_user(request: request)
+    end
+
+    it 'does ignore some users' do
+      allow_any_instance_of(BI::RequestAnalyzer).to receive(:ignore?).and_return true
+      expect(helper).to be_ab_test_ignore_user(request: request)
+    end
+  end
+
+  describe '#ab_test_override?' do
+    it 'does not override by default' do
+      expect(helper).not_to be_ab_test_override('foo', alternatives, request: request)
+    end
+
+    it 'can be used to choose alternatives for all ab tests' do
+      allow(request).to receive(:params).and_return({
+        'ab_test' => 'alternative'
+      })
+      expect(helper.ab_test_override?('foo', alternatives, request: request)).to eq 'alt2'
+    end
+
+    it 'can be used to choose alternatives for all ab tests with specific name' do
+      allow(request).to receive(:params).and_return({
+        'ab_test' => 'alt3'
+      })
+      expect(helper.ab_test_override?('foo', alternatives, request: request)).to eq 'alt3'
+    end
+
+    it 'can be used to choose alternatives for a specific ab test' do
+      allow(request).to receive(:params).and_return({
+        'ab_test' => { 'foo' => 'alternative' },
+      })
+      expect(helper.ab_test_override?('foo', alternatives, request: request)).to eq 'alt2'
+      expect(helper.ab_test_override?('bar', alternatives, request: request)).not_to eq 'alt2'
+    end
+
+    it 'can be used to choose alternatives with specific name' do
+      allow(request).to receive(:params).and_return({
+        'ab_test' => { 'foo' => 'alt3' },
+      })
+      expect(helper.ab_test_override?('foo', alternatives, request: request)).to eq 'alt3'
+      expect(helper.ab_test_override?('bar', alternatives, request: request)).not_to eq 'alt3'
+    end
+  end
+
+  describe '#ab_test_override_alternative' do
+    it 'can choose the control' do
+      expect(helper.ab_test_override_alternative('control', alternatives, request: request)).to\
+        eq 'alt1'
+    end
+
+    it 'can choose the first alternative' do
+      expect(helper.ab_test_override_alternative('alternative', alternatives, request: request)).to\
+        eq 'alt2'
+    end
+
+    it 'can choose the nth alternative, starting to count from 0' do
+      expect(helper.ab_test_override_alternative('1', alternatives, request: request)).to\
+        eq 'alt2'
+    end
+
+    it 'defaults to control if there is no nth alternative' do
+      expect(helper.ab_test_override_alternative('42', alternatives, request: request)).to\
+        eq 'alt1'
+    end
+
+    it 'defaults to nil in any other case' do
+      expect(helper.ab_test_override_alternative('nix', alternatives, request)).to be_nil
+    end
+  end
+end

data/spec/bi/commands/collector_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe BI::Commands::Collector do
+  let :collector do
+    described_class.new
+  end
+
+  it 'can check if job should be scheduled now' do
+    object = double(destroyed?: false)
+    expect(collector).not_to be_schedule_job(object)
+    collector.add(object, double.as_null_object)
+    expect(collector).to be_schedule_job(object)
+  end
+
+  it 'can add Update commands' do
+    object = double(destroyed?: false, id: 666)
+    expect(BI::Commands::Update).to receive(:new).and_call_original
+    collector.add(object, double.as_null_object)
+  end
+
+  it 'can add Delete commands' do
+    object = double(destroyed?: true, id: 666)
+    expect(BI::Commands::Delete).to receive(:new).and_call_original
+    collector.add(object, double.as_null_object)
+  end
+end

data/spec/bi/commands/connection_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe BI::Commands::Connection do
+  describe '#connect_to_server' do
+    it 'creates one connection' do
+      expect(described_class).to receive(:create_connection).once.and_return double.as_null_object
+      connection = nil
+      described_class.connect_to_server do |c|
+        connection = c
+        expect(connection).to receive(:reset)
+      end
+      expect(connection).not_to be_nil
+    end
+  end
+end

data/spec/bi/commands_job_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe BI::CommandsJob do
+  let :job do
+    described_class.new
+  end
+
+  it 'connects to server for commands' do
+    expect(job).to receive(:connect_to_server)
+    job.perform :something
+  end
+
+  it 'does not connect to server without commands' do
+    expect(job).not_to receive(:connect_to_server)
+    job.perform
+  end
+
+  it 'performs all given commands on server' do
+    command = double
+    expect(command).to receive(:perform_via)
+    allow(job).to receive(:create_connection).and_return(double.as_null_object)
+    job.perform command
+  end
+end

data/spec/bi/commands_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe BI::Commands do
+  before do
+    allow(Log.instance).to receive(:info)
+  end
+
+  let :object do
+    double
+  end
+
+  let :connection do
+    double
+  end
+
+  context BI::Commands::Update do
+    let :command do
+      described_class.new(value: object)
+    end
+
+    it 'can be configured' do
+      expect(command.value).to eq object
+    end
+
+    it 'can be performed' do
+      allow(object).to receive(:url)
+      expect(connection).to receive(:post).and_return double(status: 200)
+      command.perform_via(connection)
+    end
+  end
+
+  context BI::Commands::Delete do
+    let :command do
+      described_class.new(url: object)
+    end
+
+    it 'can be configured' do
+      expect(command.url).to eq object
+    end
+
+    it 'can be performed' do
+      expect(connection).to receive(:delete).and_return double(status: 200)
+      command.perform_via(connection)
+    end
+  end
+end

data/spec/bi/event_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe BI::Event do
+  before do
+    allow(Rails).to receive(:logger).and_return(double('logger').as_null_object)
+  end
+
+  class ABEvent
+    class << self
+      def serialize(*)
+      end
+
+      def create!(*)
+        new
+      end
+    end
+
+    def attributes
+      {}
+    end
+
+    include BI::Tracking
+  end
+
+  let :session_id do
+    SecureRandom.hex(32)
+  end
+
+  let :session do
+    double('session', loaded?: true, id: session_id)
+  end
+
+  subject do
+    described_class.new
+  end
+
+  it 'offers static write method' do
+    args = { channel: 'default', name: 'hello', version: 'world', session: session }
+    expect(ABEvent).to receive(:create!).with(tracking: { session: session_id } | args).and_call_original
+    described_class.write(**args)
+  end
+
+  it 'can handle sessions with string id' do
+    args = { channel: 'default', name: 'hello', version: 'world', session: session_id }
+    expect(ABEvent).to receive(:create!).with(tracking: args).and_call_original
+    described_class.write(**args)
+  end
+
+  it 'ignores unexpected session objects' do
+    args = { channel: 'default', name: 'hello', version: 'world', session: Object.new }
+    expect(ABEvent).to receive(:create!).with(tracking: { session: nil } | args).and_call_original
+    described_class.write(**args)
+  end
+
+  it 'logs any errors during writing and raises again' do
+    error = StandardError.new
+    allow(ABEvent).to receive(:create!).and_raise error
+    expect(Log).to receive(:error).with(error, notify: true, meta: { module: 'bi' })
+    expect {
+      subject.write(channel: 'default', name: 'hello', version: 'world', session: session)
+    }.to raise_error error
+  end
+
+  it 'calls write method on configured event_class' do
+    event_data_input = {
+      channel: 'default', name: 'hello', version: 'world', session: session,
+      my: :data
+    }
+    event_data_output = {
+      channel: 'default', name: 'hello', version: 'world', session: session.id,
+      my: :data
+    }
+    expect(ABEvent).to receive(:create!).with(tracking: event_data_output).and_call_original
+    expect(Log).to receive(:info)
+    subject.write(**event_data_input)
+  end
+end

data/spec/bi/planning_value_parser_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe BI::PlanningValueParser do
+  let :csv do
+    <<~end
+      product_tracking;amount_in_cents;yearmonth;data_type;data_version
+      foo;66600;2019-01;Foo;2018-06
+      bar;2300;2019-01;Bar;2018-06
+    end
+  end
+
+  let :instance do
+    described_class.parse(csv, class_name: 'TestPlanning')
+  end
+
+  context 'correct headers' do
+    it 'parses' do
+      expect(instance.first).to be_a TestPlanning
+    end
+  end
+
+  context 'invalid headers' do
+    let :csv do
+      <<~end
+        product_tracking;amount;yearmonth;data_type;data_version
+        foo;66600;2019-01;Foo;2018-06
+      end
+    end
+
+    it 'raises ParserError' do
+      expect(instance.errors).to eq(
+        2 => 'headers need to be ["amount_in_cents", "data_type", "data_version", "product_tracking", "yearmonth"]',
+      )
+    end
+
+    it 'is not valid' do
+      expect(instance).to_not be_valid
+    end
+  end
+
+  context 'invalid #values' do
+    let :csv do
+      <<~end
+        product_tracking;amount;yearmonth;data_type;data_version
+        foo;66600;2019-01;Foo;2018-06;nope
+      end
+    end
+
+    it 'raises ParserError' do
+      expect(instance.errors).to eq(
+        2 => '#values has to match #headers = 5'
+      )
+    end
+
+    it 'is not valid' do
+      expect(instance).to_not be_valid
+    end
+  end
+
+  context 'correct values' do
+    it 'parses' do
+      expect(instance.count).to eq 2
+    end
+  end
+
+  context 'incorrect values' do
+    let :csv do
+      <<~end
+        product_tracking;amount_in_cents;yearmonth;data_type;data_version
+        foo;66600;2019-13;Foo;2018-06
+      end
+    end
+
+    let :errors do
+      { 2 => [ "yearmonth: is invalid" ] }
+    end
+
+    before do
+      allow_any_instance_of(TestPlanning).to\
+        receive(:errors).and_return(errors)
+      allow(errors).to receive(:messages).and_return errors
+    end
+
+    it 'is not valid' do
+      expect(instance).to_not be_valid
+    end
+
+    it 'gives errorrs' do
+      expect(instance.errors).to eq(
+        2 => "2: yearmonth: is invalid",
+      )
+    end
+  end
+end

data/spec/bi/request_analyzer_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe BI::RequestAnalyzer do
+  before do
+    described_class.mize_cache_clear
+  end
+
+  let :request do
+    double(
+      session:    double,
+      user_agent: 'Agent Smith',
+      headers:    {},
+    )
+  end
+
+  subject do
+    described_class.new(request)
+  end
+
+  it 'can figure out user_agent' do
+    expect(subject.user_agent).to eq 'Agent Smith'
+  end
+
+  it 'can ignore or not' do
+    expect(subject).not_to be_ignore
+    allow(subject).to receive(:preview?).and_return true
+    expect(subject).to be_ignore
+    allow(subject).to receive(:robot?).and_return true
+    expect(subject).to be_ignore
+  end
+
+  it 'can figure out if request is a preview' do
+    request.headers['x-purpose'] = 'preview'
+    expect(subject).to be_preview
+  end
+
+  context 'mobile' do
+    it 'attempts to categorize mobile devices' do
+      allow(subject).to receive(:user_agent_configuration).and_return\
+        double(mobile?: %w[ Foo Mobile Baz ].map { |x| [x] * 2 }.to_h)
+      allow(request).to receive(:user_agent).and_return\
+        'Mozilla/5.0 (Linux; Android 6.0.1; SM-G920V Build/MMB29K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.98 Mobile Safari/537.36'
+      expect(subject).to be_mobile
+      expect(subject.device_type).to eq :mobile
+    end
+
+    it 'attempts to categorize desktop devices' do
+      allow(request).to receive(:user_agent).and_return\
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.246'
+      expect(subject).not_to be_mobile
+      expect(subject.device_type).to eq :desktop
+    end
+  end
+
+  context 'robot' do
+    before do
+      allow(subject).to receive(:user_agent_configuration).and_return\
+        double(mobile?: nil, robot?: %w[ Foo Slurp Baz ].map { |x|  [x] * 2 }.to_h)
+    end
+
+    it 'attempts to categorize non robots' do
+      allow(request).to receive(:user_agent).and_return\
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_2) AppleWebKit/601.3.9 (KHTML, like Gecko) Version/9.0.2 Safari/601.3.9'
+      expect(subject).not_to be_robot
+      expect(subject.device_type).to eq :desktop
+    end
+
+    it 'attempts to categorize robots' do
+      allow(request).to receive(:user_agent).and_return\
+        'Mozilla/5.0 (compatible; Yahoo! Slurp; http://help.yahoo.com/help/us/ysearch/slurp)'
+      expect(subject).to be_robot
+      expect(subject.device_type).to eq :bot
+    end
+  end
+end

data/spec/bi/shared_value_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe BI::SharedValue do
+  let :test_value do
+    BI::TestModelValue.new('foo')
+  end
+
+  it 'can warp a model' do
+    tv = BI::TestModelValue.new(TestModel.new('foo'))
+    expect(tv).to be_a described_class
+    expect(tv.id).to eq 'foo'
+  end
+
+  it 'can be build for a model with globalid' do
+    tv = BI::TestModelValue.find('foo')
+    expect(tv).to be_a described_class
+    expect(tv.id).to eq 'foo'
+  end
+
+  it 'can intialize for a model found via globalid' do
+    tv = BI::TestModelValue.new('foo')
+    expect(tv).to be_a described_class
+    expect(tv.id).to eq 'foo'
+  end
+
+  it 'haz endpoint url' do
+    expect(test_value.url).to eq '/api/v1/tests'
+  end
+
+  it 'can be converted to JSON value' do
+    Time.dummy('2011-11-11T11:11:11+01:00') do
+      expect(JSON(test_value)).to eq \
+        '{"id":"foo","number":10000000000,"created_at":"2011-11-11T11:11:11.000000Z","tags":["foo","bar"]}'
+    end
+  end
+
+  it 'can be output as string' do
+    expect(test_value.to_s).to eq "#<BI::TestModelValue type=TestModel id=foo>"
+  end
+
+  it 'can clear the models from bi' do
+    connection = double
+    expect(BI::Commands::Connection).to receive(:connect_to_server).and_yield(connection)
+    expect_any_instance_of(BI::Commands::Delete).to receive(:perform_via).with(connection)
+    test_value.class.clear
+  end
+end

data/spec/bi/tracking_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe BI::Tracking do
+  let :tracked do
+    Class.new do
+      class << self
+        def serialize(*)
+        end
+      end
+
+      include BI::Tracking
+
+      def tracking
+        @tracking ||= {}
+      end
+
+      self
+    end.new
+  end
+
+  it 'can track foos' do
+    expect(tracked.respond_to?(:tracking_foo)).to eq true
+    tracked.tracking_foo = :foo
+    expect(tracked.tracking_foo).to eq :foo
+  end
+
+  it 'can have a tracking_hash' do
+    tracked.tracking_foo = :foo
+    expect(tracked.tracking_hash).to eq(foo: :foo)
+  end
+
+  it 'does not answer non_tracking tings' do
+    expect {
+      tracked.non_tracking_foo = :foo
+    }.to raise_error NoMethodError
+  end
+end

data/spec/bi/type_generator_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe BI::TypeGenerator do
+  before do
+    allow_any_instance_of(described_class).to receive(:gofmt)
+  end
+
+  let :go_file do
+    Pathname.new(cc.bi.bime_dir).join('test_model.go')
+  end
+
+  after do
+    FileUtils.rm_rf go_file
+  end
+
+  it 'Can generate a GO types according to spec in a BI::*Value' do
+    described_class.new.generate
+    expect(File.read(go_file)).to eq(<<~end)
+      package bime
+
+      import (
+        "time"
+        "github.com/lib/pq"
+      )
+
+      type TestModel struct {
+        Id string `json:"id" gorm:"type:uuid;primary_key"`
+        Number *int64 `json:"number" gorm:"type:bigint"`
+        CreatedAt *time.Time `json:"created_at" gorm:"-" timestamp:"split"`
+        CreatedAtLocal *time.Time `json:"-" gorm:"type:timestamp;index"`
+        CreatedAtYearLocal *int `json:"-" gorm:"type:int;index"`
+        CreatedAtMonthLocal *int `json:"-" gorm:"type:int;index"`
+        CreatedAtDayLocal *int `json:"-" gorm:"type:int;index"`
+        CreatedAtHourLocal *int `json:"-" gorm:"type:int;index"`
+        CreatedAtCWLocal *int `json:"-" gorm:"type:int;index"`
+        CreatedAtDateLocal *string `json:"-" gorm:"type:varchar;index"`
+        CreatedAtYearMonthLocal *string `json:"-" gorm:"type:varchar;index"`
+        CreatedAtYearCWLocal *string `json:"-" gorm:"type:varchar;index"`
+        Tags pq.StringArray `json:"tags" gorm:"type:varchar[]"`
+      }
+    end
+  end
+end