flipper 0.28.3 → 1.4.2

data/spec/flipper/cloud/middleware_spec.rb

@@ -0,0 +1,289 @@
+require 'securerandom'
+require 'flipper/cloud'
+require 'flipper/cloud/middleware'
+require 'flipper/adapters/operation_logger'
+
+RSpec.describe Flipper::Cloud::Middleware do
+  let(:flipper) {
+    Flipper::Cloud.new(token: "regular") do |config|
+      config.local_adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
+      config.sync_secret = "regular_tasty"
+    end
+  }
+
+  let(:env_flipper) {
+    Flipper::Cloud.new(token: "env") do |config|
+      config.local_adapter = Flipper::Adapters::OperationLogger.new(Flipper::Adapters::Memory.new)
+      config.sync_secret = "env_tasty"
+    end
+  }
+
+  let(:app) { Flipper::Cloud.app(flipper) }
+  let(:response_body) { JSON.generate({features: {}}) }
+  let(:request_body) {
+    JSON.generate({
+      "environment_id" => 1,
+      "webhook_id" => 1,
+      "delivery_id" => SecureRandom.uuid,
+      "action" => "sync",
+    })
+  }
+  let(:timestamp) { Time.now }
+  let(:signature) {
+    Flipper::Cloud::MessageVerifier.new(secret: flipper.sync_secret).generate(request_body, timestamp)
+  }
+  let(:signature_header_value) {
+    Flipper::Cloud::MessageVerifier.new(secret: "").header(signature, timestamp)
+  }
+
+  context 'when initializing middleware with flipper instance' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it 'uses instance to sync' do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq({
+        "groups" => [
+          {"name" => "admins"},
+          {"name" => "staff"},
+          {"name" => "basic"},
+          {"name" => "plus"},
+          {"name" => "premium"},
+        ],
+      })
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when signature is invalid' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: "nope").generate(request_body, timestamp)
+    }
+
+    it 'uses instance to sync' do
+      stub = stub_request_for_token('regular')
+      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
+    end
+  end
+
+  context "when flipper cloud responds with 402" do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it "results in 402" do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular', status: 402)
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      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
+    end
+  end
+
+  context "when flipper cloud responds with non-402 and non-2xx code" do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it "results in 500" do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular', status: 503)
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      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
+    end
+  end
+
+  context "when flipper cloud responds with timeout" do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it "results in 500" do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular', status: :timeout)
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      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
+    end
+  end
+
+  context 'when initialized with flipper instance and flipper instance in env' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
+    }
+
+    it 'uses env instance to sync' do
+      stub = stub_request_for_token('env')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+        'flipper' => env_flipper,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initialized without flipper instance but flipper instance in env' do
+    let(:app) { Flipper::Cloud.app }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
+    }
+
+    it 'uses env instance to sync' do
+      stub = stub_request_for_token('env')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+        'flipper' => env_flipper,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initialized with env_key' do
+    let(:app) { Flipper::Cloud.app(flipper, env_key: 'flipper_cloud') }
+    let(:signature) {
+      Flipper::Cloud::MessageVerifier.new(secret: env_flipper.sync_secret).generate(request_body, timestamp)
+    }
+
+    it 'uses provided env key instead of default' do
+      stub = stub_request_for_token('env')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+        'flipper' => flipper,
+        'flipper_cloud' => env_flipper,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when initializing lazily with a block' do
+    let(:app) { Flipper::Cloud.app(-> { flipper }) }
+
+    it 'works' do
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when using older /webhooks path' do
+    let(:app) { Flipper::Cloud.app(flipper) }
+
+    it 'uses instance to sync' do
+      Flipper.register(:admins) { |*args| false }
+      Flipper.register(:staff) { |*args| false }
+      Flipper.register(:basic) { |*args| false }
+      Flipper.register(:plus) { |*args| false }
+      Flipper.register(:premium) { |*args| false }
+
+      stub = stub_request_for_token('regular')
+      env = {
+        "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value,
+      }
+      post '/webhooks', request_body, env
+
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq({
+        "groups" => [
+          {"name" => "admins"},
+          {"name" => "staff"},
+          {"name" => "basic"},
+          {"name" => "plus"},
+          {"name" => "premium"},
+        ],
+      })
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe 'Request method unsupported' do
+    it 'skips middleware' do
+      get '/'
+      expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("application/json")
+      expect(last_response.body).to eq("{}")
+    end
+  end
+
+  describe 'Inspecting the built Rack app' do
+    it 'returns a String' do
+      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, %r{\Ahttps://www\.flippercloud\.io/adapter/features\?(?=.*\bexclude_gate_names=true\b)(?=.*\b_cb=\d+\b)}).
+      with({
+        headers: {
+          'flipper-cloud-token' => token,
+        },
+      })
+    if status == :timeout
+      stub.to_timeout
+    else
+      stub.to_return(status: status, body: response_body)
+    end
+  end
+end

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/backoff_policy_spec.rb

@@ -0,0 +1,107 @@
+require 'flipper/cloud/telemetry/backoff_policy'
+
+RSpec.describe Flipper::Cloud::Telemetry::BackoffPolicy do
+  context "#initialize" do
+    it "with no options" do
+      policy = described_class.new
+      expect(policy.min_timeout_ms).to eq(30_000)
+      expect(policy.max_timeout_ms).to eq(120_000)
+      expect(policy.multiplier).to eq(1.5)
+      expect(policy.randomization_factor).to eq(0.5)
+    end
+
+    it "with options" do
+      policy = described_class.new({
+        min_timeout_ms: 1234,
+        max_timeout_ms: 5678,
+        multiplier: 24,
+        randomization_factor: 0.4,
+      })
+      expect(policy.min_timeout_ms).to eq(1234)
+      expect(policy.max_timeout_ms).to eq(5678)
+      expect(policy.multiplier).to eq(24)
+      expect(policy.randomization_factor).to eq(0.4)
+    end
+
+    it "with min higher than max" do
+      expect {
+        described_class.new({
+          min_timeout_ms: 2,
+          max_timeout_ms: 1,
+        })
+      }.to raise_error(ArgumentError, ":min_timeout_ms (2) must be <= :max_timeout_ms (1)")
+    end
+
+    it "with invalid min_timeout_ms" do
+      expect {
+        described_class.new({
+          min_timeout_ms: -1,
+        })
+      }.to raise_error(ArgumentError, ":min_timeout_ms must be >= 0 but was -1")
+    end
+
+    it "with invalid max_timeout_ms" do
+      expect {
+        described_class.new({
+          max_timeout_ms: -1,
+        })
+      }.to raise_error(ArgumentError, ":max_timeout_ms must be >= 0 but was -1")
+    end
+
+    it "from env" do
+      ENV.update(
+        "FLIPPER_BACKOFF_MIN_TIMEOUT_MS" => "1000",
+        "FLIPPER_BACKOFF_MAX_TIMEOUT_MS" => "2000",
+        "FLIPPER_BACKOFF_MULTIPLIER" => "1.9",
+        "FLIPPER_BACKOFF_RANDOMIZATION_FACTOR" => "0.1",
+      )
+
+      policy = described_class.new
+      expect(policy.min_timeout_ms).to eq(1000)
+      expect(policy.max_timeout_ms).to eq(2000)
+      expect(policy.multiplier).to eq(1.9)
+      expect(policy.randomization_factor).to eq(0.1)
+    end
+  end
+
+  context "#next_interval" do
+    it "works" do
+      policy = described_class.new({
+        min_timeout_ms: 1_000,
+        max_timeout_ms: 10_000,
+        multiplier: 2,
+        randomization_factor: 0.5,
+      })
+
+      expect(policy.next_interval).to be_within(500).of(1000)
+      expect(policy.next_interval).to be_within(1000).of(2000)
+      expect(policy.next_interval).to be_within(2000).of(4000)
+      expect(policy.next_interval).to be_within(4000).of(8000)
+    end
+
+    it "caps maximum duration at max_timeout_secs" do
+      policy = described_class.new({
+        min_timeout_ms: 1_000,
+        max_timeout_ms: 10_000,
+        multiplier: 2,
+        randomization_factor: 0.5,
+      })
+      10.times { policy.next_interval }
+      expect(policy.next_interval).to be_within(10_000*0.1).of(10_000)
+    end
+  end
+
+  it "can reset" do
+    policy = described_class.new({
+      min_timeout_ms: 1_000,
+      max_timeout_ms: 10_000,
+      multiplier: 2,
+      randomization_factor: 0.5,
+    })
+    10.times { policy.next_interval }
+
+    expect(policy.attempts).to eq(10)
+    policy.reset
+    expect(policy.attempts).to eq(0)
+  end
+end

data/spec/flipper/cloud/telemetry/metric_spec.rb

@@ -0,0 +1,87 @@
+require 'flipper/cloud/telemetry/metric'
+
+RSpec.describe Flipper::Cloud::Telemetry::Metric do
+  it 'has key, result and time' do
+    metric = described_class.new(:search, true, 1696793160)
+    expect(metric.key).to eq(:search)
+    expect(metric.result).to eq(true)
+    expect(metric.time).to eq(1696793160)
+  end
+
+  it "clamps time to minute" do
+    metric = described_class.new(:search, true, 1696793204)
+    expect(metric.time).to eq(1696793160)
+  end
+
+  describe "#eql?" do
+    it "returns true when key, time and result are the same" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, true, 1696793204)
+      expect(metric.eql?(other)).to be(true)
+    end
+
+    it "returns false for other class" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = Object.new
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns false for sub class" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = Class.new(described_class).new(:search, true, 1696793204)
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns false if key is different" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:other, true, 1696793204)
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns false if time is different" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, true, 1696793204 - 60 - 60)
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns true with different times if times are in same minute" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, true, 1696793206)
+      expect(metric.eql?(other)).to be(true)
+    end
+
+    it "returns false if result is different" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, false, 1696793204)
+      expect(metric.eql?(other)).to be(false)
+    end
+  end
+
+  describe "#hash" do
+    it "returns hash based on class, key, time and result" do
+      metric = described_class.new(:search, true, 1696793204)
+      expect(metric.hash).to eq([described_class, metric.key, metric.time, metric.result].hash)
+    end
+  end
+
+  describe "#as_json" do
+    it "returns key time and result" do
+      metric = described_class.new(:search, true, 1696793160)
+      expect(metric.as_json).to eq({
+        "key" => "search",
+        "result" => true,
+        "time" => 1696793160,
+      })
+    end
+
+    it "can include other hashes" do
+      metric = described_class.new(:search, true, 1696793160)
+      expect(metric.as_json(with: {"value" => 2})).to eq({
+        "key" => "search",
+        "result" => true,
+        "time" => 1696793160,
+        "value" => 2,
+      })
+    end
+  end
+end

data/spec/flipper/cloud/telemetry/metric_storage_spec.rb

@@ -0,0 +1,58 @@
+require 'flipper/cloud/telemetry/metric_storage'
+require 'flipper/cloud/telemetry/metric'
+
+RSpec.describe Flipper::Cloud::Telemetry::MetricStorage do
+  describe "#increment" do
+    it "increments the counter for the metric" do
+      metric_storage = described_class.new
+      storage = metric_storage.instance_variable_get(:@storage)
+      metric = Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160)
+      other = Flipper::Cloud::Telemetry::Metric.new(:search, false, 1696793160)
+
+      metric_storage.increment(metric)
+      expect(storage[metric].value).to be(1)
+
+      5.times { metric_storage.increment(metric) }
+      expect(storage[metric].value).to be(6)
+
+      metric_storage.increment(other)
+      expect(storage[other].value).to be(1)
+    end
+  end
+
+  describe "#drain" do
+    it "returns clears metrics and return hash" do
+      metric_storage = described_class.new
+      storage = metric_storage.instance_variable_get(:@storage)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160)] = Concurrent::AtomicFixnum.new(10)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:search, false, 1696793161)] = Concurrent::AtomicFixnum.new(15)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:plausible, true, 1696793162)] = Concurrent::AtomicFixnum.new(25)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:administrator, true, 1696793164)] = Concurrent::AtomicFixnum.new(1)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:administrator, false, 1696793164)] = Concurrent::AtomicFixnum.new(24)
+
+      drained = metric_storage.drain
+      expect(drained).to be_frozen
+      expect(drained).to eq({
+        Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160) => 10,
+        Flipper::Cloud::Telemetry::Metric.new(:search, false, 1696793161) => 15,
+        Flipper::Cloud::Telemetry::Metric.new(:plausible, true, 1696793162) => 25,
+        Flipper::Cloud::Telemetry::Metric.new(:administrator, true, 1696793164) => 1,
+        Flipper::Cloud::Telemetry::Metric.new(:administrator, false, 1696793164) => 24,
+      })
+      expect(storage.keys).to eq([])
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true if empty" do
+      metric_storage = described_class.new
+      expect(metric_storage).to be_empty
+    end
+
+    it "returns false if not empty" do
+      metric_storage = described_class.new
+      metric_storage.increment Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160)
+      expect(metric_storage).not_to be_empty
+    end
+  end
+end