flipper 0.28.0 → 1.3.6

data/spec/flipper/cloud/telemetry_spec.rb

@@ -0,0 +1,208 @@
+require 'flipper/cloud/telemetry'
+require 'flipper/cloud/configuration'
+
+RSpec.describe Flipper::Cloud::Telemetry do
+  before do
+    # Stub polling for features.
+    stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+      to_return(status: 200, body: "{}")
+  end
+
+  it "phones home and does not update telemetry interval if missing" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 200, body: "{}")
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    expect(telemetry.interval).to eq(60)
+    expect(telemetry.timer.execution_interval).to eq(60)
+    expect(stub).to have_been_requested.at_least_once
+  end
+
+  it "phones home and updates telemetry interval if present" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 200, body: "{}", headers: {"telemetry-interval" => "120"})
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    expect(telemetry.interval).to eq(120)
+    expect(telemetry.timer.execution_interval).to eq(120)
+    expect(stub).to have_been_requested.at_least_once
+  end
+
+  it "phones home and requests shutdown if telemetry-shutdown header is true" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 404, body: "{}", headers: {"telemetry-shutdown" => "true"})
+
+    output = StringIO.new
+    cloud_configuration = Flipper::Cloud::Configuration.new(
+      token: "test",
+      logger: Logger.new(output),
+      logging_enabled: true,
+    )
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+    expect(stub).to have_been_requested.at_least_once
+    expect(output.string).to match(/action=telemetry_shutdown message=The server has requested that telemetry be shut down./)
+  end
+
+  it "phones home and does not shutdown if telemetry shutdown header is missing" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 404, body: "{}", headers: {})
+
+    output = StringIO.new
+    cloud_configuration = Flipper::Cloud::Configuration.new(
+      token: "test",
+      logger: Logger.new(output),
+      logging_enabled: true,
+    )
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+    expect(stub).to have_been_requested.at_least_once
+    expect(output.string).not_to match(/action=telemetry_shutdown message=The server has requested that telemetry be shut down./)
+  end
+
+  it "can update telemetry interval from error" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 500, body: "{}", headers: {"telemetry-interval" => "120"})
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+    telemetry = described_class.new(cloud_configuration)
+
+    # Override the submitter to use back off policy that doesn't actually
+    # sleep. If we don't then the stop below kills the working thread and the
+    # interval is never updated.
+    telemetry.submitter = ->(drained) {
+      Flipper::Cloud::Telemetry::Submitter.new(
+        cloud_configuration,
+        backoff_policy: FakeBackoffPolicy.new
+      ).call(drained)
+    }
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    # 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)
+  end
+
+  it "doesn't try to update telemetry interval from error if not response error" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_raise(Net::OpenTimeout)
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+    telemetry = described_class.new(cloud_configuration)
+
+    # Override the submitter to use back off policy that doesn't actually
+    # sleep. If we don't then the stop below kills the working thread and the
+    # interval is never updated.
+    telemetry.submitter = ->(drained) {
+      Flipper::Cloud::Telemetry::Submitter.new(
+        cloud_configuration,
+        backoff_policy: FakeBackoffPolicy.new
+      ).call(drained)
+    }
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    expect(telemetry.interval).to eq(60)
+    expect(telemetry.timer.execution_interval).to eq(60)
+    expect(stub).to have_been_requested.times(5)
+  end
+
+  describe '#record' do
+    it "increments in metric storage" do
+      begin
+        config = Flipper::Cloud::Configuration.new(token: "test")
+        telemetry = described_class.new(config)
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :foo,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :foo,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :bar,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :baz,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :foo,
+          result: false,
+        })
+
+        drained = telemetry.metric_storage.drain
+        metrics_by_key = drained.keys.group_by(&:key)
+
+        foo_true, foo_false = metrics_by_key["foo"].partition { |metric| metric.result }
+        foo_true_sum = foo_true.map { |metric| drained[metric] }.sum
+        expect(foo_true_sum).to be(2)
+        foo_false_sum = foo_false.map { |metric| drained[metric] }.sum
+        expect(foo_false_sum).to be(1)
+
+        bar_true_sum = metrics_by_key["bar"].map { |metric| drained[metric] }.sum
+        expect(bar_true_sum).to be(1)
+
+        baz_true_sum = metrics_by_key["baz"].map { |metric| drained[metric] }.sum
+        expect(baz_true_sum).to be(1)
+      ensure
+        telemetry.stop
+      end
+    end
+  end
+end

data/spec/flipper/cloud_spec.rb

@@ -0,0 +1,186 @@
+require 'flipper/cloud'
+require 'flipper/adapters/instrumented'
+require 'flipper/instrumenters/memory'
+
+RSpec.describe Flipper::Cloud do
+  before do
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+  end
+
+  context "initialize with token" do
+    let(:token) { 'asdf' }
+
+    before do
+      @instance = described_class.new(token: token)
+    end
+
+    it 'returns Flipper::DSL instance' do
+      expect(@instance).to be_instance_of(Flipper::Cloud::DSL)
+    end
+
+    it 'can read the cloud configuration' do
+      expect(@instance.cloud_configuration).to be_instance_of(Flipper::Cloud::Configuration)
+    end
+
+    it 'configures the correct adapter' do
+      # pardon the nesting...
+      memoized_adapter = @instance.adapter
+      dual_write_adapter = memoized_adapter.adapter
+      expect(dual_write_adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+      poll_adapter = dual_write_adapter.local
+      expect(poll_adapter).to be_instance_of(Flipper::Adapters::Poll)
+
+      http_adapter = dual_write_adapter.remote
+      client = http_adapter.client
+      expect(client.uri.scheme).to eq('https')
+      expect(client.uri.host).to eq('www.flippercloud.io')
+      expect(client.uri.path).to eq('/adapter')
+      expect(client.headers["flipper-cloud-token"]).to eq(token)
+      expect(@instance.instrumenter).to be_a(Flipper::Cloud::Telemetry::Instrumenter)
+      expect(@instance.instrumenter.instrumenter).to be(Flipper::Instrumenters::Noop)
+    end
+  end
+
+  context 'initialize with token and options' do
+    it 'sets correct url' do
+      stub_request(:any, %r{fakeflipper.com}).to_return(status: 200)
+      instance = described_class.new(token: 'asdf', url: 'https://www.fakeflipper.com/sadpanda')
+      # pardon the nesting...
+      memoized = instance.adapter
+      dual_write = memoized.adapter
+      remote = dual_write.remote
+      uri = remote.client.uri
+      expect(uri.scheme).to eq('https')
+      expect(uri.host).to eq('www.fakeflipper.com')
+      expect(uri.path).to eq('/sadpanda')
+    end
+  end
+
+  it 'can initialize with no token explicitly provided' do
+    ENV['FLIPPER_CLOUD_TOKEN'] = 'asdf'
+    expect(described_class.new).to be_instance_of(Flipper::Cloud::DSL)
+  end
+
+  it 'can set instrumenter' do
+    instrumenter = Flipper::Instrumenters::Memory.new
+    instance = described_class.new(token: 'asdf', instrumenter: instrumenter)
+    expect(instance.instrumenter).to be_a(Flipper::Cloud::Telemetry::Instrumenter)
+    expect(instance.instrumenter.instrumenter).to be(instrumenter)
+  end
+
+  it 'allows wrapping adapter with another adapter like the instrumenter' do
+    instance = described_class.new(token: 'asdf') do |config|
+      config.adapter do |adapter|
+        Flipper::Adapters::Instrumented.new(adapter)
+      end
+    end
+    # instance.adapter is memoizable adapter instance
+    expect(instance.adapter.adapter).to be_instance_of(Flipper::Adapters::Instrumented)
+  end
+
+  it 'can set debug_output' do
+    instance = Flipper::Adapters::Http::Client.new(token: 'asdf', url: 'https://www.flippercloud.io/adapter')
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(debug_output: STDOUT)).at_least(:once).and_return(instance)
+    described_class.new(token: 'asdf', debug_output: STDOUT)
+  end
+
+  it 'can set read_timeout' do
+    instance = Flipper::Adapters::Http::Client.new(token: 'asdf', url: 'https://www.flippercloud.io/adapter')
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(read_timeout: 1)).at_least(:once).and_return(instance)
+    described_class.new(token: 'asdf', read_timeout: 1)
+  end
+
+  it 'can set open_timeout' do
+    instance = Flipper::Adapters::Http::Client.new(token: 'asdf', url: 'https://www.flippercloud.io/adapter')
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(open_timeout: 1)).at_least(:once).and_return(instance)
+    described_class.new(token: 'asdf', open_timeout: 1)
+  end
+
+  if RUBY_VERSION >= '2.6.0'
+    it 'can set write_timeout' do
+      instance = Flipper::Adapters::Http::Client.new(token: 'asdf', url: 'https://www.flippercloud.io/adapter')
+      expect(Flipper::Adapters::Http::Client).to receive(:new)
+        .with(hash_including(open_timeout: 1)).at_least(:once).and_return(instance)
+      described_class.new(token: 'asdf', open_timeout: 1)
+    end
+  end
+
+  it 'can import' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_return(status: 200, body: "{}", headers: {})
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    cloud_flipper.import(flipper)
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect(cloud_flipper.adapter.get_all).to eq(get_all)
+  end
+
+  it 'raises error for failure while importing' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_return(status: 500, body: "{}")
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect { cloud_flipper.import(flipper) }.to raise_error(Flipper::Adapters::Http::Error)
+    expect(flipper.adapter.get_all).to eq(get_all)
+  end
+
+  it 'raises error for timeout while importing' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_timeout
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect { cloud_flipper.import(flipper) }.to raise_error(Net::OpenTimeout)
+    expect(flipper.adapter.get_all).to eq(get_all)
+  end
+end

data/spec/flipper/configuration_spec.rb

@@ -30,4 +30,21 @@ RSpec.describe Flipper::Configuration do
       expect(subject.default).to be(instance)
     end
   end
+
+  describe '#statsd' do
+    let(:statsd) { double(Statsd) }
+
+    after do
+      Flipper::Instrumentation::StatsdSubscriber.client = nil
+    end
+
+    it 'returns nil by default' do
+      expect(subject.statsd).to be_nil
+    end
+
+    it 'can be set' do
+      subject.statsd = statsd
+      expect(subject.statsd).to be(statsd)
+    end
+  end
 end

data/spec/flipper/dsl_spec.rb

@@ -123,18 +123,6 @@ RSpec.describe Flipper::DSL do
     end
   end
 
-  describe '#boolean' do
-    it_should_behave_like 'a DSL boolean method' do
-      let(:method_name) { :boolean }
-    end
-  end
-
-  describe '#bool' do
-    it_should_behave_like 'a DSL boolean method' do
-      let(:method_name) { :bool }
-    end
-  end
-
   describe '#group' do
     context 'for registered group' do
       before do
@@ -148,66 +136,15 @@ RSpec.describe Flipper::DSL do
     end
   end
 
-  describe '#actor' do
-    context 'for an actor' do
-      it 'returns actor instance' do
-        actor = Flipper::Actor.new(33)
-        flipper_actor = subject.actor(actor)
-        expect(flipper_actor).to be_instance_of(Flipper::Types::Actor)
-        expect(flipper_actor.value).to eq('33')
-      end
+  describe '#expression' do
+    it "returns nil if feature has no expression" do
+      expect(subject.expression(:stats)).to be(nil)
     end
 
-    context 'for nil' do
-      it 'raises argument error' do
-        expect do
-          subject.actor(nil)
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'for something that is not actor wrappable' do
-      it 'raises argument error' do
-        expect do
-          subject.actor(Object.new)
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#time' do
-    before do
-      @result = subject.time(5)
-    end
-
-    it 'returns percentage of time' do
-      expect(@result).to be_instance_of(Flipper::Types::PercentageOfTime)
-    end
-
-    it 'sets value' do
-      expect(@result.value).to eq(5)
-    end
-
-    it 'is aliased to percentage_of_time' do
-      expect(@result).to eq(subject.percentage_of_time(@result.value))
-    end
-  end
-
-  describe '#actors' do
-    before do
-      @result = subject.actors(17)
-    end
-
-    it 'returns percentage of actors' do
-      expect(@result).to be_instance_of(Flipper::Types::PercentageOfActors)
-    end
-
-    it 'sets value' do
-      expect(@result.value).to eq(17)
-    end
-
-    it 'is aliased to percentage_of_actors' do
-      expect(@result).to eq(subject.percentage_of_actors(@result.value))
+    it "returns expression if feature has expression" do
+      expression = Flipper.property(:plan).eq("basic")
+      subject[:stats].enable_expression expression
+      expect(subject.expression(:stats)).to eq(expression)
     end
   end
 
@@ -246,6 +183,33 @@ RSpec.describe Flipper::DSL do
     end
   end
 
+  describe '#enable_expression/disable_expression' do
+    it 'enables and disables the feature for the expression' do
+      expression = Flipper.property(:plan).eq("basic")
+
+      expect(subject[:stats].expression).to be(nil)
+      subject.enable_expression(:stats, expression)
+      expect(subject[:stats].expression).to eq(expression)
+
+      subject.disable_expression(:stats)
+      expect(subject[:stats].expression).to be(nil)
+    end
+  end
+
+  describe '#add_expression/remove_expression' do
+    it 'enables and disables the feature for the expression' do
+      expression = Flipper.property(:plan).eq("basic")
+      any_expression = Flipper.any(expression)
+
+      expect(subject[:stats].expression).to be(nil)
+      subject.add_expression(:stats, any_expression)
+      expect(subject[:stats].expression).to eq(any_expression)
+
+      subject.remove_expression(:stats, expression)
+      expect(subject[:stats].expression).to eq(Flipper.any)
+    end
+  end
+
   describe '#enable_actor/disable_actor' do
     it 'enables and disables the feature for actor' do
       actor = Flipper::Actor.new(5)
@@ -261,9 +225,6 @@ RSpec.describe Flipper::DSL do
 
   describe '#enable_group/disable_group' do
     it 'enables and disables the feature for group' do
-      actor = Flipper::Actor.new(5)
-      group = Flipper.register(:fives) { |actor| actor.flipper_id == 5 }
-
       expect(subject[:stats].groups_value).to be_empty
       subject.enable_group(:stats, :fives)
       expect(subject[:stats].groups_value).to eq(Set['fives'])