flipper 0.26.2 → 0.28.3

data/spec/flipper/adapter_spec.rb

@@ -30,9 +30,9 @@ RSpec.describe Flipper::Adapter do
   end
 
   describe '#import' do
-    it 'returns nothing' do
+    it 'returns true' do
       result = destination_flipper.import(source_flipper)
-      expect(result).to be(nil)
+      expect(result).to be(true)
     end
 
     it 'can import from one adapter to another' do
@@ -114,5 +114,32 @@ RSpec.describe Flipper::Adapter do
       destination_flipper.import(source_flipper)
       expect(destination_flipper.features.map(&:key)).to eq([])
     end
+
+    it 'can import an export' do
+      source_flipper.enable(:search)
+      source_flipper.enable(:google_analytics, Flipper::Actor.new("User;1"))
+
+      destination_flipper.import(source_flipper.export)
+
+      feature = destination_flipper[:search]
+      expect(feature.boolean_value).to be(true)
+
+      feature = destination_flipper[:google_analytics]
+      expect(feature.actors_value).to eq(Set["User;1"])
+    end
+  end
+
+  describe "#export" do
+    it "exports features" do
+      source_flipper.enable(:search)
+      export = source_flipper.export
+      expect(export.features.dig("search", :boolean)).to eq("true")
+    end
+
+    it "exports with arguments" do
+      source_flipper.enable(:search)
+      export = source_flipper.export(format: :json, version: 1)
+      expect(export.features.dig("search", :boolean)).to eq("true")
+    end
   end
 end

data/spec/flipper/adapters/http_spec.rb

@@ -52,6 +52,28 @@ RSpec.describe Flipper::Adapters::Http do
       expect(flipper[:search].disable_group(:some_made_up_group)).to be(true)
       expect(flipper[:search].groups_value).to eq(Set.new)
     end
+
+    it "can import" do
+      adapter = Flipper::Adapters::Memory.new
+      source_flipper = Flipper.new(adapter)
+      source_flipper.enable_percentage_of_actors :search, 10
+      source_flipper.enable_percentage_of_time :search, 15
+      source_flipper.enable_actor :search, Flipper::Actor.new('User;1')
+      source_flipper.enable_actor :search, Flipper::Actor.new('User;100')
+      source_flipper.enable_group :search, :admins
+      source_flipper.enable_group :search, :employees
+      source_flipper.enable :plausible
+      source_flipper.disable :google_analytics
+
+      flipper = Flipper.new(subject)
+      flipper.import(source_flipper)
+      expect(flipper[:search].percentage_of_actors_value).to be(10)
+      expect(flipper[:search].percentage_of_time_value).to be(15)
+      expect(flipper[:search].actors_value).to eq(Set["User;1", "User;100"])
+      expect(flipper[:search].groups_value).to eq(Set["admins", "employees"])
+      expect(flipper[:plausible].boolean_value).to be(true)
+      expect(flipper[:google_analytics].boolean_value).to be(false)
+    end
   end
 
   it "sends default headers" do
@@ -82,7 +104,7 @@ RSpec.describe Flipper::Adapters::Http do
 
   describe "#get_multi" do
     it "raises error when not successful response" do
-      stub_request(:get, "http://app.com/flipper/features?keys=feature_panel")
+      stub_request(:get, "http://app.com/flipper/features?keys=feature_panel&exclude_gate_names=true")
         .to_return(status: 503, body: "", headers: {})
 
       adapter = described_class.new(url: 'http://app.com/flipper')
@@ -94,7 +116,7 @@ RSpec.describe Flipper::Adapters::Http do
 
   describe "#get_all" do
     it "raises error when not successful response" do
-      stub_request(:get, "http://app.com/flipper/features")
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
         .to_return(status: 503, body: "", headers: {})
 
       adapter = described_class.new(url: 'http://app.com/flipper')
@@ -106,7 +128,7 @@ RSpec.describe Flipper::Adapters::Http do
 
   describe "#features" do
     it "raises error when not successful response" do
-      stub_request(:get, "http://app.com/flipper/features")
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
         .to_return(status: 503, body: "", headers: {})
 
       adapter = described_class.new(url: 'http://app.com/flipper')

data/spec/flipper/adapters/instrumented_spec.rb

@@ -16,16 +16,6 @@ RSpec.describe Flipper::Adapters::Instrumented do
 
   it_should_behave_like 'a flipper adapter'
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    instrumented = described_class.new(adapter)
-    expect(instrumented.foo).to eq(:foo)
-  end
-
   describe '#name' do
     it 'is instrumented' do
       expect(subject.name).to be(:instrumented)
@@ -146,4 +136,32 @@ RSpec.describe Flipper::Adapters::Instrumented do
       expect(event.payload[:result]).to be(result)
     end
   end
+
+  describe '#import' do
+    it 'records instrumentation' do
+      result = subject.import(Flipper::Adapters::Memory.new)
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:import)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:result]).to be(result)
+    end
+  end
+
+  describe '#export' do
+    it 'records instrumentation' do
+      result = subject.export(format: :json, version: 1)
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:export)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:format]).to be(:json)
+      expect(event.payload[:version]).to be(1)
+      expect(event.payload[:result]).to be(result)
+    end
+  end
 end

data/spec/flipper/adapters/memoizable_spec.rb

@@ -11,16 +11,6 @@ RSpec.describe Flipper::Adapters::Memoizable do
 
   it_should_behave_like 'a flipper adapter'
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    memoizable = described_class.new(adapter)
-    expect(memoizable.foo).to eq(:foo)
-  end
-
   describe '#name' do
     it 'is instrumented' do
       expect(subject.name).to be(:memoizable)
@@ -249,6 +239,36 @@ RSpec.describe Flipper::Adapters::Memoizable do
     end
   end
 
+  describe "#import" do
+    context "with memoization enabled" do
+      before do
+        subject.memoize = true
+      end
+
+      it "unmemoizes features" do
+        cache[:foo] = "bar"
+        flipper[:stats].enable
+        flipper[:search].disable
+        subject.import(Flipper::Adapters::Memory.new)
+        expect(cache).to be_empty
+      end
+    end
+
+    context "with memoization disabled" do
+      before do
+        subject.memoize = false
+      end
+
+      it "does not unmemoize features" do
+        cache[:foo] = "bar"
+        flipper[:stats].enable
+        flipper[:search].disable
+        subject.import(Flipper::Adapters::Memory.new)
+        expect(cache).not_to be_empty
+      end
+    end
+  end
+
   describe '#features' do
     context 'with memoization enabled' do
       before do

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/adapters/operation_logger_spec.rb

@@ -18,16 +18,6 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     expect(output).to match(/@adapter=#<Flipper::Adapters::Memory/)
   end
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    operation_logger = described_class.new(adapter)
-    expect(operation_logger.foo).to eq(:foo)
-  end
-
   describe '#get' do
     before do
       @feature = flipper[:stats]
@@ -106,4 +96,33 @@ RSpec.describe Flipper::Adapters::OperationLogger do
       expect(@result).to eq(adapter.add(@feature))
     end
   end
+
+  describe '#import' do
+    before do
+      @source = Flipper::Adapters::Memory.new
+      @result = subject.import(@source)
+    end
+
+    it 'logs operation' do
+      expect(subject.count(:import)).to be(1)
+    end
+
+    it 'returns result' do
+      expect(@result).to eq(adapter.import(@source))
+    end
+  end
+
+  describe '#export' do
+    before do
+      @result = subject.export(format: :json, version: 1)
+    end
+
+    it 'logs operation' do
+      expect(subject.count(:export)).to be(1)
+    end
+
+    it 'returns result' do
+      expect(@result).to eq(adapter.export(format: :json, version: 1))
+    end
+  end
 end

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
 
@@ -342,10 +342,27 @@ RSpec.describe Flipper::DSL do
   end
 
   describe '#import' do
+    context "with flipper instance" do
+      it 'delegates to adapter' do
+        destination_flipper = build_flipper
+        expect(subject.adapter).to receive(:import).with(destination_flipper)
+        subject.import(destination_flipper)
+      end
+    end
+
+    context "with flipper adapter" do
+      it 'delegates to adapter' do
+        destination_flipper = build_flipper
+        expect(subject.adapter).to receive(:import).with(destination_flipper.adapter)
+        subject.import(destination_flipper.adapter)
+      end
+    end
+  end
+
+  describe "#export" do
     it 'delegates to adapter' do
-      destination_flipper = build_flipper
-      expect(subject.adapter).to receive(:import).with(destination_flipper.adapter)
-      subject.import(destination_flipper)
+      expect(subject.export).to eq(subject.adapter.export)
+      expect(subject.export(format: :json)).to eq(subject.adapter.export(format: :json))
     end
   end
 

data/spec/flipper/export_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Flipper::Export do
+  it "can initialize" do
+    export = described_class.new(contents: "{}", format: :json, version: 1)
+    expect(export.contents).to eq("{}")
+    expect(export.format).to eq(:json)
+    expect(export.version).to eq(1)
+  end
+
+  it "raises not implemented for features" do
+    export = described_class.new(contents: "{}", format: :json, version: 1)
+    expect { export.features }.to raise_error(NotImplementedError)
+  end
+end

data/spec/flipper/exporter_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Flipper::Exporter do
+  describe ".build" do
+    it "builds instance of exporter" do
+      exporter = described_class.build(format: :json, version: 1)
+      expect(exporter).to be_instance_of(Flipper::Exporters::Json::V1)
+    end
+
+    it "raises if format not found" do
+      expect { described_class.build(format: :nope, version: 1) }.to raise_error(KeyError)
+    end
+
+    it "raises if version not found" do
+      expect { described_class.build(format: :json, version: 0) }.to raise_error(KeyError)
+    end
+  end
+end

data/spec/flipper/exporters/json/export_spec.rb

@@ -0,0 +1,60 @@
+require 'flipper/exporters/json/v1'
+
+RSpec.describe Flipper::Exporters::Json::Export do
+  let(:contents) {
+    <<~JSON
+      {
+        "version":1,
+        "features":{
+          "search":{"boolean":null,"groups":["admins","employees"],"actors":["User;1","User;100"],"percentage_of_actors":"10","percentage_of_time":"15"},
+          "plausible":{"boolean":"true","groups":[],"actors":[],"percentage_of_actors":null,"percentage_of_time":null},
+          "google_analytics":{"boolean":null,"groups":[],"actors":[],"percentage_of_actors":null,"percentage_of_time":null}
+        }
+      }
+    JSON
+  }
+
+  it "can initialize" do
+    export = described_class.new(contents: contents)
+    expect(export.format).to eq(:json)
+    expect(export.version).to be(1)
+  end
+
+  it "can initialize with version" do
+    export = described_class.new(contents: contents, version: 1)
+    expect(export.version).to be(1)
+  end
+
+  it "can build features from contents" do
+    export = Flipper::Exporters::Json::Export.new(contents: contents)
+    expect(export.features).to eq({
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    })
+  end
+
+  it "can build an adapter from features" do
+    export = Flipper::Exporters::Json::Export.new(contents: contents)
+    expect(export.adapter).to be_instance_of(Flipper::Adapters::Memory)
+    expect(export.adapter.get_all).to eq({
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    })
+  end
+
+  it "raises for invalid json" do
+    export = described_class.new(contents: "bad contents")
+    expect {
+      export.features
+    }.to raise_error(Flipper::Exporters::Json::JsonError)
+  end
+
+  it "raises for missing features key" do
+    export = described_class.new(contents: "{}")
+    expect {
+      export.features
+    }.to raise_error(Flipper::Exporters::Json::InvalidError)
+  end
+end

data/spec/flipper/exporters/json/v1_spec.rb

@@ -0,0 +1,33 @@
+require 'flipper/exporters/json/v1'
+
+RSpec.describe Flipper::Exporters::Json::V1 do
+  subject { described_class.new }
+
+  it "has a version number" do
+    adapter = Flipper::Adapters::Memory.new
+    export = subject.call(adapter)
+    data = JSON.parse(export.contents)
+    expect(data["version"]).to eq(1)
+  end
+
+  it "exports features and gates" do
+    adapter = Flipper::Adapters::Memory.new
+    flipper = Flipper.new(adapter)
+    flipper.enable_percentage_of_actors :search, 10
+    flipper.enable_percentage_of_time :search, 15
+    flipper.enable_actor :search, Flipper::Actor.new('User;1')
+    flipper.enable_actor :search, Flipper::Actor.new('User;100')
+    flipper.enable_group :search, :admins
+    flipper.enable_group :search, :employees
+    flipper.enable :plausible
+    flipper.disable :google_analytics
+
+    export = subject.call(adapter)
+
+    expect(export.features).to eq({
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+    })
+  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