flipper 0.27.1 → 0.28.1

data/lib/flipper/types/group.rb

@@ -16,16 +16,16 @@ module Flipper
           @block = block
           @single_argument = call_with_no_context?(@block)
         else
-          @block = ->(_thing, _context) { false }
+          @block = ->(actor, context) { false }
           @single_argument = false
         end
       end
 
-      def match?(thing, context)
+      def match?(actor, context)
         if @single_argument
-          @block.call(thing)
+          @block.call(actor)
         else
-          @block.call(thing, context)
+          @block.call(actor, context)
         end
       end
 

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = '0.27.1'.freeze
+  VERSION = '0.28.1'.freeze
 end

data/lib/flipper.rb

@@ -72,12 +72,12 @@ module Flipper
   #
   # name - The Symbol name of the group.
   # block - The block that should be used to determine if the group matches a
-  #         given thing.
+  #         given actor.
   #
   # Examples
   #
-  #   Flipper.register(:admins) { |thing|
-  #     thing.respond_to?(:admin?) && thing.admin?
+  #   Flipper.register(:admins) { |actor|
+  #     actor.respond_to?(:admin?) && actor.admin?
   #   }
   #
   # Returns a Flipper::Group.

data/spec/flipper/adapters/memory_spec.rb

@@ -1,8 +1,17 @@
 RSpec.describe Flipper::Adapters::Memory do
   let(:source) { {} }
-  subject { described_class.new(source) }
 
-  it_should_behave_like 'a flipper adapter'
+  context 'threadsafe: true' do
+    subject { described_class.new(source, threadsafe: true) }
+
+    it_should_behave_like 'a flipper adapter'
+  end
+
+  context 'threadsafe: false' do
+    subject { described_class.new(source, threadsafe: false) }
+
+    it_should_behave_like 'a flipper adapter'
+  end
 
   it "can initialize from big hash" do
     flipper = Flipper.new(subject)

data/spec/flipper/dsl_spec.rb

@@ -149,12 +149,12 @@ RSpec.describe Flipper::DSL do
   end
 
   describe '#actor' do
-    context 'for a thing' do
+    context 'for an actor' do
       it 'returns actor instance' do
-        thing = Flipper::Actor.new(33)
-        actor = subject.actor(thing)
-        expect(actor).to be_instance_of(Flipper::Types::Actor)
-        expect(actor.value).to eq('33')
+        actor = Flipper::Actor.new(33)
+        flipper_actor = subject.actor(actor)
+        expect(flipper_actor).to be_instance_of(Flipper::Types::Actor)
+        expect(flipper_actor.value).to eq('33')
       end
     end
 

data/spec/flipper/feature_check_context_spec.rb

@@ -1,12 +1,12 @@
 RSpec.describe Flipper::FeatureCheckContext do
   let(:feature_name) { :new_profiles }
   let(:values) { Flipper::GateValues.new({}) }
-  let(:thing) { Flipper::Actor.new('5') }
+  let(:actor) { Flipper::Actor.new('5') }
   let(:options) do
     {
       feature_name: feature_name,
       values: values,
-      thing: thing,
+      actors: [actor],
     }
   end
 
@@ -14,7 +14,7 @@ RSpec.describe Flipper::FeatureCheckContext do
     instance = described_class.new(**options)
     expect(instance.feature_name).to eq(feature_name)
     expect(instance.values).to eq(values)
-    expect(instance.thing).to eq(thing)
+    expect(instance.actors).to eq([actor])
   end
 
   it 'requires feature_name' do
@@ -31,8 +31,8 @@ RSpec.describe Flipper::FeatureCheckContext do
     end.to raise_error(ArgumentError)
   end
 
-  it 'requires thing' do
-    options.delete(:thing)
+  it 'requires actors' do
+    options.delete(:actors)
     expect do
       described_class.new(**options)
     end.to raise_error(ArgumentError)

data/spec/flipper/feature_spec.rb

@@ -32,6 +32,52 @@ RSpec.describe Flipper::Feature do
     end
   end
 
+  describe "#enabled?" do
+    context "for an actor" do
+      let(:actor) { Flipper::Actor.new("User;1") }
+
+      it 'returns true if feature is enabled' do
+        subject.enable
+        expect(subject.enabled?(actor)).to be(true)
+      end
+
+      it 'returns false if feature is disabled' do
+        subject.disable
+        expect(subject.enabled?(actor)).to be(false)
+      end
+    end
+
+    context "for multiple actors" do
+      let(:actors) {
+        [
+          Flipper::Actor.new("User;1"),
+          Flipper::Actor.new("User;2"),
+          Flipper::Actor.new("User;3"),
+        ]
+      }
+
+      it 'returns true if feature is enabled' do
+        subject.enable
+        expect(subject.enabled?(actors)).to be(true)
+      end
+
+      it 'returns true if feature is enabled for any actor' do
+        subject.enable_actor actors.first
+        expect(subject.enabled?(actors)).to be(true)
+      end
+
+      it 'returns true if feature is enabled for any actor with multiple arguments' do
+        subject.enable_actor actors.last
+        expect(subject.enabled?(*actors)).to be(true)
+      end
+
+      it 'returns false if feature is disabled for all actors' do
+        subject.disable
+        expect(subject.enabled?(actors)).to be(false)
+      end
+    end
+  end
+
   describe '#to_s' do
     it 'returns name as string' do
       feature = described_class.new(:search, adapter)
@@ -148,29 +194,29 @@ RSpec.describe Flipper::Feature do
     end
 
     it 'is recorded for enable' do
-      thing = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
-      gate = subject.gate_for(thing)
+      actor = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
+      gate = subject.gate_for(actor)
 
-      subject.enable(thing)
+      subject.enable(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
       expect(event.name).to eq('feature_operation.flipper')
       expect(event.payload[:feature_name]).to eq(:search)
       expect(event.payload[:operation]).to eq(:enable)
-      expect(event.payload[:thing]).to eq(thing)
+      expect(event.payload[:thing]).to eq(actor)
       expect(event.payload[:result]).not_to be_nil
     end
 
     it 'always instruments flipper type instance for enable' do
-      thing = Flipper::Actor.new('1')
-      gate = subject.gate_for(thing)
+      actor = Flipper::Actor.new('1')
+      gate = subject.gate_for(actor)
 
-      subject.enable(thing)
+      subject.enable(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
-      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(thing))
+      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(actor))
     end
 
     it 'is recorded for disable' do
@@ -219,15 +265,15 @@ RSpec.describe Flipper::Feature do
     end
 
     it 'always instruments flipper type instance for disable' do
-      thing = Flipper::Actor.new('1')
-      gate = subject.gate_for(thing)
+      actor = Flipper::Actor.new('1')
+      gate = subject.gate_for(actor)
 
-      subject.disable(thing)
+      subject.disable(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
       expect(event.payload[:operation]).to eq(:disable)
-      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(thing))
+      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(actor))
     end
 
     it 'is recorded for add' do
@@ -275,17 +321,15 @@ RSpec.describe Flipper::Feature do
     end
 
     it 'is recorded for enabled?' do
-      thing = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
-      gate = subject.gate_for(thing)
-
-      subject.enabled?(thing)
+      actor = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
+      subject.enabled?(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
       expect(event.name).to eq('feature_operation.flipper')
       expect(event.payload[:feature_name]).to eq(:search)
       expect(event.payload[:operation]).to eq(:enabled?)
-      expect(event.payload[:thing]).to eq(thing)
+      expect(event.payload[:actors]).to eq([actor])
       expect(event.payload[:result]).to eq(false)
     end
 
@@ -293,8 +337,8 @@ RSpec.describe Flipper::Feature do
     actor = Flipper::Types::Actor.new(user)
     {
       nil => nil,
-      user => actor,
-      actor => actor,
+      user => [actor],
+      actor => [actor],
     }.each do |thing, wrapped_thing|
       it "always instruments #{thing.inspect} as #{wrapped_thing.class} for enabled?" do
         subject.enabled?(thing)
@@ -302,7 +346,7 @@ RSpec.describe Flipper::Feature do
         event = instrumenter.events.last
         expect(event).not_to be_nil
         expect(event.payload[:operation]).to eq(:enabled?)
-        expect(event.payload[:thing]).to eq(wrapped_thing)
+        expect(event.payload[:actors]).to eq(wrapped_thing)
       end
     end
   end
@@ -428,10 +472,10 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |_thing| true }
-        @preview_features = Flipper.register(:preview_features) { |_thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
-        @disabled = Flipper.register(:disabled) { |_thing| true }
+        @staff = Flipper.register(:staff) { |actor| true }
+        @preview_features = Flipper.register(:preview_features) { |actor| true }
+        @not_enabled = Flipper.register(:not_enabled) { |actor| true }
+        @disabled = Flipper.register(:disabled) { |actor| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
@@ -467,10 +511,10 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |_thing| true }
-        @preview_features = Flipper.register(:preview_features) { |_thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
-        @disabled = Flipper.register(:disabled) { |_thing| true }
+        @staff = Flipper.register(:staff) { |actor| true }
+        @preview_features = Flipper.register(:preview_features) { |actor| true }
+        @not_enabled = Flipper.register(:not_enabled) { |actor| true }
+        @disabled = Flipper.register(:disabled) { |actor| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
@@ -494,10 +538,10 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |_thing| true }
-        @preview_features = Flipper.register(:preview_features) { |_thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
-        @disabled = Flipper.register(:disabled) { |_thing| true }
+        @staff = Flipper.register(:staff) { |actor| true }
+        @preview_features = Flipper.register(:preview_features) { |actor| true }
+        @not_enabled = Flipper.register(:not_enabled) { |actor| true }
+        @disabled = Flipper.register(:disabled) { |actor| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled

data/spec/flipper/gates/boolean_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Flipper::Gates::Boolean do
     Flipper::FeatureCheckContext.new(
       feature_name: feature_name,
       values: Flipper::GateValues.new(boolean: bool),
-      thing: Flipper::Types::Actor.new(Flipper::Actor.new(1))
+      actors: [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
     )
   end
 

data/spec/flipper/gates/group_spec.rb

@@ -9,18 +9,17 @@ RSpec.describe Flipper::Gates::Group do
     Flipper::FeatureCheckContext.new(
       feature_name: feature_name,
       values: Flipper::GateValues.new(groups: set),
-      thing: Flipper::Types::Actor.new(Flipper::Actor.new('5'))
+      actors: [Flipper::Types::Actor.new(Flipper::Actor.new('5'))]
     )
   end
 
   describe '#open?' do
     context 'with a group in adapter, but not registered' do
       before do
-        Flipper.register(:staff) { |_thing| true }
+        Flipper.register(:staff) { |actor| true }
       end
 
       it 'ignores group' do
-        thing = Flipper::Actor.new('5')
         expect(subject.open?(context(Set[:newbs, :staff]))).to be(true)
       end
     end

data/spec/flipper/gates/percentage_of_actors_spec.rb

@@ -5,11 +5,11 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
     described_class.new
   end
 
-  def context(percentage_of_actors_value, feature = feature_name, thing = nil)
+  def context(percentage_of_actors_value, feature = feature_name, actors = nil)
     Flipper::FeatureCheckContext.new(
       feature_name: feature,
       values: Flipper::GateValues.new(percentage_of_actors: percentage_of_actors_value),
-      thing: Flipper::Types::Actor.new(thing || Flipper::Actor.new(1))
+      actors: Array(actors) || [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
     )
   end
 
@@ -20,7 +20,7 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
       let(:number_of_actors) { 10_000 }
 
       let(:actors) do
-        (1..number_of_actors).map { |n| Flipper::Actor.new(n) }
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new(n.to_s)) }
       end
 
       let(:feature_one_enabled_actors) do
@@ -48,13 +48,69 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
       end
     end
 
+    context "with an array of actors" do
+      let(:percentage) { 0.05 }
+      let(:percentage_as_integer) { percentage * 100 }
+      let(:number_of_actors) { 3_000 }
+
+      let(:user_actors) do
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new("User;#{n}")) }
+      end
+
+      let(:team_actors) do
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new("Team;#{n}")) }
+      end
+
+      let(:org_actors) do
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new("Org;#{n}")) }
+      end
+
+      let(:actors) { user_actors + team_actors + org_actors }
+
+      let(:feature_one_enabled_actors) do
+        actors.each_slice(3).select do |group|
+          context = context(percentage_as_integer, :name_one, group)
+          subject.open?(context)
+        end.flatten
+      end
+
+      let(:feature_two_enabled_actors) do
+        actors.each_slice(3).select do |group|
+          context = context(percentage_as_integer, :name_two, group)
+          subject.open?(context)
+        end.flatten
+      end
+
+      it 'does not enable both features for same set of actors' do
+        expect(feature_one_enabled_actors).not_to eq(feature_two_enabled_actors)
+      end
+
+      it 'enables feature for accurate number of actors for each feature' do
+        margin_of_error = 0.02 * actors.size # 2 percent margin of error
+        expected_enabled_size = actors.size * percentage
+
+        [
+          feature_one_enabled_actors.size,
+          feature_two_enabled_actors.size,
+        ].each do |size|
+          expect(size).to be_within(margin_of_error).of(expected_enabled_size)
+        end
+      end
+
+      it "is consistent regardless of order of actors" do
+        actors = user_actors.first(10)
+        results = 100.times.map { |n| subject.open?(context(75, :some_feature, actors.shuffle)) }
+        expect(results.uniq).to eq([true])
+      end
+    end
+
     context 'for fractional percentage' do
       let(:decimal) { 0.001 }
       let(:percentage) { decimal * 100 }
       let(:number_of_actors) { 10_000 }
 
       let(:actors) do
-        (1..number_of_actors).map { |n| Flipper::Actor.new(n) }
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new(n.to_s)) }
       end
 
       subject { described_class.new }
@@ -64,7 +120,7 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
         expected_open_count = number_of_actors * decimal
 
         open_count = actors.select do |actor|
-          context = context(percentage, :feature, actor)
+          context = context(percentage, :feature, [actor])
           subject.open?(context)
         end.size
 

data/spec/flipper/gates/percentage_of_time_spec.rb

@@ -5,11 +5,11 @@ RSpec.describe Flipper::Gates::PercentageOfTime do
     described_class.new
   end
 
-  def context(percentage_of_time_value, feature = feature_name, thing = nil)
+  def context(percentage_of_time_value, feature = feature_name, actors = nil)
     Flipper::FeatureCheckContext.new(
       feature_name: feature,
       values: Flipper::GateValues.new(percentage_of_time: percentage_of_time_value),
-      thing: thing || Flipper::Types::Actor.new(Flipper::Actor.new(1))
+      actors: Array(actors) || [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
     )
   end
 

data/spec/flipper/instrumentation/log_subscriber_spec.rb

@@ -18,8 +18,8 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
   end
 
   before do
-    Flipper.register(:admins) do |thing|
-      thing.respond_to?(:admin?) && thing.admin?
+    Flipper.register(:admins) do |actor|
+      actor.respond_to?(:admin?) && actor.admin?
     end
 
     @io = StringIO.new
@@ -46,7 +46,7 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
 
     it 'logs feature calls with result after operation' do
       feature_line = find_line('Flipper feature(search) enabled? false')
-      expect(feature_line).to include('[ thing=nil ]')
+      expect(feature_line).to include('[ actors=nil ]')
     end
 
     it 'logs adapter calls' do
@@ -56,7 +56,7 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
     end
   end
 
-  context 'feature enabled checks with a thing' do
+  context 'feature enabled checks with an actor' do
     let(:user) { Flipper::Types::Actor.new(Flipper::Actor.new('1')) }
 
     before do
@@ -64,7 +64,7 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
       flipper[:search].enabled?(user)
     end
 
-    it 'logs thing for feature' do
+    it 'logs actors for feature' do
       feature_line = find_line('Flipper feature(search) enabled?')
       expect(feature_line).to include(user.inspect)
     end

data/spec/flipper/types/actor_spec.rb

@@ -2,11 +2,11 @@ require 'flipper/types/actor'
 
 RSpec.describe Flipper::Types::Actor do
   subject do
-    thing = thing_class.new('2')
-    described_class.new(thing)
+    actor = actor_class.new('2')
+    described_class.new(actor)
   end
 
-  let(:thing_class) do
+  let(:actor_class) do
     Class.new do
       attr_reader :flipper_id
 
@@ -22,14 +22,14 @@ RSpec.describe Flipper::Types::Actor do
 
   describe '.wrappable?' do
     it 'returns true if actor' do
-      thing = thing_class.new('1')
-      actor = described_class.new(thing)
-      expect(described_class.wrappable?(actor)).to eq(true)
+      actor = actor_class.new('1')
+      actor_type_instance = described_class.new(actor)
+      expect(described_class.wrappable?(actor_type_instance)).to eq(true)
     end
 
     it 'returns true if responds to flipper_id' do
-      thing = thing_class.new(10)
-      expect(described_class.wrappable?(thing)).to eq(true)
+      actor = actor_class.new(10)
+      expect(described_class.wrappable?(actor)).to eq(true)
     end
 
     it 'returns false if nil' do
@@ -38,27 +38,27 @@ RSpec.describe Flipper::Types::Actor do
   end
 
   describe '.wrap' do
-    context 'for actor' do
-      it 'returns actor' do
-        actor = described_class.wrap(subject)
-        expect(actor).to be_instance_of(described_class)
-        expect(actor).to be(subject)
+    context 'for actor type instance' do
+      it 'returns actor type instance' do
+        actor_type_instance = described_class.wrap(subject)
+        expect(actor_type_instance).to be_instance_of(described_class)
+        expect(actor_type_instance).to be(subject)
       end
     end
 
-    context 'for other thing' do
-      it 'returns actor' do
-        thing = thing_class.new('1')
-        actor = described_class.wrap(thing)
-        expect(actor).to be_instance_of(described_class)
+    context 'for other object' do
+      it 'returns actor type instance' do
+        actor = actor_class.new('1')
+        actor_type_instance = described_class.wrap(actor)
+        expect(actor_type_instance).to be_instance_of(described_class)
       end
     end
   end
 
-  it 'initializes with thing that responds to id' do
-    thing = thing_class.new('1')
-    actor = described_class.new(thing)
-    expect(actor.value).to eq('1')
+  it 'initializes with object that responds to flipper_id' do
+    actor = actor_class.new('1')
+    actor_type_instance = described_class.new(actor)
+    expect(actor_type_instance.value).to eq('1')
   end
 
   it 'raises error when initialized with nil' do
@@ -68,48 +68,48 @@ RSpec.describe Flipper::Types::Actor do
   end
 
   it 'raises error when initalized with non-wrappable object' do
-    unwrappable_thing = Struct.new(:id).new(1)
+    unwrappable_object = Struct.new(:id).new(1)
     expect do
-      described_class.new(unwrappable_thing)
+      described_class.new(unwrappable_object)
     end.to raise_error(ArgumentError,
-                       "#{unwrappable_thing.inspect} must respond to flipper_id, but does not")
+                       "#{unwrappable_object.inspect} must respond to flipper_id, but does not")
   end
 
   it 'converts id to string' do
-    thing = thing_class.new(2)
-    actor = described_class.new(thing)
+    actor = actor_class.new(2)
+    actor = described_class.new(actor)
     expect(actor.value).to eq('2')
   end
 
-  it 'proxies everything to thing' do
-    thing = thing_class.new(10)
-    actor = described_class.new(thing)
+  it 'proxies everything to actor' do
+    actor = actor_class.new(10)
+    actor = described_class.new(actor)
     expect(actor.admin?).to eq(true)
   end
 
-  it 'exposes thing' do
-    thing = thing_class.new(10)
-    actor = described_class.new(thing)
-    expect(actor.thing).to be(thing)
+  it 'exposes actor' do
+    actor = actor_class.new(10)
+    actor_type_instance = described_class.new(actor)
+    expect(actor_type_instance.actor).to be(actor)
   end
 
   describe '#respond_to?' do
     it 'returns true if responds to method' do
-      thing = thing_class.new('1')
-      actor = described_class.new(thing)
-      expect(actor.respond_to?(:value)).to eq(true)
+      actor = actor_class.new('1')
+      actor_type_instance = described_class.new(actor)
+      expect(actor_type_instance.respond_to?(:value)).to eq(true)
     end
 
-    it 'returns true if thing responds to method' do
-      thing = thing_class.new(10)
-      actor = described_class.new(thing)
-      expect(actor.respond_to?(:admin?)).to eq(true)
+    it 'returns true if actor responds to method' do
+      actor = actor_class.new(10)
+      actor_type_instance = described_class.new(actor)
+      expect(actor_type_instance.respond_to?(:admin?)).to eq(true)
     end
 
-    it 'returns false if does not respond to method and thing does not respond to method' do
-      thing = thing_class.new(10)
-      actor = described_class.new(thing)
-      expect(actor.respond_to?(:frankenstein)).to eq(false)
+    it 'returns false if does not respond to method and actor does not respond to method' do
+      actor = actor_class.new(10)
+      actor_type_instance = described_class.new(actor)
+      expect(actor_type_instance.respond_to?(:frankenstein)).to eq(false)
     end
   end
 end

data/spec/flipper/types/group_spec.rb

@@ -90,7 +90,7 @@ RSpec.describe Flipper::Types::Group do
       context = Flipper::FeatureCheckContext.new(
         feature_name: :my_feature,
         values: Flipper::GateValues.new({}),
-        thing: Flipper::Types::Actor.new(Flipper::Actor.new(1))
+        actors: [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
       )
       group = Flipper.register(:group_with_context) { |actor| actor }
       yielded_actor = group.match?(admin_actor, context)
@@ -101,7 +101,7 @@ RSpec.describe Flipper::Types::Group do
       context = Flipper::FeatureCheckContext.new(
         feature_name: :my_feature,
         values: Flipper::GateValues.new({}),
-        thing: Flipper::Types::Actor.new(Flipper::Actor.new(1))
+        actors: [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
       )
       group = Flipper.register(:group_with_context) { |actor, context| [actor, context] }
       yielded_actor, yielded_context = group.match?(admin_actor, context)