flipper 0.10.2 → 0.11.0.beta1

data/spec/flipper/middleware/setup_env_spec.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+RSpec.describe Flipper::Middleware::SetupEnv do
+  context 'with flipper instance' do
+    let(:app) do
+      app = lambda do |env|
+        [200, { 'Content-Type' => 'text/html' }, [env['flipper'].object_id.to_s]]
+      end
+      builder = Rack::Builder.new
+      builder.use described_class, flipper
+      builder.run app
+      builder
+    end
+
+    it 'sets flipper in env' do
+      get '/'
+      expect(last_response.body).to eq(flipper.object_id.to_s)
+    end
+  end
+
+  context 'with block that returns flipper instance' do
+    let(:flipper_block) do
+      -> { flipper }
+    end
+    let(:app) do
+      app = lambda do |env|
+        [200, { 'Content-Type' => 'text/html' }, [env['flipper'].object_id.to_s]]
+      end
+      builder = Rack::Builder.new
+      builder.use described_class, flipper_block
+      builder.run app
+      builder
+    end
+
+    it 'sets flipper in env' do
+      get '/'
+      expect(last_response.body).to eq(flipper.object_id.to_s)
+    end
+  end
+
+  context 'when env already has flipper setup' do
+    let(:app) do
+      app = lambda do |env|
+        [200, { 'Content-Type' => 'text/html' }, [env['flipper'].object_id.to_s]]
+      end
+      builder = Rack::Builder.new
+      builder.use described_class, flipper
+      builder.run app
+      builder
+    end
+
+    it 'leaves env flipper alone' do
+      env_flipper = build_flipper
+      get '/', {}, 'flipper' => env_flipper
+      expect(last_response.body).to eq(env_flipper.object_id.to_s)
+    end
+  end
+
+  context 'when flipper instance is nil' do
+    let(:app) do
+      app = lambda do |env|
+        [200, { 'Content-Type' => 'text/html' }, [env['flipper'].object_id.to_s]]
+      end
+      builder = Rack::Builder.new
+      builder.use described_class, nil
+      builder.run app
+      builder
+    end
+
+    it 'leaves env flipper alone' do
+      env_flipper = build_flipper
+      get '/', {}, 'flipper' => env_flipper
+      expect(last_response.body).to eq(env_flipper.object_id.to_s)
+    end
+  end
+end

data/spec/flipper/registry_spec.rb

@@ -2,123 +2,119 @@ require 'helper'
 require 'flipper/registry'
 
 RSpec.describe Flipper::Registry do
-  subject { Flipper::Registry.new(source) }
+  subject { described_class.new(source) }
 
   let(:source) { {} }
 
-  describe "#add" do
-    it "adds to source" do
+  describe '#add' do
+    it 'adds to source' do
       value = 'thing'
       subject.add(:admins, value)
       expect(source[:admins]).to eq(value)
     end
 
-    it "converts key to symbol" do
+    it 'converts key to symbol' do
       value = 'thing'
       subject.add('admins', value)
       expect(source[:admins]).to eq(value)
     end
 
-    it "raises exception if key already registered" do
+    it 'raises exception if key already registered' do
       subject.add(:admins, 'thing')
 
-      expect {
+      expect do
         subject.add('admins', 'again')
-      }.to raise_error(Flipper::Registry::DuplicateKey)
+      end.to raise_error(Flipper::Registry::DuplicateKey)
     end
   end
 
-  describe "#get" do
-    context "key registered" do
+  describe '#get' do
+    context 'key registered' do
       before do
         source[:admins] = 'thing'
       end
 
-      it "returns value" do
+      it 'returns value' do
         expect(subject.get(:admins)).to eq('thing')
       end
 
-      it "returns value if given string key" do
+      it 'returns value if given string key' do
         expect(subject.get('admins')).to eq('thing')
       end
     end
 
-    context "key not registered" do
-      it "raises key not found" do
-        expect {
-          subject.get(:admins)
-        }.to raise_error(Flipper::Registry::KeyNotFound)
+    context 'key not registered' do
+      it 'returns nil' do
+        expect(subject.get(:admins)).to be(nil)
       end
     end
   end
 
-  describe "#key?" do
+  describe '#key?' do
     before do
-      source[:admins] = "admins"
+      source[:admins] = 'admins'
     end
 
-    it "returns true if the key exists" do
+    it 'returns true if the key exists' do
       expect(subject.key?(:admins)).to eq true
     end
 
-    it "returns false if the key does not exists" do
+    it 'returns false if the key does not exists' do
       expect(subject.key?(:unknown_key)).to eq false
     end
   end
 
-  describe "#each" do
+  describe '#each' do
     before do
       source[:admins] = 'admins'
       source[:devs] = 'devs'
     end
 
-    it "iterates source keys and values" do
+    it 'iterates source keys and values' do
       results = {}
       subject.each do |key, value|
         results[key] = value
       end
-      expect(results).to eq({
-              :admins => 'admins',
-              :devs => 'devs',
-            })
+      expect(results).to eq(admins: 'admins',
+                            devs: 'devs')
     end
   end
 
-  describe "#keys" do
+  describe '#keys' do
     before do
       source[:admins] = 'admins'
       source[:devs] = 'devs'
     end
 
-    it "returns the keys" do
-      expect(subject.keys.map(&:to_s).sort).to eq(['admins', 'devs'])
+    it 'returns the keys' do
+      expect(subject.keys.map(&:to_s).sort).to eq(%w(admins devs))
     end
 
-    it "returns the keys as symbols" do
+    it 'returns the keys as symbols' do
       subject.keys.each do |key|
         expect(key).to be_instance_of(Symbol)
       end
     end
   end
 
-  describe "#values" do
+  describe '#values' do
     before do
       source[:admins] = 'admins'
       source[:devs] = 'devs'
     end
 
-    it "returns the values" do
-      expect(subject.values.map(&:to_s).sort).to eq(['admins', 'devs'])
+    it 'returns the values' do
+      expect(subject.values.map(&:to_s).sort).to eq(%w(admins devs))
     end
   end
 
-  describe "enumeration" do
+  describe 'enumeration' do
     before do
       source[:admins] = 'admins'
       source[:devs] = 'devs'
     end
 
-    it "works" do
+    it 'works' do
       keys = []
       values = []
 
@@ -127,17 +123,17 @@ RSpec.describe Flipper::Registry do
         values << value
       end
 
-      expect(keys.map(&:to_s).sort).to eq(['admins', 'devs'])
-      expect(values.sort).to eq(['admins', 'devs'])
+      expect(keys.map(&:to_s).sort).to eq(%w(admins devs))
+      expect(values.sort).to eq(%w(admins devs))
     end
   end
 
-  describe "#clear" do
+  describe '#clear' do
     before do
       source[:admins] = 'admins'
     end
 
-    it "clears the source" do
+    it 'clears the source' do
       subject.clear
       expect(source).to be_empty
     end

data/spec/flipper/typecast_spec.rb

@@ -4,15 +4,15 @@ require 'flipper/typecast'
 RSpec.describe Flipper::Typecast do
   {
     nil => false,
-    "" => false,
+    '' => false,
     0 => false,
     1 => true,
-    "0" => false,
-    "1" => true,
+    '0' => false,
+    '1' => true,
     true => true,
     false => false,
-    "true" => true,
-    "false" => false,
+    'true' => true,
+    'false' => false,
   }.each do |value, expected|
     context "#to_boolean for #{value.inspect}" do
       it "returns #{expected}" do
@@ -23,11 +23,11 @@ RSpec.describe Flipper::Typecast do
 
   {
     nil => 0,
-    "" => 0,
+    '' => 0,
     0 => 0,
     1 => 1,
-    "1" => 1,
-    "99" => 99,
+    '1' => 1,
+    '99' => 99,
   }.each do |value, expected|
     context "#to_integer for #{value.inspect}" do
       it "returns #{expected}" do
@@ -38,9 +38,9 @@ RSpec.describe Flipper::Typecast do
 
   {
     nil => Set.new,
-    "" => Set.new,
+    '' => Set.new,
     Set.new([1, 2]) => Set.new([1, 2]),
-    [1, 2] => Set.new([1, 2])
+    [1, 2] => Set.new([1, 2]),
   }.each do |value, expected|
     context "#to_set for #{value.inspect}" do
       it "returns #{expected}" do
@@ -49,15 +49,15 @@ RSpec.describe Flipper::Typecast do
     end
   end
 
-  it "raises argument error for integer value that cannot be converted to an integer" do
-    expect {
-      described_class.to_integer(["asdf"])
-    }.to raise_error(ArgumentError, %Q(["asdf"] cannot be converted to an integer))
+  it 'raises argument error for integer value that cannot be converted to an integer' do
+    expect do
+      described_class.to_integer(['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
   end
 
-  it "raises argument error for set value that cannot be converted to a set" do
-    expect {
-      described_class.to_set("asdf")
-    }.to raise_error(ArgumentError, %Q("asdf" cannot be converted to a set))
+  it 'raises argument error for set value that cannot be converted to a set' do
+    expect do
+      described_class.to_set('asdf')
+    end.to raise_error(ArgumentError, %("asdf" cannot be converted to a set))
   end
 end

data/spec/flipper/types/actor_spec.rb

@@ -2,13 +2,13 @@ require 'helper'
 require 'flipper/types/actor'
 
 RSpec.describe Flipper::Types::Actor do
-  subject {
+  subject do
     thing = thing_class.new('2')
     described_class.new(thing)
-  }
+  end
 
-  let(:thing_class) {
-    Class.new {
+  let(:thing_class) do
+    Class.new do
       attr_reader :flipper_id
 
       def initialize(flipper_id)
@@ -18,37 +18,37 @@ RSpec.describe Flipper::Types::Actor do
       def admin?
         true
       end
-    }
-  }
+    end
+  end
 
-  describe ".wrappable?" do
-    it "returns true if actor" do
+  describe '.wrappable?' do
+    it 'returns true if actor' do
       thing = thing_class.new('1')
       actor = described_class.new(thing)
       expect(described_class.wrappable?(actor)).to eq(true)
     end
 
-    it "returns true if responds to flipper_id" do
+    it 'returns true if responds to flipper_id' do
       thing = thing_class.new(10)
       expect(described_class.wrappable?(thing)).to eq(true)
     end
 
-    it "returns false if nil" do
+    it 'returns false if nil' do
       expect(described_class.wrappable?(nil)).to be(false)
     end
   end
 
-  describe ".wrap" do
-    context "for actor" do
-      it "returns actor" do
+  describe '.wrap' do
+    context 'for actor' do
+      it 'returns actor' do
         actor = described_class.wrap(subject)
         expect(actor).to be_instance_of(described_class)
         expect(actor).to be(subject)
       end
     end
 
-    context "for other thing" do
-      it "returns actor" do
+    context 'for other thing' do
+      it 'returns actor' do
         thing = thing_class.new('1')
         actor = described_class.wrap(thing)
         expect(actor).to be_instance_of(described_class)
@@ -56,57 +56,58 @@ RSpec.describe Flipper::Types::Actor do
     end
   end
 
-  it "initializes with thing that responds to id" do
+  it 'initializes with thing that responds to id' do
     thing = thing_class.new('1')
     actor = described_class.new(thing)
     expect(actor.value).to eq('1')
   end
 
-  it "raises error when initialized with nil" do
-    expect {
+  it 'raises error when initialized with nil' do
+    expect do
       described_class.new(nil)
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
-  it "raises error when initalized with non-wrappable object" do
+  it 'raises error when initalized with non-wrappable object' do
     unwrappable_thing = Struct.new(:id).new(1)
-    expect {
+    expect do
       described_class.new(unwrappable_thing)
-    }.to raise_error(ArgumentError, "#{unwrappable_thing.inspect} must respond to flipper_id, but does not")
+    end.to raise_error(ArgumentError,
+                       "#{unwrappable_thing.inspect} must respond to flipper_id, but does not")
   end
 
-  it "converts id to string" do
+  it 'converts id to string' do
     thing = thing_class.new(2)
     actor = described_class.new(thing)
     expect(actor.value).to eq('2')
   end
 
-  it "proxies everything to thing" do
+  it 'proxies everything to thing' do
     thing = thing_class.new(10)
     actor = described_class.new(thing)
     expect(actor.admin?).to eq(true)
   end
 
-  it "exposes thing" do
+  it 'exposes thing' do
     thing = thing_class.new(10)
     actor = described_class.new(thing)
     expect(actor.thing).to be(thing)
   end
 
-  describe "#respond_to?" do
-    it "returns true if responds to method" do
+  describe '#respond_to?' do
+    it 'returns true if responds to method' do
       thing = thing_class.new('1')
       actor = described_class.new(thing)
       expect(actor.respond_to?(:value)).to eq(true)
     end
 
-    it "returns true if thing responds to method" do
+    it 'returns true if thing responds to method' do
       thing = thing_class.new(10)
       actor = described_class.new(thing)
       expect(actor.respond_to?(:admin?)).to eq(true)
     end
 
-    it "returns false if does not respond to method and thing does not respond to method" do
+    it 'returns false if does not respond to method and thing does not respond to method' do
       thing = thing_class.new(10)
       actor = described_class.new(thing)
       expect(actor.respond_to?(:frankenstein)).to eq(false)