279 lines
8.3 KiB
Ruby
279 lines
8.3 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
RSpec.describe ApplicationExperiment, :experiment do
|
|
subject { described_class.new('namespaced/stub') }
|
|
|
|
let(:feature_definition) do
|
|
{ name: 'namespaced_stub', type: 'experiment', group: 'group::adoption', default_enabled: false }
|
|
end
|
|
|
|
around do |example|
|
|
Feature::Definition.definitions[:namespaced_stub] = Feature::Definition.new('namespaced_stub.yml', feature_definition)
|
|
example.run
|
|
Feature::Definition.definitions.delete(:namespaced_stub)
|
|
end
|
|
|
|
before do
|
|
allow(subject).to receive(:enabled?).and_return(true)
|
|
end
|
|
|
|
it "naively assumes a 1x1 relationship to feature flags for tests" do
|
|
expect(Feature).to receive(:persist_used!).with('namespaced_stub')
|
|
|
|
described_class.new('namespaced/stub')
|
|
end
|
|
|
|
it "doesn't raise an exception without a defined control" do
|
|
# because we have a default behavior defined
|
|
|
|
expect { experiment('namespaced/stub') { } }.not_to raise_error
|
|
end
|
|
|
|
describe "enabled" do
|
|
before do
|
|
allow(subject).to receive(:enabled?).and_call_original
|
|
|
|
allow(Feature::Definition).to receive(:get).and_return('_instance_')
|
|
allow(Gitlab).to receive(:dev_env_or_com?).and_return(true)
|
|
allow(Feature).to receive(:get).and_return(double(state: :on))
|
|
end
|
|
|
|
it "is enabled when all criteria are met" do
|
|
expect(subject).to be_enabled
|
|
end
|
|
|
|
it "isn't enabled if the feature definition doesn't exist" do
|
|
expect(Feature::Definition).to receive(:get).with('namespaced_stub').and_return(nil)
|
|
|
|
expect(subject).not_to be_enabled
|
|
end
|
|
|
|
it "isn't enabled if we're not in dev or dotcom environments" do
|
|
expect(Gitlab).to receive(:dev_env_or_com?).and_return(false)
|
|
|
|
expect(subject).not_to be_enabled
|
|
end
|
|
|
|
it "isn't enabled if the feature flag state is :off" do
|
|
expect(Feature).to receive(:get).with('namespaced_stub').and_return(double(state: :off))
|
|
|
|
expect(subject).not_to be_enabled
|
|
end
|
|
end
|
|
|
|
describe "publishing results" do
|
|
it "doesn't record, track or push data to the client if we shouldn't track", :snowplow do
|
|
allow(subject).to receive(:should_track?).and_return(false)
|
|
subject.record!
|
|
|
|
expect(subject).not_to receive(:record_experiment)
|
|
expect(subject).not_to receive(:track)
|
|
expect(Gon).not_to receive(:push)
|
|
|
|
subject.publish(:action)
|
|
|
|
expect_no_snowplow_event
|
|
end
|
|
|
|
describe 'recording the experiment' do
|
|
it 'does not record the experiment if we do not tell it to' do
|
|
expect(subject).not_to receive(:record_experiment)
|
|
|
|
subject.publish
|
|
end
|
|
|
|
it 'records the experiment if we tell it to' do
|
|
subject.record!
|
|
|
|
expect(subject).to receive(:record_experiment)
|
|
|
|
subject.publish
|
|
end
|
|
end
|
|
|
|
it "tracks the assignment" do
|
|
expect(subject).to receive(:track).with(:assignment)
|
|
|
|
subject.publish
|
|
end
|
|
|
|
it "pushes the experiment knowledge into the client using Gon" do
|
|
expect(Gon).to receive(:push).with({ experiment: { 'namespaced/stub' => subject.signature } }, true)
|
|
|
|
subject.publish
|
|
end
|
|
|
|
it "handles when Gon raises exceptions (like when it can't be pushed into)" do
|
|
expect(Gon).to receive(:push).and_raise(NoMethodError)
|
|
|
|
expect { subject.publish }.not_to raise_error
|
|
end
|
|
end
|
|
|
|
it "can exclude from within the block" do
|
|
expect(described_class.new('namespaced/stub') { |e| e.exclude! }).to be_excluded
|
|
end
|
|
|
|
describe 'recording the experiment subject' do
|
|
using RSpec::Parameterized::TableSyntax
|
|
|
|
subject { described_class.new('namespaced/stub', nil, **context) }
|
|
|
|
before do
|
|
subject.record!
|
|
end
|
|
|
|
context 'when providing a compatible context' do
|
|
where(:context_key, :object_type) do
|
|
:namespace | :namespace
|
|
:group | :namespace
|
|
:project | :project
|
|
:user | :user
|
|
:actor | :user
|
|
end
|
|
|
|
with_them do
|
|
let(:context) { { context_key => build(object_type) }}
|
|
|
|
it 'records the experiment and the experiment subject from the context' do
|
|
expect { subject.publish }.to change(Experiment, :count).by(1)
|
|
|
|
expect(Experiment.last.name).to eq('namespaced/stub')
|
|
expect(ExperimentSubject.last.send(object_type)).to eq(context[context_key])
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when providing an incompatible or no context' do
|
|
where(context_hash: [{ foo: :bar }, {}])
|
|
|
|
with_them do
|
|
let(:context) { context_hash }
|
|
|
|
it 'does not record the experiment' do
|
|
expect { subject.publish }.not_to change(Experiment, :count)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "tracking events", :snowplow do
|
|
it "doesn't track if we shouldn't track" do
|
|
allow(subject).to receive(:should_track?).and_return(false)
|
|
|
|
subject.track(:action)
|
|
|
|
expect_no_snowplow_event
|
|
end
|
|
|
|
it "tracks the event with the expected arguments and merged contexts" do
|
|
subject.track(:action, property: '_property_', context: [
|
|
SnowplowTracker::SelfDescribingJson.new('iglu:com.gitlab/fake/jsonschema/0-0-0', { data: '_data_' })
|
|
])
|
|
|
|
expect_snowplow_event(
|
|
category: 'namespaced/stub',
|
|
action: 'action',
|
|
property: '_property_',
|
|
context: [
|
|
{
|
|
schema: 'iglu:com.gitlab/fake/jsonschema/0-0-0',
|
|
data: { data: '_data_' }
|
|
},
|
|
{
|
|
schema: 'iglu:com.gitlab/gitlab_experiment/jsonschema/1-0-0',
|
|
data: { experiment: 'namespaced/stub', key: '86208ac54ca798e11f127e8b23ec396a', variant: 'control' }
|
|
}
|
|
]
|
|
)
|
|
end
|
|
end
|
|
|
|
describe "variant resolution" do
|
|
it "uses the default value as specified in the yaml" do
|
|
expect(Feature).to receive(:enabled?).with('namespaced_stub', subject, type: :experiment, default_enabled: :yaml)
|
|
|
|
expect(subject.variant.name).to eq('control')
|
|
end
|
|
|
|
context "when rolled out to 100%" do
|
|
before do
|
|
stub_feature_flags(namespaced_stub: true)
|
|
end
|
|
|
|
it "returns the first variant name" do
|
|
subject.try(:variant1) {}
|
|
subject.try(:variant2) {}
|
|
|
|
expect(subject.variant.name).to eq('variant1')
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when caching" do
|
|
let(:cache) { Gitlab::Experiment::Configuration.cache }
|
|
|
|
before do
|
|
allow(Gitlab::Experiment::Configuration).to receive(:cache).and_call_original
|
|
|
|
cache.clear(key: subject.name)
|
|
|
|
subject.use { } # setup the control
|
|
subject.try { } # setup the candidate
|
|
end
|
|
|
|
it "caches the variant determined by the variant resolver" do
|
|
expect(subject.variant.name).to eq('candidate') # we should be in the experiment
|
|
|
|
subject.run
|
|
|
|
expect(subject.cache.read).to eq('candidate')
|
|
end
|
|
|
|
it "doesn't cache a variant if we don't explicitly provide one" do
|
|
# by not caching "empty" variants, we effectively create a mostly
|
|
# optimal combination of caching and rollout flexibility. If we cached
|
|
# every control variant assigned, we'd inflate the cache size and
|
|
# wouldn't be able to roll out to subjects that we'd already assigned to
|
|
# the control.
|
|
stub_feature_flags(namespaced_stub: false) # simulate being not rolled out
|
|
|
|
expect(subject.variant.name).to eq('control') # if we ask, it should be control
|
|
|
|
subject.run
|
|
|
|
expect(subject.cache.read).to be_nil
|
|
end
|
|
|
|
it "caches a control variant if we assign it specifically" do
|
|
# by specifically assigning the control variant here, we're guaranteeing
|
|
# that this context will always get the control variant unless we delete
|
|
# the field from the cache (or clear the entire experiment cache) -- or
|
|
# write code that would specify a different variant.
|
|
subject.run(:control)
|
|
|
|
expect(subject.cache.read).to eq('control')
|
|
end
|
|
|
|
context "arbitrary attributes" do
|
|
before do
|
|
subject.cache.store.clear(key: subject.name + '_attrs')
|
|
end
|
|
|
|
it "sets and gets attributes about an experiment" do
|
|
subject.cache.attr_set(:foo, :bar)
|
|
|
|
expect(subject.cache.attr_get(:foo)).to eq('bar')
|
|
end
|
|
|
|
it "increments a value for an experiment" do
|
|
expect(subject.cache.attr_get(:foo)).to be_nil
|
|
|
|
expect(subject.cache.attr_inc(:foo)).to eq(1)
|
|
expect(subject.cache.attr_inc(:foo)).to eq(2)
|
|
end
|
|
end
|
|
end
|
|
end
|