flipper 0.26.0 → 1.3.6

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

data/spec/flipper/adapters/strict_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Flipper::Adapters::Strict do
+  let(:flipper) { Flipper.new(subject) }
+  let(:feature) { flipper[:unknown] }
+
+  it_should_behave_like 'a flipper adapter' do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :noop) }
+  end
+
+  [true, :raise].each do |handler|
+    context "handler = #{handler}" do
+      subject { described_class.new(Flipper::Adapters::Memory.new, handler) }
+
+      context "#get" do
+        it "raises an error for unknown feature" do
+          expect { subject.get(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
+
+      context "#get_multi" do
+        it "raises an error for unknown feature" do
+          expect { subject.get_multi([feature]) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
+    end
+  end
+
+  context "handler = :warn" do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :warn) }
+
+    context "#get" do
+      it "raises an error for unknown feature" do
+        expect(capture_output { subject.get(feature) }).to match(/Could not find feature "unknown"/)
+      end
+    end
+
+    context "#get_multi" do
+      it "raises an error for unknown feature" do
+        expect(capture_output { subject.get_multi([feature]) }).to match(/Could not find feature "unknown"/)
+      end
+    end
+  end
+
+  context "handler = Block" do
+    let(:unknown_features) { [] }
+    subject do
+      described_class.new(Flipper::Adapters::Memory.new) { |feature| unknown_features << feature.key}
+    end
+
+
+    context "#get" do
+      it "raises an error for unknown feature" do
+        subject.get(feature)
+        expect(unknown_features).to eq(["unknown"])
+      end
+    end
+
+    context "#get_multi" do
+      it "raises an error for unknown feature" do
+        subject.get_multi([flipper[:foo], flipper[:bar]])
+        expect(unknown_features).to eq(["foo", "bar"])
+      end
+    end
+  end
+end

data/spec/flipper/adapters/sync/feature_synchronizer_spec.rb

@@ -8,6 +8,8 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
   end
   let(:flipper) { Flipper.new(adapter) }
   let(:feature) { flipper[:search] }
+  let(:plan_expression) { Flipper.property(:plan).eq("basic") }
+  let(:age_expression) { Flipper.property(:age).gte(21) }
 
   context "when remote disabled" do
     let(:remote) { Flipper::GateValues.new({}) }
@@ -63,6 +65,7 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
         boolean: nil,
         actors: Set["1"],
         groups: Set["staff"],
+        expression: plan_expression.value,
         percentage_of_time: 10,
         percentage_of_actors: 15,
       }
@@ -74,10 +77,34 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
       expect(local_gate_values_hash.fetch(:boolean)).to be(nil)
       expect(local_gate_values_hash.fetch(:actors)).to eq(Set["1"])
       expect(local_gate_values_hash.fetch(:groups)).to eq(Set["staff"])
+      expect(local_gate_values_hash.fetch(:expression)).to eq(plan_expression.value)
       expect(local_gate_values_hash.fetch(:percentage_of_time)).to eq("10")
       expect(local_gate_values_hash.fetch(:percentage_of_actors)).to eq("15")
     end
 
+    it "updates expression when remote is updated" do
+      any_expression = Flipper.any(plan_expression, age_expression)
+      remote = Flipper::GateValues.new(expression: any_expression.value)
+      feature.enable_expression(age_expression)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(any_expression.value)
+      expect_only_enable
+    end
+
+    it "does nothing to expression if in sync" do
+      remote = Flipper::GateValues.new(expression: plan_expression.value)
+      feature.enable_expression(plan_expression)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(plan_expression.value)
+      expect_no_enable_or_disable
+    end
+
     it "adds remotely added actors" do
       remote = Flipper::GateValues.new(actors: Set["1", "2"])
       feature.enable_actor(Flipper::Actor.new("1"))

data/spec/flipper/cli_spec.rb

@@ -0,0 +1,166 @@
+require "flipper/cli"
+
+RSpec.describe Flipper::CLI do
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:cli) { Flipper::CLI.new(stdout: stdout, stderr: stderr) }
+
+  Result = Struct.new(:status, :stdout, :stderr, keyword_init: true)
+
+  before do
+    # Prentend stdout/stderr a TTY to test colorization
+    allow(stdout).to receive(:tty?).and_return(true)
+    allow(stderr).to receive(:tty?).and_return(true)
+  end
+
+  # Infer the command from the description
+  let(:argv) do
+    descriptions = self.class.parent_groups.map {|g| g.metadata[:description_args] }.reverse.flatten.drop(1)
+    descriptions.map { |arg| Shellwords.split(arg) }.flatten
+  end
+
+  subject do
+    status = 0
+
+    begin
+      cli.run(argv)
+    rescue SystemExit => e
+      status = e.status
+    end
+
+    Result.new(status: status, stdout: stdout.string, stderr: stderr.string)
+  end
+
+  before do
+    ENV["FLIPPER_REQUIRE"] = "./spec/fixtures/environment"
+  end
+
+  describe "enable" do
+    describe "feature" do
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*\e\[32m.*enabled/)
+        expect(Flipper).to be_enabled(:feature)
+      end
+    end
+
+    describe "-a User;1 feature" do
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*\e\[33m.*enabled.*User;1/m)
+        expect(Flipper).to be_enabled(:feature, Flipper::Actor.new("User;1"))
+      end
+    end
+
+    describe "feature -g admins" do
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*enabled.*admins/m)
+        expect(Flipper.feature('feature').enabled_groups.map(&:name)).to eq([:admins])
+      end
+    end
+
+    describe "feature -p 30" do
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*enabled.*30% of actors/m)
+        expect(Flipper.feature('feature').percentage_of_actors_value).to eq(30)
+      end
+    end
+
+    describe "feature -t 50" do
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*enabled.*50% of time/m)
+        expect(Flipper.feature('feature').percentage_of_time_value).to eq(50)
+      end
+    end
+
+    describe %|feature -x '{"Equal":[{"Property":"flipper_id"},"User;1"]}'| do
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*enabled.*User;1/m)
+        expect(Flipper.feature('feature').expression.value).to eq({ "Equal" => [ { "Property" => ["flipper_id"] }, "User;1" ] })
+      end
+    end
+
+    describe %|feature -x invalid_json| do
+      it do
+        expect(subject).to have_attributes(status: 1, stderr: /JSON parse error/m)
+      end
+    end
+
+    describe %|feature -x '{}'| do
+      it do
+        expect(subject).to have_attributes(status: 1, stderr: /Invalid expression/m)
+      end
+    end
+  end
+
+  describe "disable" do
+    describe "feature" do
+      before { Flipper.enable :feature }
+
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*disabled/)
+        expect(Flipper).not_to be_enabled(:feature)
+      end
+    end
+
+    describe "feature -g admins" do
+      before { Flipper.enable_group(:feature, :admins) }
+
+      it do
+        expect(subject).to have_attributes(status: 0, stdout: /feature.*disabled/)
+        expect(Flipper.feature('feature').enabled_groups).to be_empty
+      end
+    end
+  end
+
+  describe "list" do
+    before do
+      Flipper.enable :foo
+      Flipper.disable :bar
+    end
+
+    it "lists features" do
+      expect(subject).to have_attributes(status: 0, stdout: /foo.*enabled/)
+      expect(subject).to have_attributes(status: 0, stdout: /bar.*disabled/)
+    end
+  end
+
+  ["-h", "--help", "help"].each do |arg|
+    describe arg do
+      it { should have_attributes(status: 0, stdout: /Usage: flipper/) }
+
+      it "should list subcommands" do
+        %w(enable disable list).each do |subcommand|
+          expect(subject.stdout).to match(/#{subcommand}/)
+        end
+      end
+    end
+  end
+
+  describe "help enable" do
+    it { should have_attributes(status: 0, stdout: /Usage: flipper enable \[options\] <feature>/) }
+  end
+
+  describe "nope" do
+    it { should have_attributes(status: 1, stderr: /Unknown command: nope/) }
+  end
+
+  describe "--nope" do
+    it { should have_attributes(status: 1, stderr: /invalid option: --nope/) }
+  end
+
+  describe "show foo" do
+    context "boolean" do
+      before { Flipper.enable :foo }
+      it { should have_attributes(status: 0, stdout: /foo.*enabled/) }
+    end
+
+    context "actors" do
+      before { Flipper.enable_actor :foo, Flipper::Actor.new("User;1") }
+      it { should have_attributes(status: 0, stdout: /User;1/) }
+    end
+
+    context "groups" do
+      before { Flipper.enable_group :foo, :admins }
+      it { should have_attributes(status: 0, stdout: /enabled.*admins/m) }
+    end
+  end
+end

data/spec/flipper/cloud/configuration_spec.rb

@@ -0,0 +1,251 @@
+require 'flipper/cloud/configuration'
+require 'flipper/adapters/instrumented'
+
+RSpec.describe Flipper::Cloud::Configuration do
+  let(:required_options) do
+    { token: "asdf" }
+  end
+
+  it "can set token" do
+    instance = described_class.new(required_options)
+    expect(instance.token).to eq(required_options[:token])
+  end
+
+  it "can set token from ENV var" do
+    ENV["FLIPPER_CLOUD_TOKEN"] = "from_env"
+    instance = described_class.new(required_options.reject { |k, v| k == :token })
+    expect(instance.token).to eq("from_env")
+  end
+
+  it "can set instrumenter" do
+    instrumenter = Object.new
+    instance = described_class.new(required_options.merge(instrumenter: instrumenter))
+    expect(instance.instrumenter).to be_a(Flipper::Cloud::Telemetry::Instrumenter)
+    expect(instance.instrumenter.instrumenter).to be(instrumenter)
+  end
+
+  it "can set read_timeout" do
+    instance = described_class.new(required_options.merge(read_timeout: 5))
+    expect(instance.read_timeout).to eq(5)
+  end
+
+  it "can set read_timeout from ENV var" do
+    ENV["FLIPPER_CLOUD_READ_TIMEOUT"] = "9"
+    instance = described_class.new(required_options.reject { |k, v| k == :read_timeout })
+    expect(instance.read_timeout).to eq(9)
+  end
+
+  it "can set open_timeout" do
+    instance = described_class.new(required_options.merge(open_timeout: 5))
+    expect(instance.open_timeout).to eq(5)
+  end
+
+  it "can set open_timeout from ENV var" do
+    ENV["FLIPPER_CLOUD_OPEN_TIMEOUT"] = "9"
+    instance = described_class.new(required_options.reject { |k, v| k == :open_timeout })
+    expect(instance.open_timeout).to eq(9)
+  end
+
+  it "can set write_timeout" do
+    instance = described_class.new(required_options.merge(write_timeout: 5))
+    expect(instance.write_timeout).to eq(5)
+  end
+
+  it "can set write_timeout from ENV var" do
+    ENV["FLIPPER_CLOUD_WRITE_TIMEOUT"] = "9"
+    instance = described_class.new(required_options.reject { |k, v| k == :write_timeout })
+    expect(instance.write_timeout).to eq(9)
+  end
+
+  it "can set sync_interval" do
+    instance = described_class.new(required_options.merge(sync_interval: 15))
+    expect(instance.sync_interval).to eq(15)
+  end
+
+  it "can set sync_interval from ENV var" do
+    ENV["FLIPPER_CLOUD_SYNC_INTERVAL"] = "15"
+    instance = described_class.new(required_options.reject { |k, v| k == :sync_interval })
+    expect(instance.sync_interval).to eq(15)
+  end
+
+  it "passes sync_interval into sync adapter" do
+    # The initial sync of http to local invokes this web request.
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
+    instance = described_class.new(required_options.merge(sync_interval: 20))
+    poller = instance.send(:poller)
+    expect(poller.interval).to eq(20)
+  end
+
+  it "can set debug_output" do
+    instance = described_class.new(required_options.merge(debug_output: STDOUT))
+    expect(instance.debug_output).to eq(STDOUT)
+  end
+
+  it "defaults debug_output to STDOUT if FLIPPER_CLOUD_DEBUG_OUTPUT_STDOUT set to true" do
+    ENV["FLIPPER_CLOUD_DEBUG_OUTPUT_STDOUT"] = "true"
+    instance = described_class.new(required_options)
+    expect(instance.debug_output).to eq(STDOUT)
+  end
+
+  it "defaults adapter block" do
+    # The initial sync of http to local invokes this web request.
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
+    instance = described_class.new(required_options)
+    expect(instance.adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+  end
+
+  it "can override adapter block" do
+    # The initial sync of http to local invokes this web request.
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
+    instance = described_class.new(required_options)
+    instance.adapter do |adapter|
+      Flipper::Adapters::Instrumented.new(adapter)
+    end
+    expect(instance.adapter).to be_instance_of(Flipper::Adapters::Instrumented)
+  end
+
+  it "defaults url" do
+    instance = described_class.new(required_options.reject { |k, v| k == :url })
+    expect(instance.url).to eq("https://www.flippercloud.io/adapter")
+  end
+
+  it "can override url using options" do
+    options = required_options.merge(url: "http://localhost:5000/adapter")
+    instance = described_class.new(options)
+    expect(instance.url).to eq("http://localhost:5000/adapter")
+
+    instance = described_class.new(required_options)
+    instance.url = "http://localhost:5000/adapter"
+    expect(instance.url).to eq("http://localhost:5000/adapter")
+  end
+
+  it "can override URL using ENV var" do
+    ENV["FLIPPER_CLOUD_URL"] = "https://example.com"
+    instance = described_class.new(required_options.reject { |k, v| k == :url })
+    expect(instance.url).to eq("https://example.com")
+  end
+
+  it "defaults sync_method to :poll" do
+    instance = described_class.new(required_options)
+
+    expect(instance.sync_method).to eq(:poll)
+  end
+
+  it "sets sync_method to :webhook if sync_secret provided" do
+    instance = described_class.new(required_options.merge({
+      sync_secret: "secret",
+    }))
+
+    expect(instance.sync_method).to eq(:webhook)
+    expect(instance.adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+  end
+
+  it "sets sync_method to :webhook if FLIPPER_CLOUD_SYNC_SECRET set" do
+    ENV["FLIPPER_CLOUD_SYNC_SECRET"] = "abc"
+    instance = described_class.new(required_options)
+
+    expect(instance.sync_method).to eq(:webhook)
+    expect(instance.adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+  end
+
+  it "can set sync_secret" do
+    instance = described_class.new(required_options.merge(sync_secret: "from_config"))
+      expect(instance.sync_secret).to eq("from_config")
+  end
+
+  it "can override sync_secret using ENV var" do
+    ENV["FLIPPER_CLOUD_SYNC_SECRET"] = "from_env"
+    instance = described_class.new(required_options.reject { |k, v| k == :sync_secret })
+    expect(instance.sync_secret).to eq("from_env")
+  end
+
+  it "can sync with cloud" do
+    body = JSON.generate({
+      "features": [
+        {
+          "key": "search",
+          "state": "on",
+          "gates": [
+            {
+              "key": "boolean",
+              "name": "boolean",
+              "value": true
+            },
+            {
+              "key": "groups",
+              "name": "group",
+              "value": []
+            },
+            {
+              "key": "actors",
+              "name": "actor",
+              "value": []
+            },
+            {
+              "key": "percentage_of_actors",
+              "name": "percentage_of_actors",
+              "value": 0
+            },
+            {
+              "key": "percentage_of_time",
+              "name": "percentage_of_time",
+              "value": 0
+            }
+          ]
+        },
+        {
+          "key": "history",
+          "state": "off",
+          "gates": [
+            {
+              "key": "boolean",
+              "name": "boolean",
+              "value": false
+            },
+            {
+              "key": "groups",
+              "name": "group",
+              "value": []
+            },
+            {
+              "key": "actors",
+              "name": "actor",
+              "value": []
+            },
+            {
+              "key": "percentage_of_actors",
+              "name": "percentage_of_actors",
+              "value": 0
+            },
+            {
+              "key": "percentage_of_time",
+              "name": "percentage_of_time",
+              "value": 0
+            }
+          ]
+        }
+      ]
+    })
+    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+      with({
+        headers: {
+          'flipper-cloud-token'=>'asdf',
+        },
+      }).to_return(status: 200, body: body)
+    instance = described_class.new(required_options)
+    instance.sync
+
+    # Check that remote was fetched.
+    expect(stub).to have_been_requested
+
+    # Check that local adapter really did sync.
+    local_adapter = instance.local_adapter
+    all = local_adapter.get_all
+    expect(all.keys).to eq(["search", "history"])
+    expect(all["search"][:boolean]).to eq("true")
+    expect(all["history"][:boolean]).to eq(nil)
+  end
+end

data/spec/flipper/cloud/dsl_spec.rb

@@ -0,0 +1,82 @@
+require 'flipper/cloud/configuration'
+require 'flipper/cloud/dsl'
+require 'flipper/adapters/operation_logger'
+require 'flipper/adapters/instrumented'
+
+RSpec.describe Flipper::Cloud::DSL do
+  it 'delegates everything to flipper instance' do
+    cloud_configuration = Flipper::Cloud::Configuration.new({
+      token: "asdf",
+      sync_secret: "tasty",
+    })
+    dsl = described_class.new(cloud_configuration)
+    expect(dsl.features).to eq(Set.new)
+    expect(dsl.enabled?(:foo)).to be(false)
+  end
+
+  it 'delegates sync to cloud configuration' do
+    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+      with({
+        headers: {
+          'flipper-cloud-token'=>'asdf',
+        },
+      }).to_return(status: 200, body: '{"features": {}}', headers: {})
+    cloud_configuration = Flipper::Cloud::Configuration.new({
+      token: "asdf",
+      sync_secret: "tasty",
+    })
+    dsl = described_class.new(cloud_configuration)
+    dsl.sync
+    expect(stub).to have_been_requested
+  end
+
+  it 'delegates sync_secret to cloud configuration' do
+    cloud_configuration = Flipper::Cloud::Configuration.new({
+      token: "asdf",
+      sync_secret: "tasty",
+    })
+    dsl = described_class.new(cloud_configuration)
+    expect(dsl.sync_secret).to eq("tasty")
+  end
+
+  context "when sync_method is webhook" do
+    let(:local_adapter) do
+      Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+    end
+
+    let(:cloud_configuration) do
+      Flipper::Cloud::Configuration.new({
+        token: "asdf",
+        sync_secret: "tasty",
+        local_adapter: local_adapter
+      })
+    end
+
+    subject do
+      described_class.new(cloud_configuration)
+    end
+
+    it "sends reads to local adapter" do
+      subject.features
+      subject.enabled?(:foo)
+      expect(local_adapter.count(:features)).to be(1)
+      expect(local_adapter.count(:get)).to be(1)
+    end
+
+    it "sends writes to cloud and local" do
+      add_stub = stub_request(:post, "https://www.flippercloud.io/adapter/features").
+        with({headers: {'flipper-cloud-token'=>'asdf'}}).
+        to_return(status: 200, body: '{}')
+      enable_stub = stub_request(:post, "https://www.flippercloud.io/adapter/features/foo/boolean").
+        with(headers: {'flipper-cloud-token'=>'asdf'}).
+        to_return(status: 200, body: '{}')
+
+      subject.enable(:foo)
+
+      expect(local_adapter.count(:add)).to be(1)
+      expect(local_adapter.count(:enable)).to be(1)
+      expect(add_stub).to have_been_requested
+      expect(enable_stub).to have_been_requested
+    end
+  end
+end