flipper 1.0.0 → 1.3.6

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

@@ -12,16 +12,16 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "can set token from ENV var" do
-    with_env "FLIPPER_CLOUD_TOKEN" => "from_env" do
-      instance = described_class.new(required_options.reject { |k, v| k == :token })
-      expect(instance.token).to eq("from_env")
-    end
+    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(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
@@ -30,10 +30,9 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "can set read_timeout from ENV var" do
-    with_env "FLIPPER_CLOUD_READ_TIMEOUT" => "9" do
-      instance = described_class.new(required_options.reject { |k, v| k == :read_timeout })
-      expect(instance.read_timeout).to eq(9)
-    end
+    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
@@ -42,10 +41,9 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "can set open_timeout from ENV var" do
-    with_env "FLIPPER_CLOUD_OPEN_TIMEOUT" => "9" do
-      instance = described_class.new(required_options.reject { |k, v| k == :open_timeout })
-      expect(instance.open_timeout).to eq(9)
-    end
+    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
@@ -54,31 +52,29 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "can set write_timeout from ENV var" do
-    with_env "FLIPPER_CLOUD_WRITE_TIMEOUT" => "9" do
-      instance = described_class.new(required_options.reject { |k, v| k == :write_timeout })
-      expect(instance.write_timeout).to eq(9)
-    end
+    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: 1))
-    expect(instance.sync_interval).to eq(1)
+    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
-    with_env "FLIPPER_CLOUD_SYNC_INTERVAL" => "5" do
-      instance = described_class.new(required_options.reject { |k, v| k == :sync_interval })
-      expect(instance.sync_interval).to eq(5)
-    end
+    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: 1))
+    instance = described_class.new(required_options.merge(sync_interval: 20))
     poller = instance.send(:poller)
-    expect(poller.interval).to eq(1)
+    expect(poller.interval).to eq(20)
   end
 
   it "can set debug_output" do
@@ -86,6 +82,12 @@ RSpec.describe Flipper::Cloud::Configuration do
     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: "{}")
@@ -121,10 +123,9 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "can override URL using ENV var" do
-    with_env "FLIPPER_CLOUD_URL" => "https://example.com" do
-      instance = described_class.new(required_options.reject { |k, v| k == :url })
-      expect(instance.url).to eq("https://example.com")
-    end
+    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
@@ -143,12 +144,11 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "sets sync_method to :webhook if FLIPPER_CLOUD_SYNC_SECRET set" do
-    with_env "FLIPPER_CLOUD_SYNC_SECRET" => "abc" do
-      instance = described_class.new(required_options)
+    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
+    expect(instance.sync_method).to eq(:webhook)
+    expect(instance.adapter).to be_instance_of(Flipper::Adapters::DualWrite)
   end
 
   it "can set sync_secret" do
@@ -157,10 +157,9 @@ RSpec.describe Flipper::Cloud::Configuration do
   end
 
   it "can override sync_secret using ENV var" do
-    with_env "FLIPPER_CLOUD_SYNC_SECRET" => "from_env" do
-      instance = described_class.new(required_options.reject { |k, v| k == :sync_secret })
-      expect(instance.sync_secret).to eq("from_env")
-    end
+    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
@@ -233,9 +232,9 @@ RSpec.describe Flipper::Cloud::Configuration do
     stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
       with({
         headers: {
-          'Flipper-Cloud-Token'=>'asdf',
+          'flipper-cloud-token'=>'asdf',
         },
-      }).to_return(status: 200, body: body, headers: {})
+      }).to_return(status: 200, body: body)
     instance = described_class.new(required_options)
     instance.sync
 
@@ -249,21 +248,4 @@ RSpec.describe Flipper::Cloud::Configuration do
     expect(all["search"][:boolean]).to eq("true")
     expect(all["history"][:boolean]).to eq(nil)
   end
-
-  it "can setup brow to report events to cloud" do
-    # skip logging brow
-    Brow.logger = Logger.new(File::NULL)
-    brow = described_class.new(required_options).brow
-
-    stub = stub_request(:post, "https://www.flippercloud.io/adapter/events")
-      .with { |request|
-        data = JSON.parse(request.body)
-        data.keys == ["uuid", "messages"] && data["messages"] == [{"n" => 1}]
-      }
-      .to_return(status: 201, body: "{}", headers: {})
-
-    brow.push({"n" => 1})
-    brow.worker.stop
-    expect(stub).to have_been_requested.times(1)
-  end
 end

data/spec/flipper/cloud/dsl_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Flipper::Cloud::DSL do
     stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
       with({
         headers: {
-          'Flipper-Cloud-Token'=>'asdf',
+          'flipper-cloud-token'=>'asdf',
         },
       }).to_return(status: 200, body: '{"features": {}}', headers: {})
     cloud_configuration = Flipper::Cloud::Configuration.new({
@@ -45,7 +45,7 @@ RSpec.describe Flipper::Cloud::DSL do
     end
 
     let(:cloud_configuration) do
-      cloud_configuration = Flipper::Cloud::Configuration.new({
+      Flipper::Cloud::Configuration.new({
         token: "asdf",
         sync_secret: "tasty",
         local_adapter: local_adapter
@@ -65,11 +65,11 @@ RSpec.describe Flipper::Cloud::DSL do
 
     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: '{}', headers: {})
+        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: '{}', headers: {})
+        with(headers: {'flipper-cloud-token'=>'asdf'}).
+        to_return(status: 200, body: '{}')
 
       subject.enable(:foo)
 

data/spec/flipper/cloud/middleware_spec.rb

@@ -101,8 +101,8 @@ RSpec.describe Flipper::Cloud::Middleware do
       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(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
@@ -124,8 +124,8 @@ RSpec.describe Flipper::Cloud::Middleware do
       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(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
@@ -147,8 +147,8 @@ RSpec.describe Flipper::Cloud::Middleware do
       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(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
@@ -277,13 +277,13 @@ RSpec.describe Flipper::Cloud::Middleware do
     stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
       with({
         headers: {
-          'Flipper-Cloud-Token' => token,
+          'flipper-cloud-token' => token,
         },
       })
     if status == :timeout
       stub.to_timeout
     else
-      stub.to_return(status: status, body: response_body, headers: {})
+      stub.to_return(status: status, body: response_body)
     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