flipper 0.4.0 → 0.5.0

data/lib/flipper/instrumentation/log_subscriber.rb

@@ -10,7 +10,7 @@ module Flipper
       # Example Output
       #
       #   flipper[:search].enabled?(user)
-      #   # Flipper feature(search) enabled? false (1.2ms)  [ thing=#<struct flipper_id="1"> ]
+      #   # Flipper feature(search) enabled? false (1.2ms)  [ thing=... ]
       #
       # Returns nothing.
       def feature_operation(event)
@@ -39,36 +39,28 @@ module Flipper
       # Example Output
       #
       #   # log output for adapter operation with feature
-      #   # Flipper feature(search) adapter(memory) set_add("search/actors") (0.0ms)  [ result=#<Set: {"1"}> value="1" ]
+      #   # Flipper feature(search) adapter(memory) enable  (0.0ms)  [ result=...]
       #
       #   # log output for adapter operation with no feature
-      #   # Flipper adapter(memory) set_add("features") (0.0ms)  [ result=#<Set: {"search"}> value="search" ]
+      #   # Flipper adapter(memory) features (0.0ms)  [ result=... ]
       #
       # Returns nothing.
       def adapter_operation(event)
         return unless logger.debug?
 
+        feature_name = event.payload[:feature_name]
         adapter_name = event.payload[:adapter_name]
+        gate_name = event.payload[:gate_name]
         operation = event.payload[:operation]
         result = event.payload[:result]
-        value = event.payload[:value]
-        key = event.payload[:key]
 
-        feature_description = if key.respond_to?(:feature_name)
-          "Flipper feature(#{key.feature_name})"
-        else
-          "Flipper"
-        end
+        description = "Flipper "
+        description << "feature(#{feature_name}) " unless feature_name.nil?
+        description << "adapter(#{adapter_name}) "
+        description << "#{operation} "
 
-        adapter_description = "adapter(#{adapter_name})"
-        operation_description = "#{operation}(#{key.to_s.inspect})"
-        description = "#{feature_description} #{adapter_description} #{operation_description}"
         details = "result=#{result.inspect}"
 
-        if event.payload.key?(:value)
-          details += " value=#{value.inspect}"
-        end
-
         name = '%s (%.1fms)' % [description, event.duration]
         debug "  #{color(name, CYAN, true)}  [ #{details} ]"
       end
@@ -78,11 +70,11 @@ module Flipper
       # Example Output
       #
       #   flipper[:search].enabled?(user)
-      #   # Flipper feature(search) gate(boolean) open false (0.1ms)  [ thing=#<struct flipper_id="1"> ]
-      #   # Flipper feature(search) gate(group) open false (0.1ms)  [ thing=#<struct flipper_id="1"> ]
-      #   # Flipper feature(search) gate(actor) open false (0.1ms)  [ thing=#<struct flipper_id="1"> ]
-      #   # Flipper feature(search) gate(percentage_of_actors) open false (0.1ms)  [ thing=#<struct flipper_id="1"> ]
-      #   # Flipper feature(search) gate(percentage_of_random) open false (0.1ms)  [ thing=#<struct flipper_id="1"> ]
+      #   # Flipper feature(search) gate(boolean) open false (0.1ms)  [ thing=... ]
+      #   # Flipper feature(search) gate(group) open false (0.1ms)  [ thing=... ]
+      #   # Flipper feature(search) gate(actor) open false (0.1ms)  [ thing=... ]
+      #   # Flipper feature(search) gate(percentage_of_actors) open false (0.1ms)  [ thing=... ]
+      #   # Flipper feature(search) gate(percentage_of_random) open false (0.1ms)  [ thing=... ]
       #
       # Returns nothing.
       def gate_operation(event)

data/lib/flipper/middleware/memoizer.rb

@@ -0,0 +1,23 @@
+require 'rack/body_proxy'
+
+module Flipper
+  module Middleware
+    class Memoizer
+      def initialize(app, flipper)
+        @app = app
+        @flipper = flipper
+      end
+
+      def call(env)
+        original = @flipper.adapter.memoizing?
+        @flipper.adapter.memoize = true
+
+        response = @app.call(env)
+        response[2] = Rack::BodyProxy.new(response[2]) {
+          @flipper.adapter.memoize = original
+        }
+        response
+      end
+    end
+  end
+end

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -1,124 +1,173 @@
-require 'set'
+# Requires the following methods:
+# * subject - The instance of the adapter
+shared_examples_for 'a flipper adapter' do
+  let(:actor_class) { Struct.new(:flipper_id) }
+
+  let(:flipper) { Flipper.new(subject) }
+  let(:feature) { flipper[:stats] }
+
+  let(:boolean_gate) { feature.gate(:boolean) }
+  let(:group_gate)   { feature.gate(:group) }
+  let(:actor_gate)   { feature.gate(:actor) }
+  let(:actors_gate)  { feature.gate(:percentage_of_actors) }
+  let(:random_gate)  { feature.gate(:percentage_of_random) }
 
-shared_examples_for 'a working percentage' do
-  it "does not raise when used" do
-    feature.enable percentage
-    expect { feature.enabled?(actor) }.to_not raise_error
+  before do
+    Flipper.register(:admins) { |actor|
+      actor.respond_to?(:admin?) && actor.admin?
+    }
+
+    Flipper.register(:early_access) { |actor|
+      actor.respond_to?(:early_access?) && actor.early_access?
+    }
   end
-end
 
-# Requires the following methods
-# subject
-# read_key(key)
-# write_key(key, value)
-shared_examples_for 'a flipper adapter' do
-  let(:key) { Flipper::Key.new(:foo, :bar) }
+  after do
+    Flipper.unregister_groups
+  end
 
-  describe "#write" do
-    it "sets key to value in store" do
-      subject.write(key, true)
-      read_key(key).should be_true
-    end
+  it "has name that is a symbol" do
+    subject.name.should_not be_nil
+    subject.name.should be_instance_of(Symbol)
   end
 
-  describe "#read" do
-    it "returns nil if key not in store" do
-      subject.read(key).should be_nil
-    end
+  it "has included the flipper adapter module" do
+    subject.class.ancestors.should include(Flipper::Adapter)
+  end
 
-    it "returns value if key in store" do
-      write_key key, 'bar'
-      subject.read(key).should eq('bar')
-    end
+  it "returns correct default values for the gates if none are enabled" do
+    subject.get(feature).should eq({
+      :boolean => nil,
+      :groups => Set.new,
+      :actors => Set.new,
+      :percentage_of_actors => nil,
+      :percentage_of_random => nil,
+    })
   end
 
-  describe "#delete" do
-    it "deletes key" do
-      write_key key, 'bar'
-      subject.delete(key)
-      read_key(key).should be_nil
-    end
+  it "can enable, disable and get value for boolean gate" do
+    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
+
+    result = subject.get(feature)
+    result[:boolean].should eq('true')
+
+    subject.disable(feature, boolean_gate, flipper.boolean(false)).should be_true
+
+    result = subject.get(feature)
+    result[:boolean].should be_nil
   end
 
-  describe "#set_add" do
-    it "adds value to store" do
-      subject.set_add(key, '1')
-      read_key(key).should eq(Set['1'])
-    end
+  it "fully disables all enabled things when boolean gate disabled" do
+    actor_22 = actor_class.new('22')
+    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
+    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
+    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should be_true
+    subject.enable(feature, actors_gate, flipper.actors(25)).should be_true
+    subject.enable(feature, random_gate, flipper.random(45)).should be_true
+
+    subject.disable(feature, boolean_gate, flipper.boolean).should be_true
+
+    subject.get(feature).should eq({
+      :boolean => nil,
+      :groups => Set.new,
+      :actors => Set.new,
+      :percentage_of_actors => nil,
+      :percentage_of_random => nil,
+    })
+  end
 
-    it "does not add same value more than once" do
-      subject.set_add(key, '1')
-      subject.set_add(key, '1')
-      subject.set_add(key, '1')
-      subject.set_add(key, '2')
-      read_key(key).should eq(Set['1', '2'])
-    end
+  it "can enable, disable and get value for group gate" do
+    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
+    subject.enable(feature, group_gate, flipper.group(:early_access)).should be_true
+
+    result = subject.get(feature)
+    result[:groups].should eq(Set['admins', 'early_access'])
+
+    subject.disable(feature, group_gate, flipper.group(:early_access)).should be_true
+    result = subject.get(feature)
+    result[:groups].should eq(Set['admins'])
+
+    subject.disable(feature, group_gate, flipper.group(:admins)).should be_true
+    result = subject.get(feature)
+    result[:groups].should eq(Set.new)
   end
 
-  describe "#set_delete" do
-    it "removes value from set if key in store" do
-      write_key key, Set['1', '2']
-      subject.set_delete(key, '1')
-      read_key(key).should eq(Set['2'])
-    end
+  it "can enable, disable and get value for actor gate" do
+    actor_22 = actor_class.new('22')
+    actor_asdf = actor_class.new('asdf')
+
+    subject.enable(feature, actor_gate, flipper.actor(actor_22)).should be_true
+    subject.enable(feature, actor_gate, flipper.actor(actor_asdf)).should be_true
+
+    result = subject.get(feature)
+    result[:actors].should eq(Set['22', 'asdf'])
+
+    subject.disable(feature, actor_gate, flipper.actor(actor_22)).should be_true
+    result = subject.get(feature)
+    result[:actors].should eq(Set['asdf'])
 
-    it "works fine if key not in store" do
-      subject.set_delete(key, 'bar')
-    end
+    subject.disable(feature, actor_gate, flipper.actor(actor_asdf)).should be_true
+    result = subject.get(feature)
+    result[:actors].should eq(Set.new)
   end
 
-  describe "#set_members" do
-    it "defaults to empty set" do
-      subject.set_members(key).should eq(Set.new)
-    end
+  it "can enable, disable and get value for percentage of actors gate" do
+    subject.enable(feature, actors_gate, flipper.actors(15)).should be_true
+    result = subject.get(feature)
+    result[:percentage_of_actors].should eq('15')
 
-    it "returns set if in store" do
-      write_key key, Set['1', '2']
-      subject.set_members(key).should eq(Set['1', '2'])
-    end
+    subject.disable(feature, actors_gate, flipper.actors(0)).should be_true
+    result = subject.get(feature)
+    result[:percentage_of_actors].should eq('0')
   end
 
-  it "should work with Flipper.new" do
-    Flipper.new(subject).should_not be_nil
+  it "can enable, disable and get value for percentage of random gate" do
+    subject.enable(feature, random_gate, flipper.random(10)).should be_true
+    result = subject.get(feature)
+    result[:percentage_of_random].should eq('10')
+
+    subject.disable(feature, random_gate, flipper.random(0)).should be_true
+    result = subject.get(feature)
+    result[:percentage_of_random].should eq('0')
   end
 
-  context "working with values" do
-    it "always uses strings" do
-      subject.read(key).should be_nil
-      subject.write key, true
-      subject.read(key).should eq('true')
+  it "converts boolean value to a string" do
+    subject.enable(feature, boolean_gate, flipper.boolean).should be_true
+    result = subject.get(feature)
+    result[:boolean].should eq('true')
+  end
 
-      subject.write key, 22
-      subject.read(key).should eq('22')
+  it "converts the actor value to a string" do
+    subject.enable(feature, actor_gate, flipper.actor(actor_class.new(22))).should be_true
+    result = subject.get(feature)
+    result[:actors].should eq(Set['22'])
+  end
+
+  it "converts group value to a string" do
+    subject.enable(feature, group_gate, flipper.group(:admins)).should be_true
+    result = subject.get(feature)
+    result[:groups].should eq(Set['admins'])
+  end
 
-      subject.delete(key)
-      subject.read(key).should be_nil
-    end
+  it "converts percentage of random integer value to a string" do
+    subject.enable(feature, random_gate, flipper.random(10)).should be_true
+    result = subject.get(feature)
+    result[:percentage_of_random].should eq('10')
   end
 
-  context "working with sets" do
-    it "always uses strings" do
-      subject.set_add key, 1
-      subject.set_add key, 2
-      subject.set_members(key).should eq(Set['1', '2'])
-      subject.set_delete key, 2
-      subject.set_members(key).should eq(Set['1'])
-    end
+  it "converts percentage of actors integer value to a string" do
+    subject.enable(feature, actors_gate, flipper.actors(10)).should be_true
+    result = subject.get(feature)
+    result[:percentage_of_actors].should eq('10')
   end
 
-  context "integration spot-checks" do
-    let(:instance) { Flipper.new(subject) }
-    let(:feature) { instance[:feature] }
-    let(:actor) { Struct.new(:id).new(1) }
+  it "can add and list known features" do
+    subject.features.should eq(Set.new)
 
-    context "percentage of actors" do
-      let(:percentage) { instance.actors(10) }
-      it_should_behave_like 'a working percentage'
-    end
+    subject.add(flipper[:stats]).should be_true
+    subject.features.should eq(Set['stats'])
 
-    context "random percentage" do
-      let(:percentage) { instance.random(10) }
-      it_should_behave_like 'a working percentage'
-    end
+    subject.add(flipper[:search]).should be_true
+    subject.features.should eq(Set['stats', 'search'])
   end
 end

data/lib/flipper/types/boolean.rb

@@ -1,8 +1,12 @@
 module Flipper
   module Types
     class Boolean < Type
+      def initialize(value = nil)
+        @value = value.nil? ? true : value
+      end
+
       def value
-        true
+        @value
       end
     end
   end

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/flipper/adapters/instrumented_spec.rb

@@ -0,0 +1,92 @@
+require 'helper'
+require 'flipper/adapters/memory'
+require 'flipper/adapters/instrumented'
+require 'flipper/instrumenters/memory'
+require 'flipper/spec/shared_adapter_specs'
+
+describe Flipper::Adapters::Instrumented do
+  let(:instrumenter) { Flipper::Instrumenters::Memory.new }
+  let(:adapter) { Flipper::Adapters::Memory.new }
+  let(:flipper) { Flipper.new(adapter) }
+
+  let(:feature) { flipper[:stats] }
+  let(:gate) { feature.gate(:percentage_of_actors) }
+  let(:thing) { flipper.actors(22) }
+
+  subject {
+    described_class.new(adapter, :instrumenter => instrumenter)
+  }
+
+  it_should_behave_like 'a flipper adapter'
+
+  describe "#get" do
+    it "records instrumentation" do
+      result = subject.get(feature)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('adapter_operation.flipper')
+      event.payload[:operation].should eq(:get)
+      event.payload[:adapter_name].should eq(:memory)
+      event.payload[:feature_name].should eq(:stats)
+      event.payload[:result].should be(result)
+    end
+  end
+
+  describe "#enable" do
+    it "records instrumentation" do
+      result = subject.enable(feature, gate, thing)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('adapter_operation.flipper')
+      event.payload[:operation].should eq(:enable)
+      event.payload[:adapter_name].should eq(:memory)
+      event.payload[:feature_name].should eq(:stats)
+      event.payload[:gate_name].should eq(:percentage_of_actors)
+      event.payload[:result].should be(result)
+    end
+  end
+
+  describe "#disable" do
+    it "records instrumentation" do
+      result = subject.disable(feature, gate, thing)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('adapter_operation.flipper')
+      event.payload[:operation].should eq(:disable)
+      event.payload[:adapter_name].should eq(:memory)
+      event.payload[:feature_name].should eq(:stats)
+      event.payload[:gate_name].should eq(:percentage_of_actors)
+      event.payload[:result].should be(result)
+    end
+  end
+
+  describe "#add" do
+    it "records instrumentation" do
+      result = subject.add(feature)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('adapter_operation.flipper')
+      event.payload[:operation].should eq(:add)
+      event.payload[:adapter_name].should eq(:memory)
+      event.payload[:feature_name].should eq(:stats)
+      event.payload[:result].should be(result)
+    end
+  end
+
+  describe "#features" do
+    it "records instrumentation" do
+      result = subject.features
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('adapter_operation.flipper')
+      event.payload[:operation].should eq(:features)
+      event.payload[:adapter_name].should eq(:memory)
+      event.payload[:result].should be(result)
+    end
+  end
+end