flipflop 2.0.0

data/test/unit/feature_set_test.rb

@@ -0,0 +1,136 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class NullStrategy < Flipflop::Strategies::AbstractStrategy
+  def enabled?(feature)
+  end
+end
+
+class TrueStrategy < Flipflop::Strategies::AbstractStrategy
+  def enabled?(feature)
+    true
+  end
+end
+
+class FalseStrategy < Flipflop::Strategies::AbstractStrategy
+  def enabled?(feature)
+    false
+  end
+end
+
+describe Flipflop::FeatureSet do
+  subject do
+    Flipflop::FeatureSet.current.reset!
+    Flipflop::FeatureSet.current.tap do |set|
+      set.add(Flipflop::FeatureDefinition.new(:one))
+    end
+  end
+
+  describe "current" do
+    it "should return same instance" do
+      current = subject
+      assert_equal current, Flipflop::FeatureSet.current
+    end
+
+    it "should return same instance in different thread" do
+      current = subject
+      assert_equal current, Thread.new { Flipflop::FeatureSet.current }.value
+    end
+  end
+
+  describe "test" do
+    it "should freeze strategies" do
+      subject.test!
+      assert_raises RuntimeError do
+        subject.use(Flipflop::Strategies::AbstractStrategy.new)
+      end
+    end
+
+    it "should replace strategies with test strategy" do
+      subject.test!
+      assert_equal [Flipflop::Strategies::TestStrategy], subject.strategies.map(&:class)
+    end
+
+    it "should replace strategies with given strategy" do
+      subject.test!(Flipflop::Strategies::LambdaStrategy.new)
+      assert_equal [Flipflop::Strategies::LambdaStrategy], subject.strategies.map(&:class)
+    end
+
+    it "should return test strategy" do
+      returned = subject.test!(strategy = Flipflop::Strategies::LambdaStrategy.new)
+      assert_equal strategy, returned
+    end
+  end
+
+  describe "enabled" do
+    it "should return false by default" do
+      subject.use(NullStrategy.new)
+      assert_equal false, subject.enabled?(:one)
+    end
+
+    it "should return value of next true strategy if unknown" do
+      subject.use(NullStrategy.new)
+      subject.use(TrueStrategy.new)
+      assert_equal true, subject.enabled?(:one)
+    end
+
+    it "should return value of next false strategy if unknown" do
+      subject.use(NullStrategy.new)
+      subject.use(FalseStrategy.new)
+      assert_equal false, subject.enabled?(:one)
+    end
+
+    it "should stop resolving at first true value" do
+      subject.use(TrueStrategy.new)
+      subject.use(FalseStrategy.new)
+      subject.use(NullStrategy.new)
+      assert_equal true, subject.enabled?(:one)
+    end
+
+    it "should stop resolving at first false value" do
+      subject.use(FalseStrategy.new)
+      subject.use(TrueStrategy.new)
+      subject.use(NullStrategy.new)
+      assert_equal false, subject.enabled?(:one)
+    end
+  end
+
+  describe "add" do
+    it "should add feature" do
+      subject.add(feature = Flipflop::FeatureDefinition.new(:feature))
+      assert_equal feature, subject.feature(feature.key)
+    end
+
+    it "should freeze feature" do
+      subject.add(feature = Flipflop::FeatureDefinition.new(:feature))
+      assert subject.feature(feature.key).frozen?
+    end
+  end
+
+  describe "use" do
+    it "should add strategy" do
+      subject.use(strategy = NullStrategy.new)
+      assert_equal strategy, subject.strategy(strategy.key)
+    end
+
+    it "should freeze strategy" do
+      subject.use(strategy = NullStrategy.new)
+      assert subject.strategy(strategy.key).frozen?
+    end
+  end
+
+  describe "feature" do
+    it "should raise if feature is unknown" do
+      assert_raises Flipflop::FeatureError do
+        subject.feature(:unknown)
+      end
+    end
+  end
+
+  describe "strategy" do
+    it "should raise if strategy is unknown" do
+      assert_raises Flipflop::StrategyError do
+        subject.strategy("12345")
+      end
+    end
+  end
+end

data/test/unit/flipflop_test.rb

@@ -0,0 +1,99 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+describe Flipflop do
+  before do
+    Flipflop.configure do
+      feature :one, default: true
+      feature :two, default: false
+    end
+  end
+
+  describe "configure" do
+    before do
+      Flipflop.configure do
+        feature :config_feature, default: true
+      end
+    end
+
+    it "should reset feature set" do
+      Flipflop.configure do
+      end
+      assert_equal [], Flipflop::FeatureSet.current.features
+    end
+
+    it "should add features" do
+      assert_equal [:config_feature],
+        Flipflop::FeatureSet.current.features.map(&:key)
+    end
+
+    it "should freeze features" do
+      assert_raises RuntimeError do
+        Flipflop::FeatureSet.current.add(Flipflop::FeatureDefinition.new(:foo))
+      end
+    end
+
+    it "should freeze strategies" do
+      assert_raises RuntimeError do
+        Flipflop::FeatureSet.current.use(Flipflop::Strategies::AbstractStrategy.new)
+      end
+    end
+  end
+
+  describe "enabled?" do
+    it "should return true for enabled features" do
+      assert_equal true, Flipflop.on?(:one)
+    end
+
+    it "should return false for disabled features" do
+      assert_equal false, Flipflop.on?(:two)
+    end
+
+    it "should call strategy once if cached" do
+      called = 0
+      counter = Class.new(Flipflop::Strategies::AbstractStrategy) do
+        define_method :enabled? do |feature|
+          called += 1
+          false
+        end
+      end
+
+      Flipflop.configure do
+        strategy counter
+        feature :one, default: true
+      end
+
+      begin
+        Flipflop::FeatureCache.current.enable!
+        Flipflop.on?(:one)
+        Flipflop.on?(:one)
+        assert_equal 1, called
+      ensure
+        Flipflop::FeatureCache.current.disable!
+      end
+    end
+  end
+
+  describe "dynamic predicate method" do
+    it "should respond to feature predicate" do
+      assert Flipflop.respond_to?(:one?)
+    end
+
+    it "should not respond to incorrectly formatted predicate" do
+      refute Flipflop.respond_to?(:foobar!)
+    end
+
+    it "should return true for enabled features" do
+      assert_equal true, Flipflop.one?
+    end
+
+    it "should return false for disabled features" do
+      assert_equal false, Flipflop.two?
+    end
+
+    it "raises error for incorrectly formatted predicate" do
+      assert_raises NoMethodError do
+        Flipflop.foobar!
+      end
+    end
+  end
+end

data/test/unit/strategies/abstract_strategy_request_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+describe Flipflop::Strategies::AbstractStrategy::RequestInterceptor do
+  subject do
+    Class.new(ActionController::Metal) do
+      class << self
+        attr_accessor :request
+      end
+
+      include AbstractController::Callbacks
+      include Flipflop::Strategies::AbstractStrategy::RequestInterceptor
+
+      def index
+        self.class.request = Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request
+      end
+    end
+  end
+
+  after do
+    Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
+  end
+
+  it "should add before filter to controller" do
+    filters = subject._process_action_callbacks.select { |f| f.kind == :before }
+    assert_equal 1, filters.length
+  end
+
+  it "should add after filter to controller" do
+    filters = subject._process_action_callbacks.select { |f| f.kind == :after }
+    assert_equal 1, filters.length
+  end
+
+  it "should set request" do
+    subject.action(:index).call({})
+    assert_instance_of ActionDispatch::Request, subject.request
+  end
+
+  it "should clear request" do
+    subject.action(:index).call({})
+    assert_nil Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request
+  end
+end

data/test/unit/strategies/abstract_strategy_test.rb

@@ -0,0 +1,124 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+describe Flipflop::Strategies::AbstractStrategy do
+  after do
+    Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
+  end
+
+  describe "with defaults" do
+    subject do
+      Flipflop::Strategies::AbstractStrategy.new.freeze
+    end
+
+    it "should have default name" do
+      assert_equal "abstract", subject.name
+    end
+
+    it "should have no default description" do
+      assert_nil subject.description
+    end
+
+    it "should not be switchable" do
+      assert_equal false, subject.switchable?
+    end
+
+    it "should not be hidden" do
+      assert_equal false, subject.hidden?
+    end
+
+    it "should have unique key" do
+      assert_match /^\d+$/, subject.key
+    end
+
+    describe "request" do
+      it "should return request" do
+        Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = 3
+        assert_equal 3, subject.send(:request)
+      end
+
+      it "should raise if request is missing" do
+        Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
+        assert_raises Flipflop::StrategyError do
+          subject.send(:request)
+        end
+      end
+
+      it "should raise with message if request is missing" do
+        Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
+        message = nil
+        begin
+          subject.send(:request)
+        rescue => err
+          message = err.message
+        end
+        assert_equal "Strategy 'abstract' required request, but was used outside request context.", message
+      end
+
+      it "should raise if request is missing in thread" do
+        Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = 3
+        assert_raises Flipflop::StrategyError do
+          Thread.new { subject.send(:request) }.value
+        end
+      end
+    end
+
+    describe "request predicate" do
+      it "should return true if request is present" do
+        Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = 3
+        assert_equal true, subject.send(:request?)
+      end
+
+      it "should return false if request is missing" do
+        Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
+        assert_equal false, subject.send(:request?)
+      end
+    end
+  end
+
+  describe "with options" do
+    subject do
+      Flipflop::Strategies::AbstractStrategy.new(
+        name: "strategy",
+        description: "my strategy",
+        hidden: true,
+      ).freeze
+    end
+
+    it "should have specified name" do
+      assert_equal "strategy", subject.name
+    end
+
+    it "should have specified description" do
+      assert_equal "my strategy", subject.description
+    end
+
+    it "should be hidden" do
+      assert_equal true, subject.hidden?
+    end
+  end
+
+  describe "with unknown options" do
+    subject do
+      Flipflop::Strategies::AbstractStrategy.new(
+        unknown: "one",
+        other: "two",
+      ).freeze
+    end
+
+    it "should raise error" do
+      assert_raises Flipflop::StrategyError do
+        subject
+      end
+    end
+
+    it "should raise with message" do
+      message = nil
+      begin
+        subject
+      rescue => err
+        message = err.message
+      end
+      assert_equal "Strategy 'abstract' did not understand option :unknown, :other.", message
+    end
+  end
+end

data/test/unit/strategies/active_record_strategy_test.rb

@@ -0,0 +1,157 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class ResultSet
+  def initialize(key, results = [])
+    @key, @results = key, results
+  end
+
+  def first_or_initialize
+    @results.first or My::Feature.new(@key, false)
+  end
+
+  def first
+    @results.first
+  end
+end
+
+module My
+  class Feature < Struct.new(:key, :enabled)
+    class << self
+      attr_accessor :results
+
+      def where(conditions)
+        results[conditions[:key].to_sym]
+      end
+    end
+
+    alias_method :enabled?, :enabled
+
+    def destroy
+      My::Feature.results[key] = ResultSet.new(key)
+    end
+
+    def save!
+      My::Feature.results[key] = ResultSet.new(key, [self])
+    end
+  end
+end
+
+describe Flipflop::Strategies::ActiveRecordStrategy do
+  describe "with defaults" do
+    subject do
+      Flipflop::Strategies::ActiveRecordStrategy.new(class: My::Feature).freeze
+    end
+
+    it "should have default name" do
+      assert_equal "active_record", subject.name
+    end
+
+    it "should have default description" do
+      assert_equal "Stores features in database. Applies to all users.",
+        subject.description
+    end
+
+    it "should be switchable" do
+      assert_equal true, subject.switchable?
+    end
+
+    it "should have unique key" do
+      assert_match /^\d+$/, subject.key
+    end
+
+    describe "with enabled feature" do
+      before do
+        My::Feature.results = {
+          one: ResultSet.new(:one, [My::Feature.new(:one, true)]),
+        }
+      end
+
+      it "should have feature enabled" do
+        assert_equal true, subject.enabled?(:one)
+      end
+
+      it "should be able to switch feature off" do
+        subject.switch!(:one, false)
+        assert_equal false, subject.enabled?(:one)
+      end
+
+      it "should be able to clear feature" do
+        subject.clear!(:one)
+        assert_nil subject.enabled?(:one)
+      end
+    end
+
+    describe "with disabled feature" do
+      before do
+        My::Feature.results = {
+          two: ResultSet.new(:two, [My::Feature.new(:two, false)]),
+        }
+      end
+
+      it "should not have feature enabled" do
+        assert_equal false, subject.enabled?(:two)
+      end
+
+      it "should be able to switch feature on" do
+        subject.switch!(:two, true)
+        assert_equal true, subject.enabled?(:two)
+      end
+
+      it "should be able to clear feature" do
+        subject.clear!(:two)
+        assert_nil subject.enabled?(:two)
+      end
+    end
+
+    describe "with unsaved feature" do
+      before do
+        My::Feature.results = {
+          three: ResultSet.new(:three),
+        }
+      end
+
+      it "should not know feature" do
+        assert_nil subject.enabled?(:three)
+      end
+
+      it "should be able to switch feature on" do
+        subject.switch!(:three, true)
+        assert_equal true, subject.enabled?(:three)
+      end
+    end
+  end
+
+  describe "with string class name" do
+    subject do
+      Flipflop::Strategies::ActiveRecordStrategy.new(class: "My::Feature").freeze
+    end
+
+    before do
+      My::Feature.results = {
+        one: ResultSet.new(:one, [My::Feature.new(:one, true)]),
+      }
+    end
+
+    it "should be able to switch feature off" do
+      subject.switch!(:one, false)
+      assert_equal false, subject.enabled?(:one)
+    end
+  end
+
+  describe "with symbol class name" do
+    subject do
+      Flipflop::Strategies::ActiveRecordStrategy.new(class: :"My::Feature").freeze
+    end
+
+    before do
+      My::Feature.results = {
+        one: ResultSet.new(:one, [My::Feature.new(:one, true)]),
+      }
+    end
+
+    it "should be able to switch feature off" do
+      subject.switch!(:one, false)
+      assert_equal false, subject.enabled?(:one)
+    end
+  end
+end

data/test/unit/strategies/cookie_strategy_test.rb

@@ -0,0 +1,126 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+describe Flipflop::Strategies::CookieStrategy do
+  subject do
+    Flipflop::Strategies::CookieStrategy.new.freeze
+  end
+
+  describe "in request context" do
+    before do
+      Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = create_request
+    end
+
+    after do
+      Flipflop::Strategies::AbstractStrategy::RequestInterceptor.request = nil
+    end
+
+    it "should have default name" do
+      assert_equal "cookie", subject.name
+    end
+
+    it "should have default description" do
+      assert_equal "Stores features in a browser cookie. Applies to current user.",
+        subject.description
+    end
+
+    it "should be switchable" do
+      assert_equal true, subject.switchable?
+    end
+
+    it "should have unique key" do
+      assert_match /^\d+$/, subject.key
+    end
+
+    describe "with enabled feature" do
+      before do
+        subject.send(:request).cookie_jar[subject.send(:cookie_name, :one)] = "1"
+      end
+
+      it "should have feature enabled" do
+        assert_equal true, subject.enabled?(:one)
+      end
+
+      it "should be able to switch feature off" do
+        subject.switch!(:one, false)
+        assert_equal false, subject.enabled?(:one)
+      end
+
+      it "should be able to clear feature" do
+        subject.clear!(:one)
+        assert_nil subject.enabled?(:one)
+      end
+    end
+
+    describe "with disabled feature" do
+      before do
+        subject.send(:request).cookie_jar[subject.send(:cookie_name, :two)] = "0"
+      end
+
+      it "should not have feature enabled" do
+        assert_equal false, subject.enabled?(:two)
+      end
+
+      it "should be able to switch feature on" do
+        subject.switch!(:two, true)
+        assert_equal true, subject.enabled?(:two)
+      end
+
+      it "should be able to clear feature" do
+        subject.clear!(:two)
+        assert_nil subject.enabled?(:two)
+      end
+    end
+
+    describe "with uncookied feature" do
+      it "should not know feature" do
+        assert_nil subject.enabled?(:three)
+      end
+
+      it "should be able to switch feature on" do
+        subject.switch!(:three, true)
+        assert_equal true, subject.enabled?(:three)
+      end
+    end
+
+    describe "with options" do
+      subject do
+        Flipflop::Strategies::CookieStrategy.new(
+          domain: :all,
+          path: "/foo",
+          httponly: true,
+        ).freeze
+      end
+
+      it "should pass options when setting value" do
+        subject.switch!(:one, true)
+        subject.send(:request).cookie_jar.write(headers = {})
+        assert_equal "flipflop_one=1; domain=.example.com; path=/foo; HttpOnly",
+          headers["Set-Cookie"]
+      end
+
+      it "should pass options when deleting value" do
+        subject.switch!(:one, true)
+        subject.clear!(:one)
+        subject.send(:request).cookie_jar.write(headers = {})
+        assert_equal "flipflop_one=; domain=.example.com; path=/foo; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000; HttpOnly",
+          headers["Set-Cookie"]
+      end
+    end
+  end
+
+  describe "outside request context" do
+    it "should not know feature" do
+      assert_nil subject.enabled?(:one)
+    end
+
+    it "should not be switchable" do
+      assert_equal false, subject.switchable?
+    end
+
+    it "should not be able to switch feature on" do
+      assert_raises Flipflop::StrategyError do
+        subject.switch!(:one, true)
+      end
+    end
+  end
+end