flipper 1.3.6 → 1.4.1

data/spec/flipper/adapters/strict_spec.rb

@@ -21,6 +21,12 @@ RSpec.describe Flipper::Adapters::Strict do
           expect { subject.get_multi([feature]) }.to raise_error(Flipper::Adapters::Strict::NotFound)
         end
       end
+
+      context "#add" do
+        it "raises an error for unknown feature" do
+          expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
     end
   end
 
@@ -28,16 +34,22 @@ RSpec.describe Flipper::Adapters::Strict do
     subject { described_class.new(Flipper::Adapters::Memory.new, :warn) }
 
     context "#get" do
-      it "raises an error for unknown feature" do
+      it "warns 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
+      it "warns for unknown feature" do
         expect(capture_output { subject.get_multi([feature]) }).to match(/Could not find feature "unknown"/)
       end
     end
+
+    context "#add" do
+      it "warns for unknown feature" do
+        expect(capture_output { subject.add(feature) }).to match(/Could not find feature "unknown"/)
+      end
+    end
   end
 
   context "handler = Block" do
@@ -48,17 +60,63 @@ RSpec.describe Flipper::Adapters::Strict do
 
 
     context "#get" do
-      it "raises an error for unknown feature" do
+      it "calls block 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
+      it "calls block for unknown feature" do
         subject.get_multi([flipper[:foo], flipper[:bar]])
         expect(unknown_features).to eq(["foo", "bar"])
       end
     end
+
+    context "#add" do
+      it "calls block for unknown feature" do
+        subject.add(feature)
+        expect(unknown_features).to eq(["unknown"])
+      end
+    end
+  end
+
+  describe ".with_sync_mode" do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :raise) }
+
+    it "bypasses strict checks for add" do
+      described_class.with_sync_mode do
+        expect { subject.add(feature) }.not_to raise_error
+      end
+    end
+
+    it "bypasses strict checks for get" do
+      described_class.with_sync_mode do
+        expect { subject.get(feature) }.not_to raise_error
+      end
+    end
+
+    it "bypasses strict checks for get_multi" do
+      described_class.with_sync_mode do
+        expect { subject.get_multi([feature]) }.not_to raise_error
+      end
+    end
+
+    it "restores previous sync mode after block" do
+      described_class.with_sync_mode do
+        # inside sync mode
+      end
+      expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+    end
+
+    it "restores previous sync mode even on error" do
+      begin
+        described_class.with_sync_mode do
+          raise "boom"
+        end
+      rescue RuntimeError
+      end
+      expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+    end
   end
 end

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

@@ -105,6 +105,18 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
       expect_no_enable_or_disable
     end
 
+    it "updates expression when remote conditionally enabled but expression is nil" do
+      remote = Flipper::GateValues.new(expression: nil, actors: Set["1"])
+      feature.enable_expression(plan_expression)
+      feature.enable_actor(Flipper::Actor.new("1"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(nil)
+      expect_only_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/adapters/sync/synchronizer_spec.rb

@@ -1,4 +1,5 @@
 require "flipper/adapters/memory"
+require "flipper/adapters/actor_limit"
 require "flipper/instrumenters/memory"
 require "flipper/adapters/sync/synchronizer"
 
@@ -84,5 +85,91 @@ RSpec.describe Flipper::Adapters::Sync::Synchronizer do
 
       expect(local_flipper.features.map(&:key)).to eq([])
     end
+
+    it 'emits feature_operation.flipper events when syncing' do
+      remote_flipper.enable(:search)
+
+      subject.call
+
+      events = instrumenter.events_by_name("feature_operation.flipper")
+      enable_events = events.select { |e| e.payload[:operation] == :enable }
+      expect(enable_events).not_to be_empty
+
+      feature_names = enable_events.map { |e| e.payload[:feature_name].to_s }
+      expect(feature_names).to include("search")
+    end
+
+    it 'emits feature_operation.flipper events when adding features' do
+      remote_flipper.add(:new_feature)
+
+      subject.call
+
+      events = instrumenter.events_by_name("feature_operation.flipper")
+      add_events = events.select { |e| e.payload[:operation] == :add }
+      expect(add_events).not_to be_empty
+
+      feature_names = add_events.map { |e| e.payload[:feature_name].to_s }
+      expect(feature_names).to include("new_feature")
+    end
+
+    it 'emits feature_operation.flipper events when removing features' do
+      local_flipper.add(:old_feature)
+
+      subject.call
+
+      events = instrumenter.events_by_name("feature_operation.flipper")
+      remove_events = events.select { |e| e.payload[:operation] == :remove }
+      expect(remove_events).not_to be_empty
+
+      feature_names = remove_events.map { |e| e.payload[:feature_name].to_s }
+      expect(feature_names).to include("old_feature")
+    end
+  end
+
+  context 'with ActorLimit adapter wrapping local' do
+    let(:limit) { 10 }
+    let(:limited_local) { Flipper::Adapters::ActorLimit.new(local, limit) }
+    let(:limited_local_flipper) { Flipper.new(limited_local) }
+
+    subject { described_class.new(limited_local, remote, instrumenter: instrumenter) }
+
+    it 'syncs actors even when remote has more actors than local limit' do
+      # Remote has more actors than local limit allows
+      20.times { |i| remote_flipper[:search].enable_actor Flipper::Actor.new("User;#{i}") }
+
+      # This should NOT raise - sync should bypass actor limits
+      expect { subject.call }.not_to raise_error
+
+      # All actors should be synced
+      expect(limited_local_flipper[:search].actors_value.size).to eq(20)
+    end
+
+    it 'syncs new actors added to remote after initial sync' do
+      # Initial state: remote has 20 actors, local limit is 10
+      20.times { |i| remote_flipper[:search].enable_actor Flipper::Actor.new("User;#{i}") }
+
+      # First sync - should work despite exceeding limit
+      subject.call
+      expect(limited_local_flipper[:search].actors_value.size).to eq(20)
+
+      # Add a 21st actor to remote (simulating Cloud adding a new actor)
+      remote_flipper[:search].enable_actor Flipper::Actor.new("User;20")
+
+      # Sync again - should pick up the new actor
+      expect { subject.call }.not_to raise_error
+      expect(limited_local_flipper[:search].actors_value.size).to eq(21)
+      expect(limited_local_flipper[:search].actors_value).to include("User;20")
+    end
+
+    it 'still enforces limit for direct enable operations' do
+      # First sync 20 actors from remote
+      20.times { |i| remote_flipper[:search].enable_actor Flipper::Actor.new("User;#{i}") }
+      subject.call
+
+      # Direct enable should still fail because we're over limit
+      expect {
+        limited_local_flipper[:search].enable_actor Flipper::Actor.new("User;new")
+      }.to raise_error(Flipper::Adapters::ActorLimit::LimitExceeded)
+    end
   end
 end

data/spec/flipper/adapters/sync_spec.rb

@@ -197,4 +197,17 @@ RSpec.describe Flipper::Adapters::Sync do
     expect(remote_adapter).to receive(:get_all).and_raise(exception)
     expect { subject.get_all }.not_to raise_error
   end
+
+  describe '#adapter_stack' do
+    it 'returns the tree representation' do
+      expect(subject.adapter_stack).to eq("sync(local: operation_logger -> memory, remote: operation_logger -> memory)")
+    end
+
+    it 'shows nested adapters in the tree' do
+      memory = Flipper::Adapters::Memory.new
+      strict = Flipper::Adapters::Strict.new(Flipper::Adapters::Memory.new)
+      adapter = described_class.new(memory, strict, interval: 1)
+      expect(adapter.adapter_stack).to eq("sync(local: memory, remote: strict -> memory)")
+    end
+  end
 end

data/spec/flipper/cli_spec.rb

@@ -147,6 +147,57 @@ RSpec.describe Flipper::CLI do
     it { should have_attributes(status: 1, stderr: /invalid option: --nope/) }
   end
 
+  describe "export" do
+    before do
+      Flipper.enable :search
+      Flipper.disable :analytics
+    end
+
+    it "outputs valid JSON export" do
+      expect(subject).to have_attributes(status: 0)
+      data = JSON.parse(subject.stdout)
+      expect(data["version"]).to eq(1)
+      expect(data["features"]).to have_key("search")
+      expect(data["features"]).to have_key("analytics")
+    end
+  end
+
+  describe "cloud" do
+    it "shows help when no subcommand given" do
+      expect(subject).to have_attributes(status: 0, stdout: /migrate/)
+      expect(subject.stdout).to match(/push/)
+    end
+  end
+
+  describe "cloud migrate" do
+    before do
+      Flipper.enable :search
+      require 'flipper/cloud/migrate'
+      allow(Flipper::Cloud).to receive(:migrate).and_return(
+        Flipper::Cloud::MigrateResult.new(code: 200, url: "https://www.flippercloud.io/cloud/setup/abc123")
+      )
+      allow(cli).to receive(:system)
+    end
+
+    it "prints the cloud URL" do
+      expect(subject).to have_attributes(status: 0, stdout: /flippercloud\.io/)
+    end
+  end
+
+  describe "cloud push test-token" do
+    before do
+      Flipper.enable :search
+      require 'flipper/cloud/migrate'
+      allow(Flipper::Cloud).to receive(:push).and_return(
+        Flipper::Cloud::MigrateResult.new(code: 204, url: nil)
+      )
+    end
+
+    it "prints success message" do
+      expect(subject).to have_attributes(status: 0, stdout: /Successfully pushed/)
+    end
+  end
+
   describe "show foo" do
     context "boolean" do
       before { Flipper.enable :foo }

data/spec/flipper/cloud/configuration_spec.rb

@@ -135,6 +135,9 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "sets sync_method to :webhook if sync_secret provided" 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_secret: "secret",
     }))
@@ -144,6 +147,9 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "sets sync_method to :webhook if FLIPPER_CLOUD_SYNC_SECRET set" do
+    # The initial sync of http to local invokes this web request.
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
     ENV["FLIPPER_CLOUD_SYNC_SECRET"] = "abc"
     instance = described_class.new(required_options)
 

data/spec/flipper/cloud/dsl_spec.rb

@@ -5,6 +5,9 @@ require 'flipper/adapters/instrumented'
 
 RSpec.describe Flipper::Cloud::DSL do
   it 'delegates everything to flipper instance' do
+    # stub the initial sync of http to local
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
     cloud_configuration = Flipper::Cloud::Configuration.new({
       token: "asdf",
       sync_secret: "tasty",
@@ -27,10 +30,13 @@ RSpec.describe Flipper::Cloud::DSL do
     })
     dsl = described_class.new(cloud_configuration)
     dsl.sync
-    expect(stub).to have_been_requested
+    expect(stub).to have_been_requested.at_least_once
   end
 
   it 'delegates sync_secret to cloud configuration' do
+    # stub the initial sync of http to local
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
     cloud_configuration = Flipper::Cloud::Configuration.new({
       token: "asdf",
       sync_secret: "tasty",
@@ -53,13 +59,15 @@ RSpec.describe Flipper::Cloud::DSL do
     end
 
     subject do
+      # stub the initial sync of http to local
+      stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
       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(:features)).to be(2)
       expect(local_adapter.count(:get)).to be(1)
     end
 

data/spec/flipper/cloud/middleware_spec.rb

@@ -62,7 +62,7 @@ RSpec.describe Flipper::Cloud::Middleware do
           {"name" => "premium"},
         ],
       })
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
@@ -72,15 +72,17 @@ RSpec.describe Flipper::Cloud::Middleware do
       Flipper::Cloud::MessageVerifier.new(secret: "nope").generate(request_body, timestamp)
     }
 
-    it 'uses instance to sync' do
-      stub = stub_request_for_token('regular')
+    it 'does not perform webhook sync' do
+      webhook_regular_stub = stub_request_for_token('regular', from_webhook: true)
+      poll_regular_stub = stub_request_for_token('regular', from_webhook: false)
       env = {
         "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
       }
       post '/', request_body, env
 
       expect(last_response.status).to eq(400)
-      expect(stub).not_to have_been_requested
+      expect(poll_regular_stub).to have_been_requested.at_least_once
+      expect(webhook_regular_stub).not_to have_been_requested
     end
   end
 
@@ -103,7 +105,7 @@ RSpec.describe Flipper::Cloud::Middleware do
       expect(last_response.status).to eq(402)
       expect(last_response.headers["flipper-cloud-response-error-class"]).to eq("Flipper::Adapters::Http::Error")
       expect(last_response.headers["flipper-cloud-response-error-message"]).to include("Failed with status: 402")
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
@@ -126,7 +128,7 @@ RSpec.describe Flipper::Cloud::Middleware do
       expect(last_response.status).to eq(500)
       expect(last_response.headers["flipper-cloud-response-error-class"]).to eq("Flipper::Adapters::Http::Error")
       expect(last_response.headers["flipper-cloud-response-error-message"]).to include("Failed with status: 503")
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
@@ -149,7 +151,7 @@ RSpec.describe Flipper::Cloud::Middleware do
       expect(last_response.status).to eq(500)
       expect(last_response.headers["flipper-cloud-response-error-class"]).to eq("Net::OpenTimeout")
       expect(last_response.headers["flipper-cloud-response-error-message"]).to eq("execution expired")
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
@@ -160,7 +162,8 @@ RSpec.describe Flipper::Cloud::Middleware do
     }
 
     it 'uses env instance to sync' do
-      stub = stub_request_for_token('env')
+      regular_stub = stub_request_for_token('regular')
+      env_stub = stub_request_for_token('env')
       env = {
         "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
         'flipper' => env_flipper,
@@ -168,7 +171,8 @@ RSpec.describe Flipper::Cloud::Middleware do
       post '/', request_body, env
 
       expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
+      expect(regular_stub).to have_been_made.at_least_once
+      expect(env_stub).to have_been_made.at_least_once
     end
   end
 
@@ -187,7 +191,7 @@ RSpec.describe Flipper::Cloud::Middleware do
       post '/', request_body, env
 
       expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
@@ -198,7 +202,9 @@ RSpec.describe Flipper::Cloud::Middleware do
     }
 
     it 'uses provided env key instead of default' do
-      stub = stub_request_for_token('env')
+      regular_poll_stub = stub_request_for_token('regular')
+      env_poll_stub = stub_request_for_token('env')
+      env_webhook_stub = stub_request_for_token('env', from_webhook: true)
       env = {
         "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
         'flipper' => flipper,
@@ -207,7 +213,9 @@ RSpec.describe Flipper::Cloud::Middleware do
       post '/', request_body, env
 
       expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
+      expect(regular_poll_stub).to have_been_made.at_least_once
+      expect(env_poll_stub).to have_been_made.at_least_once
+      expect(env_webhook_stub).not_to have_been_requested
     end
   end
 
@@ -222,7 +230,7 @@ RSpec.describe Flipper::Cloud::Middleware do
       post '/', request_body, env
 
       expect(last_response.status).to eq(200)
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
@@ -252,12 +260,13 @@ RSpec.describe Flipper::Cloud::Middleware do
           {"name" => "premium"},
         ],
       })
-      expect(stub).to have_been_requested
+      expect(stub).to have_been_made.at_least_once
     end
   end
 
   describe 'Request method unsupported' do
     it 'skips middleware' do
+      stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
       get '/'
       expect(last_response.status).to eq(404)
       expect(last_response.content_type).to eq("application/json")
@@ -267,14 +276,23 @@ RSpec.describe Flipper::Cloud::Middleware do
 
   describe 'Inspecting the built Rack app' do
     it 'returns a String' do
+      stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
       expect(Flipper::Cloud.app(flipper).inspect).to eq("Flipper::Cloud")
     end
   end
 
   private
 
-  def stub_request_for_token(token, status: 200)
-    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+  def stub_request_for_token(token, status: 200, from_webhook: false)
+    if from_webhook
+      # Match URL with both exclude_gate_names=true and _cb=integer
+      url_pattern = %r{https://www\.flippercloud\.io/adapter/features\?.*exclude_gate_names=true.*&_cb=\d+}
+    else
+      # Match URL with just exclude_gate_names=true
+      url_pattern = %r{https://www\.flippercloud\.io/adapter/features\?.*exclude_gate_names=true}
+    end
+
+    stub = stub_request(:get, url_pattern).
       with({
         headers: {
           'flipper-cloud-token' => token,

data/spec/flipper/cloud/migrate_spec.rb

@@ -0,0 +1,160 @@
+require "flipper/cloud/migrate"
+require "flipper/typecast"
+require "webmock/rspec"
+
+RSpec.describe Flipper::Cloud, ".migrate" do
+  let(:flipper) { Flipper.new(Flipper::Adapters::Memory.new) }
+
+  before do
+    flipper.enable :search
+    flipper.disable :analytics
+    flipper.enable_percentage_of_actors :checkout, 50
+  end
+
+  around do |example|
+    original = ENV["FLIPPER_CLOUD_URL"]
+    ENV["FLIPPER_CLOUD_URL"] = "http://localhost:5555"
+    example.run
+  ensure
+    ENV["FLIPPER_CLOUD_URL"] = original
+  end
+
+  def decompress_request_body
+    raw = WebMock::RequestRegistry.instance.requested_signatures.hash.keys.last.body
+    JSON.parse(Flipper::Typecast.from_gzip(raw))
+  end
+
+  describe ".migrate" do
+    it "returns a MigrateResult with code and url on success" do
+      stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc123"}', headers: {"Content-Type" => "application/json"})
+
+      result = Flipper::Cloud.migrate(flipper)
+
+      expect(result).to be_a(Flipper::Cloud::MigrateResult)
+      expect(result.code).to eq(200)
+      expect(result.url).to eq("http://localhost:5555/cloud/setup/abc123")
+    end
+
+    it "sends export data and metadata in the request body" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc123"}')
+
+      Flipper::Cloud.migrate(flipper, app_name: "MyApp")
+
+      expect(stub).to have_been_requested
+      body = decompress_request_body
+      expect(body["metadata"]["app_name"]).to eq("MyApp")
+      expect(body["export"]["version"]).to eq(1)
+      expect(body["export"]["features"]).to have_key("search")
+    end
+
+    it "sends gzip-compressed request body" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .with(headers: {"content-encoding" => "gzip"})
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc"}')
+
+      Flipper::Cloud.migrate(flipper)
+
+      expect(stub).to have_been_requested
+      body = decompress_request_body
+      expect(body["export"]["features"]).to have_key("search")
+    end
+
+    it "handles error responses" do
+      stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 500, body: '{"error":"Internal Server Error"}')
+
+      result = Flipper::Cloud.migrate(flipper)
+
+      expect(result.code).to eq(500)
+      expect(result.url).to be_nil
+    end
+
+    it "includes error message from response body" do
+      stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 422, body: '{"error":"Invalid export format"}')
+
+      result = Flipper::Cloud.migrate(flipper)
+
+      expect(result.code).to eq(422)
+      expect(result.message).to eq("Invalid export format")
+    end
+
+    it "uses FLIPPER_CLOUD_URL environment variable" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc"}')
+
+      Flipper::Cloud.migrate(flipper)
+
+      expect(stub).to have_been_requested
+    end
+
+    it "sends content-type and accept headers" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .with(headers: {
+          "content-type" => "application/json",
+          "accept" => "application/json",
+        })
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc"}')
+
+      Flipper::Cloud.migrate(flipper)
+
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe ".push" do
+    it "returns a MigrateResult with code on success" do
+      stub_request(:post, "http://localhost:5555/adapter/import")
+        .to_return(status: 204, body: "")
+
+      result = Flipper::Cloud.push("test-token", flipper)
+
+      expect(result).to be_a(Flipper::Cloud::MigrateResult)
+      expect(result.code).to eq(204)
+    end
+
+    it "sends the token as a header" do
+      stub = stub_request(:post, "http://localhost:5555/adapter/import")
+        .with(headers: {"flipper-cloud-token" => "test-token"})
+        .to_return(status: 204, body: "")
+
+      Flipper::Cloud.push("test-token", flipper)
+
+      expect(stub).to have_been_requested
+    end
+
+    it "sends gzip-compressed export contents as the body" do
+      stub = stub_request(:post, "http://localhost:5555/adapter/import")
+        .with(headers: {"content-encoding" => "gzip"})
+        .to_return(status: 204, body: "")
+
+      Flipper::Cloud.push("test-token", flipper)
+
+      expect(stub).to have_been_requested
+      body = decompress_request_body
+      expect(body["version"]).to eq(1)
+      expect(body["features"]).to have_key("search")
+    end
+
+    it "handles error responses" do
+      stub_request(:post, "http://localhost:5555/adapter/import")
+        .to_return(status: 401, body: '{"error":"Unauthorized"}')
+
+      result = Flipper::Cloud.push("bad-token", flipper)
+
+      expect(result.code).to eq(401)
+    end
+
+    it "includes error message from response body" do
+      stub_request(:post, "http://localhost:5555/adapter/import")
+        .to_return(status: 401, body: '{"error":"Invalid token"}')
+
+      result = Flipper::Cloud.push("bad-token", flipper)
+
+      expect(result.code).to eq(401)
+      expect(result.message).to eq("Invalid token")
+    end
+  end
+end

data/spec/flipper/cloud/telemetry_spec.rb

@@ -122,7 +122,7 @@ RSpec.describe Flipper::Cloud::Telemetry do
     # Check the conig interval and the timer interval.
     expect(telemetry.interval).to eq(120)
     expect(telemetry.timer.execution_interval).to eq(120)
-    expect(stub).to have_been_requested.times(5)
+    expect(stub).to have_been_requested.at_least_times(5)
   end
 
   it "doesn't try to update telemetry interval from error if not response error" do