flip_fab 0.0.1

data/spec/lib/flip_fab/contextual_feature_spec.rb

@@ -0,0 +1,352 @@
+module FlipFab
+  describe ContextualFeature do
+    let(:override)             {  }
+    let(:default)              { :disabled }
+    let(:persistence_adapters) { [TestPersistence] }
+    let(:feature)              { Feature.new :example_feature, { default: default, persistence_adapters: persistence_adapters } }
+    let(:feature_states)       {{ example_feature: :enabled }}
+    let(:context)              { TestContext.new feature_states, { 'example_feature' => override } }
+    subject{ described_class.new feature, context }
+
+    describe '.new' do
+
+      it 'assigns the feature' do
+        expect(subject.feature).to eq(feature)
+      end
+
+      it 'assigns the context' do
+        expect(subject.context).to eq(context)
+      end
+
+      context 'when the feature has been overridden' do
+        let(:override) { 'disabled' }
+
+        it 'persists the override' do
+          expect{ subject }.to change{ feature_states }.from({ example_feature: :enabled }).to({ example_feature: :disabled })
+        end
+
+        context 'when the override provided is not one of enabled or disabled, it does not persist the override' do
+          let(:override) { '' }
+
+          it 'does not persist the override' do
+            expect{ subject }.not_to change{ feature_states }.from({ example_feature: :enabled })
+          end
+        end
+      end
+    end
+
+    describe '#enabled?' do
+
+      context 'when the feature is enabled in the adapter' do
+        let(:feature_states) {{ example_feature: :enabled }}
+
+        it 'returns true' do
+          expect(subject.enabled?).to be_truthy
+        end
+
+        context 'when the feature has been overridden' do
+          let(:override) { 'disabled' }
+
+          it 'returns false' do
+            expect(subject.enabled?).to be_falsey
+          end
+        end
+      end
+
+      context 'when the feature is disabled in the adapter' do
+        let(:feature_states) {{ example_feature: :disabled }}
+
+        it 'returns false' do
+          expect(subject.enabled?).to be_falsey
+        end
+      end
+
+      context 'when the feature is not specified in the adapter' do
+        let(:feature_states) {{ }}
+
+        context 'when the default is :enabled' do
+          let(:default) { :enabled }
+
+          it 'returns true' do
+            expect(subject.enabled?).to be_truthy
+          end
+        end
+
+        context 'when the default is :disabled' do
+          let(:default) { :disabled }
+
+          it 'returns false' do
+            expect(subject.enabled?).to be_falsey
+          end
+        end
+      end
+
+      context 'when there are multiple adapters' do
+        let(:persistence_adapters) { [TestPersistence, TestMultiplePersistence] }
+
+        context 'when the first adapter has enabled and the second adapter has nil' do
+          let(:feature_states) {{ example_feature: :enabled, different_example_feature: nil }}
+
+          it 'returns true' do
+            expect(subject.enabled?).to be_truthy
+          end
+        end
+
+        context 'when the first adapter has nil and the second adapter has enabled' do
+          let(:feature_states) {{ example_feature: nil, different_example_feature: :enabled }}
+
+          it 'returns true' do
+            expect(subject.enabled?).to be_truthy
+          end
+        end
+
+        context 'when the first adapter has disabled and the second adapter has enabled' do
+          let(:feature_states) {{ example_feature: :disabled, different_example_feature: :enabled }}
+
+          it 'returns false' do
+            expect(subject.enabled?).to be_falsey
+          end
+        end
+      end
+    end
+
+    describe '#disabled?' do
+
+      context 'when #enabled? returns true' do
+        let(:feature_states) {{ example_feature: :enabled }}
+
+        it 'returns false' do
+          expect(subject.disabled?).to be_falsey
+        end
+      end
+
+      context 'when #enabled? returns false' do
+        let(:feature_states) {{ example_feature: :disabled }}
+
+        it 'returns true' do
+          expect(subject.disabled?).to be_truthy
+        end
+      end
+    end
+
+    describe '#state=' do
+
+      context 'when the provided value is not :enabled or :disabled' do
+
+        it 'raises' do
+          expect{ subject.state = '' }.to raise_error 'Invalid state provided: ``, possible states are :enabled, :disabled'
+          expect{ subject.state = 'enabled' }.to raise_error 'Invalid state provided: `enabled`, possible states are :enabled, :disabled'
+        end
+      end
+
+      context 'when the provided value is :enabled or :disabled' do
+
+        it 'changes the state of the feature' do
+          expect{ subject.state = :disabled }.to change{subject.enabled?}.from(true).to(false)
+          expect{ subject.state = :enabled }.to change{subject.enabled?}.from(false).to(true)
+        end
+      end
+    end
+
+    describe '#enable' do
+
+      context 'when the state has been overridden' do
+        let(:override) { 'disabled' }
+
+        context 'and the persistence adapter has the opposite state' do
+          let(:feature_states) {{ example_feature: :disabled }}
+
+          it 'does not change the state of the feature' do
+            expect{subject.enable}.not_to change{subject.enabled?}.from(false)
+          end
+
+          it 'does not persist the state in the adapter' do
+            expect_any_instance_of(TestPersistence).not_to receive(:write).with(:enabled)
+            subject.enable
+          end
+        end
+      end
+
+      context 'when there are multiple persistence adapters' do
+        let(:persistence_adapters) { [TestPersistence, TestMultiplePersistence] }
+        let(:feature_states) {{ example_feature: :disabled, different_example_feature: :disabled }}
+
+        it 'changes the state of the feature' do
+          expect{subject.enable}.to change{subject.enabled?}.from(false).to(true)
+        end
+
+        it 'persists the state in the adapters' do
+          expect{ subject.enable }.to change{ feature_states }.from({ example_feature: :disabled, different_example_feature: :disabled }).to({ example_feature: :enabled, different_example_feature: :enabled })
+        end
+      end
+
+      context 'when there is a persistence adapter' do
+        let(:persistence_adapters) { [TestPersistence] }
+
+        context 'and the persistence adapter has the same state' do
+          let(:feature_states) {{ example_feature: :enabled }}
+
+          it 'does not change the state of the feature' do
+            expect{subject.enable}.not_to change{subject.enabled?}.from(true)
+          end
+        end
+
+        context 'and the persistence adapter has the opposite state' do
+          let(:feature_states) {{ example_feature: :disabled }}
+
+          it 'changes the state of the feature' do
+            expect{subject.enable}.to change{subject.enabled?}.from(false).to(true)
+          end
+
+          it 'persists the state in the adapter' do
+            expect{ subject.enable }.to change{ feature_states }.from({ example_feature: :disabled }).to({ example_feature: :enabled })
+          end
+        end
+
+        context 'and the persistence adapter has no state' do
+          let(:feature_states) {{ }}
+
+          context 'and the feature is disabled' do
+            let(:default) { :disabled }
+
+            it 'changes the state of the feature' do
+              expect{subject.enable}.to change{subject.enabled?}.from(false).to(true)
+            end
+
+            it 'persists the state in the adapter' do
+              expect{ subject.enable }.to change{ feature_states }.from({ }).to({ example_feature: :enabled })
+            end
+          end
+
+          context 'and the feature is enabled' do
+            let(:default) { :enabled }
+
+            it 'does not change the state of the feature' do
+              expect{subject.enable}.not_to change{subject.enabled?}.from(true)
+            end
+
+            it 'persists the state in the adapter' do
+              expect{ subject.enable }.to change{ feature_states }.from({ }).to({ example_feature: :enabled })
+            end
+          end
+        end
+
+        context 'when there is not a persistence adapter' do
+          let(:persistence_adapters) { [] }
+
+          context 'and the feature is enabled' do
+            let(:default) { :enabled }
+
+            it 'does not change the state of the feature' do
+              expect{subject.enable}.not_to change{subject.enabled?}.from(true)
+            end
+          end
+
+          context 'and the feature is disabled' do
+            let(:default) { :disabled }
+
+            it 'changes the state of the feature' do
+              expect{subject.enable}.to change{subject.enabled?}.from(false).to(true)
+            end
+          end
+        end
+      end
+    end
+
+
+    describe '#disable' do
+
+      context 'when the state has been overridden' do
+        let(:override) { 'enabled' }
+
+        context 'and the persistence adapter has the opposite state' do
+          let(:feature_states) {{ example_feature: :enabled }}
+
+          it 'does not change the state of the feature' do
+            expect{subject.disable}.not_to change{subject.disabled?}.from(false)
+          end
+
+          it 'does not persist the state in the adapter' do
+            expect_any_instance_of(TestPersistence).not_to receive(:write).with(:disabled)
+            subject.disable
+          end
+        end
+      end
+
+      context 'when there is a persistence adapter' do
+        let(:persistence_adapters) { [TestPersistence] }
+
+        context 'and the persistence adapter has the same state' do
+          let(:feature_states) {{ example_feature: :disabled }}
+
+          it 'does not change the state of the feature' do
+            expect{subject.disable}.not_to change{subject.disabled?}.from(true)
+          end
+        end
+
+        context 'and the persistence adapter has the opposite state' do
+          let(:feature_states) {{ example_feature: :enabled }}
+
+          it 'changes the state of the feature' do
+            expect{subject.disable}.to change{subject.disabled?}.from(false).to(true)
+          end
+
+          it 'persists the state in the adapter' do
+            expect_any_instance_of(TestPersistence).to receive(:write).with(:disabled)
+            subject.disable
+          end
+        end
+
+        context 'and the persistence adapter has no state' do
+          let(:feature_states) {{ }}
+
+          context 'and the feature is enabled' do
+            let(:default) { :enabled }
+
+            it 'changes the state of the feature' do
+              expect{subject.disable}.to change{subject.disabled?}.from(false).to(true)
+            end
+
+            it 'persists the state in the adapter' do
+              expect_any_instance_of(TestPersistence).to receive(:write).with(:disabled)
+              subject.disable
+            end
+          end
+
+          context 'and the feature is disabled' do
+            let(:default) { :disabled }
+
+            it 'does not change the state of the feature' do
+              expect{subject.disable}.not_to change{subject.disabled?}.from(true)
+            end
+
+            it 'persists the state in the adapter' do
+              expect_any_instance_of(TestPersistence).to receive(:write).with(:disabled)
+              subject.disable
+            end
+          end
+        end
+
+        context 'when there is not a persistence adapter' do
+          let(:persistence_adapters) { [] }
+
+          context 'and the feature is disabled' do
+            let(:default) { :disabled }
+
+            it 'does not change the state of the feature' do
+              expect{subject.disable}.not_to change{subject.disabled?}.from(true)
+            end
+          end
+
+          context 'and the feature is enabled' do
+            let(:default) { :enabled }
+
+            it 'changes the state of the feature' do
+              expect{subject.disable}.to change{subject.disabled?}.from(false).to(true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/flip_fab/cookie_persistence.feature

@@ -0,0 +1,50 @@
+Feature: Persisting the feature state in a cookie
+
+  Background:
+    Given the host is 'www.simplybusiness.co.uk'
+      And the feature name is 'example_feature'
+      And the time is '2015-01-22 15:26:31 +0000'
+      And the state of the feature is 'enabled'
+
+  Scenario: The cookie should apply to the root path (/)
+    When I persist the feature state in a cookie
+    Then the cookie has the path '/'
+
+  Scenario Outline: The cookie should apply for all domains under the top-level domain (no domain for localhost or IP addresses, however)
+    Given the host is '<host>'
+     When I persist the feature state in a cookie
+     Then the cookie has the domain '<cookie domain>'
+
+    Examples:
+      | host                           | cookie domain         |
+      | localhost                      |                       |
+      | 127.0.0.1                      |                       |
+      | 192.168.2.40                   |                       |
+      | www.simplybusiness.co.uk       | .simplybusiness.co.uk |
+      | www.quote.simplybusiness.co.uk | .simplybusiness.co.uk |
+      | simplybusiness.co.uk           | .simplybusiness.co.uk |
+      | www.simplybusiness.com         | .simplybusiness.com   |
+
+  Scenario Outline: The cookie should be named using the name of the gem and name of feature, concatenated with a dot
+    Given the feature name is '<feature name>'
+     When I persist the feature state in a cookie
+     Then the cookie has the name '<cookie name>'
+
+    Examples:
+      | feature name           | cookie name                     |
+      | cool_new_feature       | flip_fab.cool_new_feature       |
+      | other_cool_new_feature | flip_fab.other_cool_new_feature |
+
+  Scenario: The cookie should expire after 1 year
+    When I persist the feature state in a cookie
+    Then the cookie expires at 'Fri, 22 Jan 2016 15:26:31 -0000'
+
+  Scenario Outline: The cookie's value should be the state of the feature
+   Given the state of the feature is '<feature state>'
+    When I persist the feature state in a cookie
+    Then the cookie value is '<feature state>'
+
+   Examples:
+     | feature state |
+     | enabled       |
+     | disabled      |

data/spec/lib/flip_fab/cookie_persistence_spec.rb

@@ -0,0 +1,90 @@
+require 'rack'
+require 'timecop'
+
+module FlipFab
+  describe CookiePersistence do
+    let(:cookies) { }
+    let(:context) { TestRackContext.new cookies, 'simplybusiness.co.uk' }
+    before { FlipFab.define_feature :example_feature }
+    after  { FlipFab.features.clear }
+    subject{ described_class.new :example_feature, context }
+
+    it 'runs the feature' do
+      feature
+    end
+
+    step 'the host is :host' do |host|
+      @host = host
+    end
+
+    step 'the feature name is :feature_name' do |feature_name|
+      @feature_name = feature_name
+    end
+
+    step 'the time is :current_time' do |current_time|
+      Timecop.freeze(Time.parse current_time)
+    end
+
+    step 'the state of the feature is :feature_state' do |feature_state|
+      @feature_state = feature_state
+    end
+
+    step 'I persist the feature state in a cookie' do
+      context = TestRackContext.new '', @host
+      (described_class.new @feature_name, context).write @feature_state
+      @cookie = context.response_cookies
+    end
+
+    step 'the cookie has the path :path' do |path|
+      expect(@cookie).to match(/path=#{path};/)
+    end
+
+    step 'the cookie has the domain :domain' do |domain|
+      if domain == ''
+        expect(@cookie).not_to match(/domain/)
+      else
+        expect(@cookie).to match(/domain=#{domain};/)
+      end
+    end
+
+    step 'the cookie has the name :name' do |name|
+      expect(@cookie).to match(/\A#{name}.*/)
+    end
+
+    step 'the cookie expires at :expiration' do |expiration|
+      expect(@cookie).to match(/expires=#{expiration}\Z/)
+    end
+
+    step 'the cookie value is :value' do |value|
+      expect(@cookie).to match(/\=#{value};/)
+    end
+
+    describe '#read' do
+
+      context 'when there is no existing cookie' do
+        let(:cookies) { }
+
+        it 'returns nil' do
+          expect(subject.read).to be_nil
+        end
+      end
+
+      context 'when the feature state is defined in the cookie' do
+        let(:cookies) { 'flip_fab.example_feature=enabled' }
+
+        it 'returns the feature state' do
+          expect(subject.read).to eq(:enabled)
+        end
+      end
+    end
+
+    describe '#write' do
+      before { Timecop.freeze(Time.local(1990)) }
+      after  { Timecop.return }
+
+      it 'saves the feature state' do
+        expect{ subject.write :enabled }.to change{ context.response_cookies }.from(nil).to('flip_fab.example_feature=enabled; domain=.simplybusiness.co.uk; path=/; expires=Tue, 01 Jan 1991 00:00:00 -0000')
+      end
+    end
+  end
+end

data/spec/lib/flip_fab/feature_spec.rb

@@ -0,0 +1,86 @@
+module FlipFab
+  describe Feature do
+    let(:name) { :example_test }
+    let(:options) {{ default: :enabled, persistence_adapters: [] }}
+    subject { described_class.new name, options }
+
+    describe '.new' do
+
+      it 'assigns the name' do
+        expect(subject.name).to eq(:example_test)
+      end
+
+      it 'assigns the default' do
+        expect(subject.default).to eq(:enabled)
+      end
+
+      it 'assigns the persistence adapters' do
+        expect(subject.persistence_adapters).to eq([])
+      end
+
+      context 'when the default is not provided' do
+        let(:options) { {} }
+
+        it 'assigns the default to :disabled' do
+          expect(subject.default).to eq(:disabled)
+        end
+      end
+
+      context 'when the persistence adapters are not provided' do
+        let(:options) { {} }
+
+        it 'uses a cookie adapter' do
+          expect(subject.persistence_adapters).to eq([CookiePersistence])
+        end
+      end
+    end
+
+    describe '#enabled?' do
+
+      context 'when the feature is enabled' do
+        let(:options) {{ default: :enabled, persistence_adapters: [] }}
+
+        it 'returns true' do
+          expect(subject.enabled?).to be_truthy
+        end
+      end
+
+      context 'when the feature is disabled' do
+        let(:options) {{ default: :disabled, persistence_adapters: [] }}
+
+        it 'returns false' do
+          expect(subject.enabled?).to be_falsey
+        end
+      end
+    end
+
+    describe '#disabled?' do
+
+      context 'when the feature is disabled' do
+        let(:options) {{ default: :disabled, persistence_adapters: [] }}
+
+        it 'returns true' do
+          expect(subject.disabled?).to be_truthy
+        end
+      end
+
+      context 'when the feature is enabled' do
+        let(:options) {{ default: :enabled, persistence_adapters: [] }}
+
+        it 'returns false' do
+          expect(subject.disabled?).to be_falsey
+        end
+      end
+    end
+
+    describe '#with_context' do
+      let(:context) { double(:context) }
+
+      it 'returns a contextual feature' do
+        expect(subject.with_context context).to be_a ContextualFeature
+        expect((subject.with_context context).feature).to eq(subject)
+        expect((subject.with_context context).context).to eq(context)
+      end
+    end
+  end
+end

data/spec/lib/flip_fab/features_by_name_spec.rb

@@ -0,0 +1,34 @@
+module FlipFab
+  describe FeaturesByName do
+    let(:feature)  { Feature.new :example_feature }
+    let(:features) { { example_feature: feature } }
+    subject{ described_class.new features }
+
+    describe '#[]' do
+
+      context 'when the feature exists' do
+
+        it 'returns the feature' do
+          expect(subject[:example_feature]).to eq(feature)
+        end
+      end
+
+      context 'when the feature does not exist' do
+
+        it 'raises' do
+          expect{ subject[:no_feature] }.to raise_error 'no feature has been defined with the name: no_feature'
+        end
+      end
+    end
+
+    describe '#with_context' do
+      let(:context) { double(:context) }
+
+      it 'returns contextual features by name' do
+        expect(subject.with_context context).to be_a described_class
+        expect((subject.with_context context)[:example_feature]).to be_a ContextualFeature
+        expect((subject.with_context context)[:example_feature].feature).to eq(feature)
+      end
+    end
+  end
+end

data/spec/lib/flip_fab/helper.feature

@@ -0,0 +1,31 @@
+Feature: Feature flipping in the context of a request, session, etc.
+
+  Scenario Outline: A feature can be flipped and remains flipped in the provided context
+    Given there is a feature with a default state of '<default_state>'
+      And there are two contexts
+     Then the feature is '<default_state>' in the first context, '<default_state>' in the second context
+     When I 'enable' the feature in the first context
+     Then the feature is 'enabled' in the first context, '<default_state>' in the second context
+     When I 'disable' the feature in the first context
+     Then the feature is 'disabled' in the first context, '<default_state>' in the second context
+
+    Examples:
+      | default_state |
+      |       enabled |
+      |      disabled |
+
+  Scenario Outline: A feature's state can be set in the URL parameters and remains in that state for that user
+    Given there is a feature with a default state of '<default_state>' with cookie persistence
+     When I override the state in the URL parameters with '<overridden_state>'
+     Then the feature is '<overridden_state>' for the user
+     When I 'enable' the feature for the user
+     Then the feature is '<overridden_state>' for the user
+     When I 'disable' the feature for the user
+     Then the feature is '<overridden_state>' for the user
+
+    Examples:
+      | default_state | overridden_state |
+      |       enabled |          enabled |
+      |      disabled |         disabled |
+      |       enabled |         disabled |
+      |      disabled |          enabled |