flipper 1.0.0 → 1.3.6

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

@@ -0,0 +1,145 @@
+require "stringio"
+require 'flipper/cloud/configuration'
+require 'flipper/cloud/telemetry/submitter'
+
+RSpec.describe Flipper::Cloud::Telemetry::Submitter do
+  let(:cloud_configuration) {
+    Flipper::Cloud::Configuration.new({token: "asdf"})
+  }
+  let(:fake_backoff_policy) { FakeBackoffPolicy.new }
+  let(:subject) { described_class.new(cloud_configuration, backoff_policy: fake_backoff_policy) }
+
+  describe "#initialize" do
+    it "works with cloud_configuration" do
+      submitter = described_class.new(cloud_configuration)
+      expect(submitter.cloud_configuration).to eq(cloud_configuration)
+    end
+  end
+
+  describe "#call" do
+    let(:enabled_metrics) {
+      {
+        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,
+      }
+    }
+
+    it "does not submit blank metrics" do
+      expect(subject.call({})).to be(nil)
+    end
+
+    it "submits present metrics" do
+      expected_body = {
+        "request_id" => subject.request_id,
+        "enabled_metrics" =>[
+          {"key" => "search", "time" => 1696793160, "result" => true, "value" => 10},
+          {"key" => "search", "time" => 1696793160, "result" => false, "value" => 15},
+          {"key" => "plausible", "time" => 1696793160, "result" => true, "value" => 25},
+          {"key" => "administrator", "time" => 1696793160, "result" => true, "value" => 1},
+          {"key" => "administrator", "time" => 1696793160, "result" => false, "value" => 24},
+        ]
+      }
+      expected_headers = {
+        'accept' => 'application/json',
+        'client-engine' => defined?(RUBY_ENGINE) ? RUBY_ENGINE : "",
+        'client-hostname' => Socket.gethostname,
+        'client-language' => 'ruby',
+        'client-language-version' => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+        'client-pid' => Process.pid.to_s,
+        'client-platform' => RUBY_PLATFORM,
+        'client-thread' => Thread.current.object_id.to_s,
+        'content-encoding' => 'gzip',
+        'content-type' => 'application/json',
+        'flipper-cloud-token' => 'asdf',
+        'schema-version' => 'V1',
+        'user-agent' => "Flipper HTTP Adapter v#{Flipper::VERSION}",
+      }
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        with(headers: expected_headers) { |request|
+          gunzipped = Flipper::Typecast.from_gzip(request.body)
+          body = Flipper::Typecast.from_json(gunzipped)
+          body == expected_body
+        }.to_return(status: 200, body: "{}")
+      subject.call(enabled_metrics)
+    end
+
+    it "defaults backoff_policy" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 429, body: "{}").
+        to_return(status: 200, body: "{}")
+      instance = described_class.new(cloud_configuration)
+      expect(instance.backoff_policy.min_timeout_ms).to eq(30_000)
+      expect(instance.backoff_policy.max_timeout_ms).to eq(120_000)
+    end
+
+    it "tries 10 times by default" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 500, body: "{}")
+      subject.call(enabled_metrics)
+      expect(subject.backoff_policy.retries).to eq(4) # 4 retries + 1 initial attempt
+    end
+
+    [
+      EOFError,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      Errno::ENETUNREACH,
+      Errno::ENOTSOCK,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      Net::ReadTimeout,
+      OpenSSL::SSL::SSLError,
+      SocketError,
+      Timeout::Error,  # Also covers subclasses like Net::OpenTimeout.
+    ].each  do |error_class|
+      it "retries on #{error_class}" do
+        stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+          to_raise(error_class)
+        subject.call(enabled_metrics)
+        expect(subject.backoff_policy.retries).to eq(4)
+      end
+    end
+
+    it "retries on 429" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 429, body: "{}").
+        to_return(status: 429, body: "{}").
+        to_return(status: 200, body: "{}")
+      subject.call(enabled_metrics)
+      expect(subject.backoff_policy.retries).to eq(2)
+    end
+
+    it "retries on 500" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 500, body: "{}").
+        to_return(status: 503, body: "{}").
+        to_return(status: 502, body: "{}").
+        to_return(status: 200, body: "{}")
+      subject.call(enabled_metrics)
+      expect(subject.backoff_policy.retries).to eq(3)
+    end
+  end
+
+  def with_telemetry_debug_logging(&block)
+    output = StringIO.new
+    original_logger = cloud_configuration.logger
+
+    begin
+      cloud_configuration.logger = Logger.new(output)
+      block.call
+    ensure
+      cloud_configuration.logger = original_logger
+    end
+
+    output.string
+  end
+end

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

@@ -35,13 +35,15 @@ RSpec.describe Flipper::Cloud do
       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(Flipper::Instrumenters::Noop)
+      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
@@ -55,15 +57,15 @@ RSpec.describe Flipper::Cloud do
   end
 
   it 'can initialize with no token explicitly provided' do
-    with_env 'FLIPPER_CLOUD_TOKEN' => 'asdf' do
-      expect(described_class.new).to be_instance_of(Flipper::Cloud::DSL)
-    end
+    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(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
@@ -77,34 +79,38 @@ RSpec.describe Flipper::Cloud do
   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)
+      .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)
+      .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)
+      .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)
+        .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: {})
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_return(status: 200, body: "{}", headers: {})
 
     flipper = Flipper.new(Flipper::Adapters::Memory.new)
 
@@ -116,10 +122,10 @@ RSpec.describe Flipper::Cloud do
     cloud_flipper = Flipper::Cloud.new(token: "asdf")
 
     get_all = {
-      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
-      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "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)
@@ -130,7 +136,7 @@ RSpec.describe Flipper::Cloud do
 
   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: "{}")
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_return(status: 500, body: "{}")
 
     flipper = Flipper.new(Flipper::Adapters::Memory.new)
 
@@ -142,10 +148,10 @@ RSpec.describe Flipper::Cloud do
     cloud_flipper = Flipper::Cloud.new(token: "asdf")
 
     get_all = {
-      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
-      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "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)
@@ -155,7 +161,7 @@ RSpec.describe Flipper::Cloud do
 
   it 'raises error for timeout while importing' do
     stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
-      with(headers: {'Flipper-Cloud-Token'=>'asdf'}).to_timeout
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_timeout
 
     flipper = Flipper.new(Flipper::Adapters::Memory.new)
 
@@ -167,10 +173,10 @@ RSpec.describe Flipper::Cloud do
     cloud_flipper = Flipper::Cloud.new(token: "asdf")
 
     get_all = {
-      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: "5"},
-      "search" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "test" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "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)

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

@@ -136,6 +136,18 @@ RSpec.describe Flipper::DSL do
     end
   end
 
+  describe '#expression' do
+    it "returns nil if feature has no expression" do
+      expect(subject.expression(:stats)).to be(nil)
+    end
+
+    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
+
   describe '#features' do
     context 'with no features enabled/disabled' do
       it 'defaults to empty set' do
@@ -171,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)
@@ -186,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'])