gitlab-experiment 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f170ab47c88f393041b3f4b8b69c168d8a159fcfcdf2fe7458ceca75a9b9db
-  data.tar.gz: 5bc7fe4a5c8a493ce14413c109ac4424bdd61d8b0c3513530963e52586bfaf5f
+  metadata.gz: d4b1d80362166d1e86dd434fffe2a8e31676440f48b578e4bfcca4624fc819a8
+  data.tar.gz: 4535076f1c77f3faefc92f59be23689a5412f462bda088b67a4fbbdb58c74254
 SHA512:
-  metadata.gz: bc52008aea6015b274fb7200c83b14145b355be637f1d286a8c9590df40c5d5e2c1d6da9e6f41f7f1970c576dfb13af69f43610e162eebff642d3945455e1b24
-  data.tar.gz: 9f16a5b7bdd2ae9ea9b624946d5055878c67d67e3f755900bccdac153c330fab77ed98d1d88b0f1a869e3bbd1b1f347366252db98207513e789c387c6fd509d0
+  metadata.gz: d9d3445f7ee60be9d445760f103162861b1983c35ed6a9347e8703bc44c4bef2d7b154a62b2b05aa02c84471b8cfa95f91aa5521ee5743b9afa8ea5b4a4088eb
+  data.tar.gz: cb49261fe14971ff76799bac943e5826b04cad84982b8d061cbd7b2843a0817854772f2b3e8e55600023aff9b5266c0ba562df50c47bb90703cb686c4f973ebd

data/lib/gitlab/experiment/rspec.rb

@@ -3,44 +3,78 @@
 module Gitlab
   class Experiment
     module RSpecHelpers
-      def stub_experiments(experiments)
-        experiments.each do |name, variant|
-          variant = :control if variant == false
+      def stub_experiments(experiments, times = nil)
+        experiments.each { |experiment| wrapped_experiment(experiment, times) }
+      end
+
+      def wrapped_experiment(experiment, times = nil, expected = false, &block)
+        klass, experiment_name, variant_name = *experiment_details(experiment)
+        base_klass = Configuration.base_class.constantize
 
-          base = Configuration.base_class.constantize
-          klass = base.constantize(name) || base
+        # Set expectations on experiment classes so we can and_wrap_original with more specific args
+        experiment_klasses = base_klass.descendants.reject { |k| k == klass }
+        experiment_klasses.push(base_klass).each do |k|
+          allow(k).to receive(:new).and_call_original
+        end
 
-          # We have to use this high level any_instance behavior as there's
-          # not an alternative that allows multiple wrappings of `new`.
-          allow_any_instance_of(klass).to receive(:enabled?).and_return(true)
+        receiver = receive(:new)
 
-          if variant == true # passing true allows the rollout to do its job
-            allow_any_instance_of(klass).to receive(:experiment_group?).and_return(true)
-          else
-            allow_any_instance_of(klass).to receive(:resolve_variant_name).and_return(variant.to_s)
+        # Be specific for BaseClass calls
+        receiver = receiver.with(experiment_name, any_args) if experiment_name && klass == base_klass
+
+        receiver.exactly(times).times if times
+
+        # Set expectations on experiment class of interest
+        allow_or_expect_klass = expected ? expect(klass) : allow(klass)
+        allow_or_expect_klass.to receiver.and_wrap_original do |method, *original_args, &original_block|
+          method.call(*original_args).tap do |e|
+            # Stub internal methods before calling the original_block
+            allow(e).to receive(:enabled?).and_return(true)
+
+            if variant_name == true # passing true allows the rollout to do its job
+              allow(e).to receive(:experiment_group?).and_return(true)
+            else
+              allow(e).to receive(:resolve_variant_name).and_return(variant_name.to_s)
+            end
+
+            # Stub/set expectations before calling the original_block
+            yield e if block
+
+            original_block.call(e) if original_block.present?
           end
         end
       end
 
-      def wrapped_experiment(experiment, shallow: false, failure: nil, &block)
-        if shallow
-          yield experiment if block.present?
-          return experiment
-        end
+      private
 
-        receive_wrapped_new = receive(:new).and_wrap_original do |new, *new_args, &new_block|
-          instance = new.call(*new_args)
-          instance.tap(&block) if block.present?
-          instance.tap(&new_block) if new_block.present?
-          instance
+      def experiment_details(experiment)
+        if experiment.is_a?(Symbol)
+          experiment_name = experiment
+          variant_name = nil
         end
 
-        klass = experiment.class == Class ? experiment : experiment.class
-        if failure
-          expect(klass).to receive_wrapped_new, failure
+        experiment_name, variant_name = *experiment if experiment.is_a?(Array)
+
+        base_klass = Configuration.base_class.constantize
+        variant_name = experiment.variant.name if experiment.is_a?(base_klass)
+
+        if experiment.class.name.nil? # Anonymous class instance
+          klass = experiment.class
+        elsif experiment.instance_of?(Class) # Class level stubbing, eg. "MyExperiment"
+          klass = experiment
         else
-          allow(klass).to receive_wrapped_new
+          experiment_name ||= experiment.instance_variable_get(:@name)
+          klass = base_klass.constantize(experiment_name)
+        end
+
+        if experiment_name && klass == base_klass
+          experiment_name = experiment_name.to_sym
+
+          # For experiment names like: "group/experiment-name"
+          experiment_name = experiment_name.to_s if experiment_name.inspect.include?('"')
         end
+
+        [klass, experiment_name, variant_name]
       end
     end
 
@@ -135,34 +169,41 @@ module Gitlab
         end
 
         chain(:with_context) { |expected_context| @expected_context = expected_context }
-        chain(:on_any_instance) { @on_self = false }
+
+        chain(:on_next_instance) { @on_next_instance = true }
 
         def expect_tracking_on(experiment, negated, event, *event_args)
-          @experiment = experiment
-          @on_self = true if require_experiment(experiment, 'track', classes: !@on_self) && @on_self.nil?
-          wrapped_experiment(experiment, shallow: @on_self, failure: failure_message(:no_new, event)) do |instance|
-            @experiment = instance
-            allow(@experiment).to receive(:track)
+          klass = experiment.instance_of?(Class) ? experiment : experiment.class
+          unless klass <= Gitlab::Experiment
+            raise(
+              ArgumentError,
+              "track matcher is limited to experiment instances and classes"
+            )
+          end
+
+          expectations = proc do |e|
+            @experiment = e
+            allow(e).to receive(:track).and_call_original
 
             if negated
-              expect(@experiment).not_to receive_tracking_call_for(event, *event_args)
+              expect(e).not_to receive(:track).with(*[event, *event_args])
             else
-              expect(@experiment).to receive_tracking_call_for(event, *event_args)
-            end
-          end
-        end
+              if @expected_variant
+                expect(@experiment.variant.name).to eq(@expected_variant), failure_message(:variant, event)
+              end
 
-        def receive_tracking_call_for(expected_event, *expected_event_args)
-          receive(:track).with(*[expected_event, *expected_event_args]).and_wrap_original do |track, event, *event_args|
-            track.call(event, *event_args) # call the original
+              if @expected_context
+                expect(@experiment.context.value).to include(@expected_context), failure_message(:context, event)
+              end
 
-            if @expected_variant
-              expect(@experiment.variant.name).to eq(@expected_variant), failure_message(:variant, expected_event)
+              expect(e).to receive(:track).with(*[event, *event_args]).and_call_original
             end
+          end
 
-            if @expected_context
-              expect(@experiment.context.value).to include(@expected_context), failure_message(:context, expected_event)
-            end
+          if experiment.instance_of?(Class) || @on_next_instance
+            wrapped_experiment(experiment, nil, true) { |e| expectations.call(e) }
+          else
+            expectations.call(experiment)
           end
         end
 
@@ -180,8 +221,6 @@ module Gitlab
                   expected context: #{@expected_context}
                     actual context: #{@experiment.context.value}
             MESSAGE
-          when :no_new
-            %(expected #{@experiment.inspect} to have tracked #{event.inspect}, but no new instances were created)
           end
         end
       end

data/lib/gitlab/experiment/version.rb

@@ -2,6 +2,6 @@
 
 module Gitlab
   class Experiment
-    VERSION = '0.5.1'
+    VERSION = '0.5.2'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-experiment
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - GitLab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-17 00:00:00.000000000 Z
+date: 2021-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport