flipper 0.26.0 → 1.3.6

data/spec/flipper_integration_spec.rb

@@ -7,25 +7,32 @@ RSpec.describe Flipper do
   let(:admin_group) { flipper.group(:admins) }
   let(:dev_group)   { flipper.group(:devs) }
 
-  let(:admin_thing) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false
+  let(:admin_actor) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false, flipper_properties: {"admin" => true, "dev" => false}
   end
-  let(:dev_thing) do
-    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true
+  let(:dev_actor) do
+    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true, flipper_properties: {"admin" => false, "dev" => true}
   end
 
-  let(:admin_truthy_thing) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false
+  let(:admin_truthy_actor) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false, flipper_properties: {"admin" => "true-ish", "dev" => false}
   end
-  let(:admin_falsey_thing) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: nil, dev?: false
+  let(:admin_falsey_actor) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: nil, dev?: false, flipper_properties: {"admin" => nil, "dev" => false}
+  end
+
+  let(:basic_plan_actor) do
+    double 'Non Flipper Thing', flipper_id: 1, flipper_properties: {"plan" => "basic"}
+  end
+  let(:premium_plan_actor) do
+    double 'Non Flipper Thing', flipper_id: 10, flipper_properties: {"plan" => "premium"}
   end
 
   let(:pitt)        { Flipper::Actor.new(1) }
   let(:clooney)     { Flipper::Actor.new(10) }
 
-  let(:five_percent_of_actors) { flipper.actors(5) }
-  let(:five_percent_of_time) { flipper.time(5) }
+  let(:five_percent_of_actors) { Flipper::Types::PercentageOfActors.new(5) }
+  let(:five_percent_of_time) { Flipper::Types::PercentageOfTime.new(5) }
 
   before do
     described_class.register(:admins, &:admin?)
@@ -60,20 +67,22 @@ RSpec.describe Flipper do
         expect(@result).to eq(true)
       end
 
-      it 'enables feature for non flipper thing in group' do
-        expect(feature.enabled?(admin_thing)).to eq(true)
+      it 'enables feature for non flipper actor in group' do
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
-      it 'does not enable feature for non flipper thing in other group' do
-        expect(feature.enabled?(dev_thing)).to eq(false)
+      it 'does not enable feature for non flipper actor in other group' do
+        expect(feature.enabled?(dev_actor)).to eq(false)
       end
 
       it 'enables feature for flipper actor in group' do
-        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_actor))).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
       it 'does not enable for flipper actor not in group' do
-        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
+        expect(feature.enabled?(Flipper::Types::Actor.new(dev_actor))).to eq(false)
+        expect(feature.enabled?(dev_actor)).to eq(false)
       end
 
       it 'does not enable feature for all' do
@@ -118,8 +127,8 @@ RSpec.describe Flipper do
 
       it 'enables feature for actor within percentage' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be_within(2).of(5)
@@ -141,8 +150,8 @@ RSpec.describe Flipper do
 
       it 'enables feature for actor within percentage' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be_within(2).of(5)
@@ -180,10 +189,10 @@ RSpec.describe Flipper do
 
     context 'with argument that has no gate' do
       it 'raises error' do
-        thing = Object.new
+        actor = Object.new
         expect do
-          feature.enable(thing)
-        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+          feature.enable(actor)
+        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{actor.inspect}")
       end
     end
   end
@@ -215,13 +224,13 @@ RSpec.describe Flipper do
       end
 
       it 'disables actor in group' do
-        expect(feature.enabled?(admin_thing)).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'disables actor in percentage of actors' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be(0)
@@ -247,20 +256,22 @@ RSpec.describe Flipper do
         expect(@result).to eq(true)
       end
 
-      it 'disables the feature for non flipper thing in the group' do
-        expect(feature.enabled?(admin_thing)).to eq(false)
+      it 'disables the feature for non flipper actor in the group' do
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
-      it 'does not disable feature for non flipper thing in other groups' do
-        expect(feature.enabled?(dev_thing)).to eq(true)
+      it 'does not disable feature for non flipper actor in other groups' do
+        expect(feature.enabled?(dev_actor)).to eq(true)
       end
 
       it 'disables feature for flipper actor in group' do
-        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(false)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_actor))).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'does not disable feature for flipper actor in other groups' do
-        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(true)
+        expect(feature.enabled?(Flipper::Types::Actor.new(dev_actor))).to eq(true)
+        expect(feature.enabled?(dev_actor)).to eq(true)
       end
 
       it 'adds feature to set of features' do
@@ -294,7 +305,7 @@ RSpec.describe Flipper do
 
     context 'with a percentage of actors' do
       before do
-        @result = feature.disable(flipper.actors(0))
+        @result = feature.disable(Flipper::Types::PercentageOfActors.new(0))
       end
 
       it 'returns true' do
@@ -303,8 +314,8 @@ RSpec.describe Flipper do
 
       it 'disables feature' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be(0)
@@ -318,7 +329,7 @@ RSpec.describe Flipper do
     context 'with a percentage of time' do
       before do
         @gate = feature.gate(:percentage_of_time)
-        @result = feature.disable(flipper.time(0))
+        @result = feature.disable(Flipper::Types::PercentageOfTime.new(0))
       end
 
       it 'returns true' do
@@ -342,10 +353,10 @@ RSpec.describe Flipper do
 
     context 'with argument that has no gate' do
       it 'raises error' do
-        thing = Object.new
+        actor = Object.new
         expect do
-          feature.disable(thing)
-        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+          feature.disable(actor)
+        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{actor.inspect}")
       end
     end
   end
@@ -373,23 +384,29 @@ RSpec.describe Flipper do
       end
 
       it 'returns true' do
-        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_actor))).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
       it 'returns true for truthy block values' do
-        expect(feature.enabled?(flipper.actor(admin_truthy_thing))).to eq(true)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_truthy_actor))).to eq(true)
+        expect(feature.enabled?(admin_truthy_actor)).to eq(true)
+      end
+
+      it 'returns true if any actor is in enabled group' do
+        expect(feature.enabled?(dev_actor, admin_actor)).to be(true)
       end
     end
 
     context 'for actor in disabled group' do
       it 'returns false' do
-        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
-        expect(feature.enabled?(dev_thing)).to eq(false)
+        expect(feature.enabled?(Flipper::Types::Actor.new(dev_actor))).to eq(false)
+        expect(feature.enabled?(dev_actor)).to eq(false)
       end
 
       it 'returns false for falsey block values' do
-        expect(feature.enabled?(flipper.actor(admin_falsey_thing))).to eq(false)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_falsey_actor))).to eq(false)
+        expect(feature.enabled?(admin_falsey_actor)).to eq(false)
       end
     end
 
@@ -408,6 +425,10 @@ RSpec.describe Flipper do
         expect(feature.enabled?(clooney)).to eq(false)
       end
 
+      it 'returns false if all actors are disabled' do
+        expect(feature.enabled?(clooney, pitt)).to be(false)
+      end
+
       it 'returns true if boolean enabled' do
         feature.enable
         expect(feature.enabled?(clooney)).to eq(true)
@@ -428,7 +449,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
@@ -446,7 +467,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
@@ -463,7 +484,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(false)
         expect(feature.enabled?(nil)).to eq(false)
         expect(feature.enabled?(pitt)).to eq(false)
-        expect(feature.enabled?(admin_thing)).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'returns true if boolean enabled' do
@@ -471,7 +492,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
@@ -488,7 +509,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(false)
         expect(feature.enabled?(nil)).to eq(false)
         expect(feature.enabled?(pitt)).to eq(false)
-        expect(feature.enabled?(admin_thing)).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'returns true if boolean enabled' do
@@ -496,27 +517,31 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
-    context 'for a non flipper thing' do
+    context 'for a non flipper actor' do
       before do
         feature.enable admin_group
       end
 
       it 'returns true if in enabled group' do
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
       it 'returns false if not in enabled group' do
-        expect(feature.enabled?(dev_thing)).to eq(false)
+        expect(feature.enabled?(dev_actor)).to eq(false)
+      end
+
+      it 'retruns true if any actor is true' do
+        expect(feature.enabled?(admin_actor, dev_actor)).to eq(true)
       end
 
       it 'returns true if boolean enabled' do
         feature.enable
-        expect(feature.enabled?(admin_thing)).to eq(true)
-        expect(feature.enabled?(dev_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
+        expect(feature.enabled?(dev_actor)).to eq(true)
       end
     end
   end
@@ -530,11 +555,96 @@ RSpec.describe Flipper do
     end
 
     it 'enables feature for object in enabled group' do
-      expect(feature.enabled?(admin_thing)).to eq(true)
+      expect(feature.enabled?(admin_actor)).to eq(true)
     end
 
     it 'does not enable feature for object in not enabled group' do
-      expect(feature.enabled?(dev_thing)).to eq(false)
+      expect(feature.enabled?(dev_actor)).to eq(false)
+    end
+  end
+
+  context "for expression" do
+    it "works" do
+      feature.enable Flipper.property(:plan).eq("basic")
+
+      expect(feature.enabled?).to be(false)
+      expect(feature.enabled?(basic_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor)).to be(false)
+      expect(feature.enabled?(admin_actor)).to be(false)
+    end
+
+    it "works for true expression with no actor" do
+      feature.enable Flipper.boolean(true)
+      expect(feature.enabled?).to be(true)
+    end
+
+    it "works for multiple actors" do
+      feature.enable Flipper.property(:plan).eq("basic")
+
+      expect(feature.enabled?(basic_plan_actor, premium_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor, basic_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor, admin_actor)).to be(false)
+    end
+  end
+
+  context "for Any" do
+    it "works" do
+      expression = Flipper.any(
+        Flipper.property(:plan).eq("basic"),
+        Flipper.property(:plan).eq("plus"),
+      )
+      feature.enable expression
+
+      expect(feature.enabled?(basic_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor)).to be(false)
+    end
+  end
+
+  context "for All" do
+    it "works" do
+      true_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 21,
+      })
+      false_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 20,
+      })
+      expression = Flipper.all(
+        Flipper.property(:plan).eq("basic"),
+        Flipper.property(:age).eq(21)
+      )
+      feature.enable expression
+
+      expect(feature.enabled?(true_actor)).to be(true)
+      expect(feature.enabled?(false_actor)).to be(false)
+    end
+
+    it "works when nested" do
+      admin_actor = Flipper::Actor.new("User;1", {
+        "admin" => true,
+      })
+      true_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 21,
+      })
+      false_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 20,
+      })
+      expression = Flipper.any(
+        Flipper.property(:admin).eq(true),
+        Flipper.all(
+          Flipper.property(:plan).eq("basic"),
+          Flipper.property(:age).eq(21)
+        )
+      )
+
+      feature.enable expression
+
+      expect(feature.enabled?(admin_actor)).to be(true)
+      expect(feature.enabled?(true_actor)).to be(true)
+      expect(feature.enabled?(false_actor)).to be(false)
     end
   end
 end

data/spec/flipper_spec.rb

@@ -64,7 +64,12 @@ RSpec.describe Flipper do
 
   describe "delegation to instance" do
     let(:group) { Flipper::Types::Group.new(:admins) }
-    let(:actor) { Flipper::Actor.new("1") }
+    let(:actor) {
+      Flipper::Actor.new("1", {
+        "plan" => "basic",
+      })
+    }
+    let(:expression) { Flipper.property(:plan).eq("basic") }
 
     before do
       described_class.configure do |config|
@@ -88,12 +93,35 @@ RSpec.describe Flipper do
       expect(described_class.instance.enabled?(:search)).to be(false)
     end
 
-    it 'delegates bool to instance' do
-      expect(described_class.bool).to eq(described_class.instance.bool)
+    it 'delegates expression to instance' do
+      expect(described_class.expression(:search)).to be(nil)
+
+      expression = Flipper.property(:plan).eq("basic")
+      Flipper.instance.enable_expression :search, expression
+
+      expect(described_class.expression(:search)).to eq(expression)
     end
 
-    it 'delegates boolean to instance' do
-      expect(described_class.boolean).to eq(described_class.instance.boolean)
+    it 'delegates enable_expression to instance' do
+      described_class.enable_expression(:search, expression)
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+    end
+
+    it 'delegates disable_expression to instance' do
+      described_class.disable_expression(:search)
+      expect(described_class.instance.enabled?(:search, actor)).to be(false)
+    end
+
+    it 'delegates add_expression to instance' do
+      described_class.add_expression(:search, expression)
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+    end
+
+    it 'delegates remove_expression to instance' do
+      described_class.enable_expression(:search, Flipper.any(expression))
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+      described_class.remove_expression(:search, expression)
+      expect(described_class.instance.enabled?(:search, actor)).to be(false)
     end
 
     it 'delegates enable_actor to instance' do
@@ -106,10 +134,6 @@ RSpec.describe Flipper do
       expect(described_class.instance.enabled?(:search, actor)).to be(false)
     end
 
-    it 'delegates actor to instance' do
-      expect(described_class.actor(actor)).to eq(described_class.instance.actor(actor))
-    end
-
     it 'delegates enable_group to instance' do
       described_class.enable_group(:search, group)
       expect(described_class.instance[:search].enabled_groups).to include(group)
@@ -130,15 +154,6 @@ RSpec.describe Flipper do
       expect(described_class.instance[:search].percentage_of_actors_value).to be(0)
     end
 
-    it 'delegates actors to instance' do
-      expect(described_class.actors(5)).to eq(described_class.instance.actors(5))
-    end
-
-    it 'delegates percentage_of_actors to instance' do
-      expected = described_class.instance.percentage_of_actors(5)
-      expect(described_class.percentage_of_actors(5)).to eq(expected)
-    end
-
     it 'delegates enable_percentage_of_time to instance' do
       described_class.enable_percentage_of_time(:search, 5)
       expect(described_class.instance[:search].percentage_of_time_value).to be(5)
@@ -149,15 +164,6 @@ RSpec.describe Flipper do
       expect(described_class.instance[:search].percentage_of_time_value).to be(0)
     end
 
-    it 'delegates time to instance' do
-      expect(described_class.time(56)).to eq(described_class.instance.time(56))
-    end
-
-    it 'delegates percentage_of_time to instance' do
-      expected = described_class.instance.percentage_of_time(56)
-      expect(described_class.percentage_of_time(56)).to eq(expected)
-    end
-
     it 'delegates features to instance' do
       described_class.instance.add(:search)
       expect(described_class.features).to eq(described_class.instance.features)
@@ -202,6 +208,12 @@ RSpec.describe Flipper do
       expect(described_class.enabled?(:search)).to be(true)
     end
 
+    it 'delegates export to instance' do
+      described_class.enable(:search)
+      expect(described_class.export).to eq(described_class.adapter.export)
+      expect(described_class.export(format: :json)).to eq(described_class.adapter.export(format: :json))
+    end
+
     it 'delegates adapter to instance' do
       expect(described_class.adapter).to eq(described_class.instance.adapter)
     end
@@ -216,16 +228,20 @@ RSpec.describe Flipper do
       expect(described_class.memoizing?).to eq(described_class.adapter.memoizing?)
     end
 
+    it 'delegates read_only? to instance' do
+      expect(described_class.read_only?).to eq(described_class.adapter.read_only?)
+    end
+
     it 'delegates sync stuff to instance and does nothing' do
       expect(described_class.sync).to be(nil)
       expect(described_class.sync_secret).to be(nil)
     end
 
     it 'delegates sync stuff to instance for Flipper::Cloud' do
-      stub = stub_request(:get, "https://www.flippercloud.io/adapter/features").
+      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({
@@ -297,7 +313,7 @@ RSpec.describe Flipper do
 
   describe '.group_exists' do
     it 'returns true if the group is already created' do
-      group = described_class.register('admins', &:admin?)
+      described_class.register('admins', &:admin?)
       expect(described_class.group_exists?(:admins)).to eq(true)
     end
 
@@ -350,4 +366,52 @@ RSpec.describe Flipper do
       expect(described_class.instance_variable_get('@groups_registry')).to eq(registry)
     end
   end
+
+  describe ".constant" do
+    it "returns Flipper::Expression::Constant instance" do
+      expect(described_class.constant(false)).to eq(Flipper::Expression::Constant.new(false))
+      expect(described_class.constant("string")).to eq(Flipper::Expression::Constant.new("string"))
+    end
+  end
+
+  describe ".property" do
+    it "returns Flipper::Expressions::Property expression" do
+      expect(Flipper.property("name")).to eq(Flipper::Expression.build(Property: "name"))
+    end
+  end
+
+  describe ".boolean" do
+    it "returns Flipper::Expressions::Boolean expression" do
+      expect(described_class.boolean(true)).to eq(Flipper::Expression.build(Boolean: true))
+      expect(described_class.boolean(false)).to eq(Flipper::Expression.build(Boolean: false))
+    end
+  end
+
+  describe ".random" do
+    it "returns Flipper::Expressions::Random expression" do
+      expect(Flipper.random(100)).to eq(Flipper::Expression.build(Random: 100))
+    end
+  end
+
+  describe ".any" do
+    let(:age_expression) { Flipper.property(:age).gte(21) }
+    let(:plan_expression) { Flipper.property(:plan).eq("basic") }
+
+    it "returns Flipper::Expressions::Any instance" do
+      expect(Flipper.any(age_expression, plan_expression)).to eq(
+        Flipper::Expression.build({Any: [age_expression, plan_expression]})
+      )
+    end
+  end
+
+  describe ".all" do
+    let(:age_expression) { Flipper.property(:age).gte(21) }
+    let(:plan_expression) { Flipper.property(:plan).eq("basic") }
+
+    it "returns Flipper::Expressions::All instance" do
+      expect(Flipper.all(age_expression, plan_expression)).to eq(
+        Flipper::Expression.build({All: [age_expression, plan_expression]})
+      )
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -2,14 +2,17 @@ $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'pp'
 require 'pathname'
-FlipperRoot = Pathname(__FILE__).dirname.join('..').expand_path
-
-require 'rubygems'
-require 'bundler'
+require 'bundler/setup'
 
-Bundler.setup(:default)
+require 'warning'
+Warning.ignore(/lib\/statsd/)
+Warning.ignore(/lib\/debug\//)
+Warning.ignore(/lib\/ice_age\//)
+Warning.ignore(/lib\/moneta\//)
+Warning.ignore(/lib\/mongo\//)
 
 require 'debug'
+require 'statsd'
 require 'webmock/rspec'
 WebMock.disable_net_connect!(allow_localhost: true)
 
@@ -17,12 +20,21 @@ require 'flipper'
 require 'flipper/api'
 require 'flipper/spec/shared_adapter_specs'
 require 'flipper/ui'
+require 'flipper/test_help'
 
+FlipperRoot = Pathname(__FILE__).dirname.join('..').expand_path
 Dir[FlipperRoot.join('spec/support/**/*.rb')].sort.each { |f| require f }
 
+# Disable telemetry logging in specs.
+ENV["FLIPPER_CLOUD_LOGGING_ENABLED"] = "false"
+
 RSpec.configure do |config|
   config.before(:example) do
-    Flipper::Adapters::Poll::Poller.reset if defined?(Flipper::Adapters::Poll::Poller)
+    # default stub for telemetry
+    stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 200, body: "", headers: {})
+    Flipper::Cloud::Telemetry.reset if defined?(Flipper::Cloud::Telemetry) && Flipper::Cloud::Telemetry.respond_to?(:reset)
+    Flipper::Poller.reset if defined?(Flipper::Poller)
     Flipper.unregister_groups
     Flipper.configuration = nil
   end
@@ -91,15 +103,3 @@ RSpec.shared_examples_for 'a DSL feature' do
     end.to raise_error(ArgumentError, /must be a String or Symbol/)
   end
 end
-
-RSpec.shared_examples_for 'a DSL boolean method' do
-  it 'returns boolean with value set' do
-    result = subject.send(method_name, true)
-    expect(result).to be_instance_of(Flipper::Types::Boolean)
-    expect(result.value).to be(true)
-
-    result = subject.send(method_name, false)
-    expect(result).to be_instance_of(Flipper::Types::Boolean)
-    expect(result.value).to be(false)
-  end
-end

data/spec/support/actor_names.yml

@@ -0,0 +1 @@
+actor_name_1: 'Actor #1'

data/spec/support/fail_on_output.rb

@@ -0,0 +1,8 @@
+if ENV["CI"] || ENV["FAIL_ON_OUTPUT"]
+  RSpec.configure do |config|
+    config.around do |example|
+      output = capture_output { example.run }
+      fail "Use `silence { }` to avoid printing to STDOUT/STDERR\n#{output}" unless output.empty?
+    end
+  end
+end