flipper 0.16.0 → 1.4.0

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

@@ -1,5 +1,5 @@
-require "helper"
 require "flipper/adapters/memory"
+require "flipper/adapters/actor_limit"
 require "flipper/instrumenters/memory"
 require "flipper/adapters/sync/synchronizer"
 
@@ -85,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

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/sync'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 require 'active_support/notifications'
 
 RSpec.describe Flipper::Adapters::Sync do
@@ -175,22 +173,22 @@ RSpec.describe Flipper::Adapters::Sync do
   end
 
   it 'synchronizes for #features' do
-    expect(subject).to receive(:sync)
+    expect(subject).to receive(:synchronize)
     subject.features
   end
 
   it 'synchronizes for #get' do
-    expect(subject).to receive(:sync)
+    expect(subject).to receive(:synchronize)
     subject.get sync[:search]
   end
 
   it 'synchronizes for #get_multi' do
-    expect(subject).to receive(:sync)
+    expect(subject).to receive(:synchronize)
     subject.get_multi [sync[:search]]
   end
 
   it 'synchronizes for #get_all' do
-    expect(subject).to receive(:sync)
+    expect(subject).to receive(:synchronize)
     subject.get_all
   end
 
@@ -199,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

@@ -0,0 +1,217 @@
+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 "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 }
+      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,257 @@
+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
+    # 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",
+    }))
+
+    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
+    # 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)
+
+    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