flipper 0.26.0 → 1.1.0

data/spec/flipper/adapter_builder_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Flipper::AdapterBuilder do
+  describe "#initialize" do
+    it "instance_eval's block with no arg" do
+      called = false
+      self_in_block = nil
+
+      described_class.new do
+        called = true
+        self_in_block = self
+      end
+
+      expect(self_in_block).to be_instance_of(described_class)
+      expect(called).to be(true)
+    end
+
+    it "evals block with arg" do
+      called = false
+      self_outside_block = self
+      self_in_block = nil
+
+      described_class.new do |arg|
+        called = true
+        self_in_block = self
+        expect(arg).to be_instance_of(described_class)
+      end
+
+      expect(self_in_block).to be(self_outside_block)
+      expect(called).to be(true)
+    end
+  end
+
+  describe "#use" do
+    it "wraps the store adapter with the given adapter" do
+      subject.use(Flipper::Adapters::Memoizable)
+      subject.use(Flipper::Adapters::Strict, :warn)
+
+      memoizable_adapter = subject.to_adapter
+      strict_adapter = memoizable_adapter.adapter
+      memory_adapter = strict_adapter.adapter
+
+
+      expect(memoizable_adapter).to be_instance_of(Flipper::Adapters::Memoizable)
+      expect(strict_adapter).to be_instance_of(Flipper::Adapters::Strict)
+      expect(strict_adapter.handler).to be(Flipper::Adapters::Strict::HANDLERS.fetch(:warn))
+      expect(memory_adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+
+    it "passes block to adapter initializer" do
+      expected_block = lambda {}
+      adapter_class = double('adapter class')
+
+      subject.use(adapter_class, &expected_block)
+
+      expect(adapter_class).to receive(:new) { |&block| expect(block).to be(expected_block) }.and_return(:adapter)
+      expect(subject.to_adapter).to be(:adapter)
+    end
+  end
+
+  describe "#store" do
+    it "defaults to memory adapter" do
+      expect(subject.to_adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+
+    it "only saves one store" do
+      require "flipper/adapters/pstore"
+      subject.store(Flipper::Adapters::PStore)
+      expect(subject.to_adapter).to be_instance_of(Flipper::Adapters::PStore)
+
+      subject.store(Flipper::Adapters::Memory)
+      expect(subject.to_adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+  end
+end

data/spec/flipper/adapter_spec.rb

@@ -6,6 +6,7 @@ RSpec.describe Flipper::Adapter do
       boolean: nil,
       groups: Set.new,
       actors: Set.new,
+      expression: nil,
       percentage_of_actors: nil,
       percentage_of_time: nil,
     }
@@ -30,9 +31,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 +115,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/dual_write_spec.rb

@@ -55,14 +55,14 @@ RSpec.describe Flipper::Adapters::DualWrite do
 
   it 'updates remote and local for #enable' do
     feature = sync[:search]
-    subject.enable feature, feature.gate(:boolean), local.boolean
+    subject.enable feature, feature.gate(:boolean), Flipper::Types::Boolean.new(true)
     expect(remote_adapter.count(:enable)).to be(1)
     expect(local_adapter.count(:enable)).to be(1)
   end
 
   it 'updates remote and local for #disable' do
     feature = sync[:search]
-    subject.disable feature, feature.gate(:boolean), local.boolean(false)
+    subject.disable feature, feature.gate(:boolean), Flipper::Types::Boolean.new(false)
     expect(remote_adapter.count(:disable)).to be(1)
     expect(local_adapter.count(:disable)).to be(1)
   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
@@ -62,16 +84,50 @@ RSpec.describe Flipper::Adapters::Http do
     }
     stub_request(:get, "http://app.com/flipper/features/feature_panel")
       .with(headers: headers)
-      .to_return(status: 404, body: "", headers: {})
+      .to_return(status: 404)
 
     adapter = described_class.new(url: 'http://app.com/flipper')
     adapter.get(flipper[:feature_panel])
   end
 
+  it "sends framework versions" do
+    stub_const("Rails", double(version: "7.1.0"))
+    stub_const("Sinatra::VERSION", "3.1.0")
+    stub_const("Hanami::VERSION", "0.7.2")
+
+    headers = {
+      "Client-Framework" => ["rails=7.1.0", "sinatra=3.1.0", "hanami=0.7.2"]
+    }
+
+    stub_request(:get, "http://app.com/flipper/features/feature_panel")
+      .with(headers: headers)
+      .to_return(status: 404)
+
+    adapter = described_class.new(url: 'http://app.com/flipper')
+    adapter.get(flipper[:feature_panel])
+  end
+
+  it "does not send undefined framework versions" do
+    stub_const("Rails", double(version: "7.1.0"))
+    stub_const("Sinatra::VERSION", "3.1.0")
+
+    headers = {
+      "Client-Framework" => ["rails=7.1.0", "sinatra=3.1.0"]
+    }
+
+    stub_request(:get, "http://app.com/flipper/features/feature_panel")
+      .with(headers: headers)
+      .to_return(status: 404)
+
+    adapter = described_class.new(url: 'http://app.com/flipper')
+    adapter.get(flipper[:feature_panel])
+  end
+
+
   describe "#get" do
     it "raises error when not successful response" do
       stub_request(:get, "http://app.com/flipper/features/feature_panel")
-        .to_return(status: 503, body: "", headers: {})
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {
@@ -82,8 +138,8 @@ 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")
-        .to_return(status: 503, body: "", headers: {})
+      stub_request(:get, "http://app.com/flipper/features?keys=feature_panel&exclude_gate_names=true")
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {
@@ -94,8 +150,8 @@ 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")
-        .to_return(status: 503, body: "", headers: {})
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {
@@ -106,8 +162,8 @@ 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")
-        .to_return(status: 503, body: "", headers: {})
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {

data/spec/flipper/adapters/instrumented_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Flipper::Adapters::Instrumented do
 
   let(:feature) { flipper[:stats] }
   let(:gate) { feature.gate(:percentage_of_actors) }
-  let(:thing) { flipper.actors(22) }
+  let(:thing) { Flipper::Types::PercentageOfActors.new(22) }
 
   subject do
     described_class.new(adapter, instrumenter: instrumenter)
@@ -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

@@ -2,7 +2,7 @@ require 'flipper/adapters/memoizable'
 require 'flipper/adapters/operation_logger'
 
 RSpec.describe Flipper::Adapters::Memoizable do
-  let(:features_key) { described_class::FeaturesKey }
+  let(:features_key) { :flipper_features }
   let(:adapter) { Flipper::Adapters::Memory.new }
   let(:flipper) { Flipper.new(adapter) }
   let(:cache)   { {} }
@@ -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)
@@ -64,7 +54,7 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'memoizes feature' do
         feature = flipper[:stats]
         result = subject.get(feature)
-        expect(cache[described_class.key_for(feature.key)]).to be(result)
+        expect(cache["feature/#{feature.key}"]).to be(result)
       end
     end
 
@@ -93,8 +83,8 @@ RSpec.describe Flipper::Adapters::Memoizable do
         features = names.map { |name| flipper[name] }
         results = subject.get_multi(features)
         features.each do |feature|
-          expect(cache[described_class.key_for(feature.key)]).not_to be(nil)
-          expect(cache[described_class.key_for(feature.key)]).to be(results[feature.key])
+          expect(cache["feature/#{feature.key}"]).not_to be(nil)
+          expect(cache["feature/#{feature.key}"]).to be(results[feature.key])
         end
       end
     end
@@ -125,10 +115,10 @@ RSpec.describe Flipper::Adapters::Memoizable do
         features = names.map { |name| flipper[name].tap(&:enable) }
         results = subject.get_all
         features.each do |feature|
-          expect(cache[described_class.key_for(feature.key)]).not_to be(nil)
-          expect(cache[described_class.key_for(feature.key)]).to be(results[feature.key])
+          expect(cache["feature/#{feature.key}"]).not_to be(nil)
+          expect(cache["feature/#{feature.key}"]).to be(results[feature.key])
         end
-        expect(cache[subject.class::FeaturesKey]).to eq(names.map(&:to_s).to_set)
+        expect(cache[:flipper_features]).to eq(names.map(&:to_s).to_set)
       end
 
       it 'only calls get_all once for memoized adapter' do
@@ -198,9 +188,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'unmemoizes feature' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
-        subject.enable(feature, gate, flipper.bool)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        cache["feature/#{feature.key}"] = { some: 'thing' }
+        subject.enable(feature, gate, Flipper::Types::Boolean.new)
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -212,8 +202,8 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'returns result' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        result = subject.enable(feature, gate, flipper.bool)
-        adapter_result = adapter.enable(feature, gate, flipper.bool)
+        result = subject.enable(feature, gate, Flipper::Types::Boolean.new)
+        adapter_result = adapter.enable(feature, gate, Flipper::Types::Boolean.new)
         expect(result).to eq(adapter_result)
       end
     end
@@ -228,9 +218,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'unmemoizes feature' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
-        subject.disable(feature, gate, flipper.bool)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        cache["feature/#{feature.key}"] = { some: 'thing' }
+        subject.disable(feature, gate, Flipper::Types::Boolean.new)
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -242,13 +232,43 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'returns result' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        result = subject.disable(feature, gate, flipper.bool)
-        adapter_result = adapter.disable(feature, gate, flipper.bool)
+        result = subject.disable(feature, gate, Flipper::Types::Boolean.new)
+        adapter_result = adapter.disable(feature, gate, Flipper::Types::Boolean.new)
         expect(result).to eq(adapter_result)
       end
     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
@@ -312,9 +332,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
 
       it 'unmemoizes the feature' do
         feature = flipper[:stats]
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
+        cache["feature/#{feature.key}"] = { some: 'thing' }
         subject.remove(feature)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -337,9 +357,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
 
       it 'unmemoizes feature' do
         feature = flipper[:stats]
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
+        cache["feature/#{feature.key}"] = { some: 'thing' }
         subject.clear(feature)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 

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)
@@ -14,7 +23,9 @@ RSpec.describe Flipper::Adapters::Memory do
     flipper.enable_actor :following, Flipper::Actor.new('3')
     flipper.enable_group :following, Flipper::Types::Group.new(:staff)
 
-    expect(source).to eq({
+    dup = described_class.new(subject.get_all)
+
+    expect(dup.get_all).to eq({
       "subscriptions" => subject.default_config.merge(boolean: "true"),
       "search" => subject.default_config,
       "logging" => subject.default_config.merge(:percentage_of_time => "30"),

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]
@@ -47,7 +37,7 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     before do
       @feature = flipper[:stats]
       @gate = @feature.gate(:boolean)
-      @thing = flipper.bool
+      @thing = Flipper::Types::Boolean.new
       @result = subject.enable(@feature, @gate, @thing)
     end
 
@@ -64,7 +54,7 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     before do
       @feature = flipper[:stats]
       @gate = @feature.gate(:boolean)
-      @thing = flipper.bool
+      @thing = Flipper::Types::Boolean.new
       @result = subject.disable(@feature, @gate, @thing)
     end
 
@@ -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/adapters/read_only_spec.rb

@@ -5,11 +5,12 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   let(:flipper) { Flipper.new(subject) }
   let(:feature) { flipper[:stats] }
 
-  let(:boolean_gate) { feature.gate(:boolean) }
-  let(:group_gate)   { feature.gate(:group) }
-  let(:actor_gate)   { feature.gate(:actor) }
-  let(:actors_gate)  { feature.gate(:percentage_of_actors) }
-  let(:time_gate)    { feature.gate(:percentage_of_time) }
+  let(:boolean_gate)    { feature.gate(:boolean) }
+  let(:group_gate)      { feature.gate(:group) }
+  let(:actor_gate)      { feature.gate(:actor) }
+  let(:expression_gate) { feature.gate(:expression) }
+  let(:actors_gate)     { feature.gate(:percentage_of_actors) }
+  let(:time_gate)       { feature.gate(:percentage_of_time) }
 
   subject { described_class.new(adapter) }
 
@@ -41,18 +42,28 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   end
 
   it 'can get feature' do
+    expression = Flipper.property(:plan).eq("basic")
     actor22 = Flipper::Actor.new('22')
-    adapter.enable(feature, boolean_gate, flipper.boolean)
+    adapter.enable(feature, boolean_gate, Flipper::Types::Boolean.new)
     adapter.enable(feature, group_gate, flipper.group(:admins))
-    adapter.enable(feature, actor_gate, flipper.actor(actor22))
-    adapter.enable(feature, actors_gate, flipper.actors(25))
-    adapter.enable(feature, time_gate, flipper.time(45))
-
-    expect(subject.get(feature)).to eq(boolean: 'true',
-                                       groups: Set['admins'],
-                                       actors: Set['22'],
-                                       percentage_of_actors: '25',
-                                       percentage_of_time: '45')
+    adapter.enable(feature, actor_gate, Flipper::Types::Actor.new(actor22))
+    adapter.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))
+    adapter.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(45))
+    adapter.enable(feature, expression_gate, expression)
+
+    expect(subject.get(feature)).to eq({
+      boolean: 'true',
+      groups: Set['admins'],
+      actors: Set['22'],
+      expression: {
+        "Equal" => [
+          {"Property" => ["plan"]},
+          "basic",
+        ]
+      },
+      percentage_of_actors: '25',
+      percentage_of_time: '45',
+    })
   end
 
   it 'can get features' do
@@ -61,6 +72,10 @@ RSpec.describe Flipper::Adapters::ReadOnly do
     expect(subject.features).to eq(Set['stats'])
   end
 
+  it 'is configured as read only' do
+    expect(subject.read_only?).to eq(true)
+  end
+
   it 'raises error on add' do
     expect { subject.add(feature) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
@@ -74,12 +89,12 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   end
 
   it 'raises error on enable' do
-    expect { subject.enable(feature, boolean_gate, flipper.boolean) }
+    expect { subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new) }
       .to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 
   it 'raises error on disable' do
-    expect { subject.disable(feature, boolean_gate, flipper.boolean) }
+    expect { subject.disable(feature, boolean_gate, Flipper::Types::Boolean.new) }
       .to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 end