flipper 0.11.0.beta6 → 0.11.0.beta7

data/lib/flipper/gate_values.rb

@@ -22,8 +22,8 @@ module Flipper
       @boolean = Typecast.to_boolean(adapter_values[:boolean])
       @actors = Typecast.to_set(adapter_values[:actors])
       @groups = Typecast.to_set(adapter_values[:groups])
-      @percentage_of_actors = Typecast.to_integer(adapter_values[:percentage_of_actors])
-      @percentage_of_time = Typecast.to_integer(adapter_values[:percentage_of_time])
+      @percentage_of_actors = Typecast.to_percentage(adapter_values[:percentage_of_actors])
+      @percentage_of_time = Typecast.to_percentage(adapter_values[:percentage_of_time])
     end
 
     def [](key)

data/lib/flipper/gates/group.rb

@@ -28,12 +28,8 @@ module Flipper
           false
         else
           value.any? do |name|
-            begin
-              group = Flipper.group(name)
-              group.match?(context.thing, context)
-            rescue GroupNotRegistered
-              false
-            end
+            group = Flipper.group(name)
+            group.match?(context.thing, context)
           end
         end
       end

data/lib/flipper/gates/percentage_of_actors.rb

@@ -30,7 +30,9 @@ module Flipper
         if Types::Actor.wrappable?(context.thing)
           actor = Types::Actor.wrap(context.thing)
           id = "#{context.feature_name}#{actor.value}"
-          Zlib.crc32(id) % 100 < percentage
+          # this is to support up to 3 decimal places in percentages
+          scaling_factor = 1_000
+          Zlib.crc32(id) % (100 * scaling_factor) < percentage * scaling_factor
         else
           false
         end

data/lib/flipper/typecast.rb

@@ -26,6 +26,30 @@ module Flipper
       end
     end
 
+    # Internal: Convert value to a float.
+    #
+    # Returns a Float representation of the value.
+    # Raises ArgumentError if conversion is not possible.
+    def self.to_float(value)
+      if value.respond_to?(:to_f)
+        value.to_f
+      else
+        raise ArgumentError, "#{value.inspect} cannot be converted to a float"
+      end
+    end
+
+    # Internal: Convert value to a percentage.
+    #
+    # Returns a Integer or Float representation of the value.
+    # Raises ArgumentError if conversion is not possible.
+    def self.to_percentage(value)
+      if value.to_s.include?('.'.freeze)
+        to_float(value)
+      else
+        to_integer(value)
+      end
+    end
+
     # Internal: Convert value to a set.
     #
     # Returns a Set representation of the value.

data/lib/flipper/types/percentage.rb

@@ -2,7 +2,7 @@ module Flipper
   module Types
     class Percentage < Type
       def initialize(value)
-        value = Typecast.to_integer(value)
+        value = Typecast.to_percentage(value)
 
         if value < 0 || value > 100
           raise ArgumentError,

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = '0.11.0.beta6'.freeze
+  VERSION = '0.11.0.beta7'.freeze
 end

data/spec/flipper/configuration_spec.rb

@@ -0,0 +1,16 @@
+require 'helper'
+require 'flipper/configuration'
+
+RSpec.describe Flipper::Configuration do
+  describe '#default' do
+    it 'raises if default not configured' do
+      expect { subject.default }.to raise_error(Flipper::DefaultNotSet)
+    end
+
+    it 'can be set default' do
+      instance = Flipper.new(Flipper::Adapters::Memory.new)
+      subject.default { instance }
+      expect(subject.default).to be(instance)
+    end
+  end
+end

data/spec/flipper/dsl_spec.rb

@@ -274,6 +274,15 @@ RSpec.describe Flipper::DSL do
       subject.disable_percentage_of_time(:stats)
       expect(subject[:stats].percentage_of_time_value).to be(0)
     end
+
+    it 'can enable/disable float values' do
+      expect(subject[:stats].percentage_of_time_value).to be(0)
+      subject.enable_percentage_of_time(:stats, 0.01)
+      expect(subject[:stats].percentage_of_time_value).to be(0.01)
+
+      subject.disable_percentage_of_time(:stats)
+      expect(subject[:stats].percentage_of_time_value).to be(0)
+    end
   end
 
   describe '#enable_percentage_of_actors/disable_percentage_of_actors' do
@@ -285,6 +294,15 @@ RSpec.describe Flipper::DSL do
       subject.disable_percentage_of_actors(:stats)
       expect(subject[:stats].percentage_of_actors_value).to be(0)
     end
+
+    it 'can enable/disable float values' do
+      expect(subject[:stats].percentage_of_actors_value).to be(0)
+      subject.enable_percentage_of_actors(:stats, 0.01)
+      expect(subject[:stats].percentage_of_actors_value).to be(0.01)
+
+      subject.disable_percentage_of_actors(:stats)
+      expect(subject[:stats].percentage_of_actors_value).to be(0)
+    end
   end
 
   describe '#add' do

data/spec/flipper/gates/percentage_of_actors_spec.rb

@@ -7,10 +7,10 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
     described_class.new
   end
 
-  def context(integer, feature = feature_name, thing = nil)
+  def context(percentage_of_actors_value, feature = feature_name, thing = nil)
     Flipper::FeatureCheckContext.new(
       feature_name: feature,
-      values: Flipper::GateValues.new(percentage_of_actors: integer),
+      values: Flipper::GateValues.new(percentage_of_actors: percentage_of_actors_value),
       thing: thing || Flipper::Types::Actor.new(Flipper::Actor.new(1))
     )
   end
@@ -19,20 +19,18 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
     context 'when compared against two features' do
       let(:percentage) { 0.05 }
       let(:percentage_as_integer) { percentage * 100 }
-      let(:number_of_actors) { 100 }
+      let(:number_of_actors) { 10_000 }
 
       let(:actors) do
         (1..number_of_actors).map { |n| Flipper::Actor.new(n) }
       end
 
       let(:feature_one_enabled_actors) do
-        gate = described_class.new
-        actors.select { |actor| gate.open? context(percentage_as_integer, :name_one, actor) }
+        actors.select { |actor| subject.open? context(percentage_as_integer, :name_one, actor) }
       end
 
       let(:feature_two_enabled_actors) do
-        gate = described_class.new
-        actors.select { |actor| gate.open? context(percentage_as_integer, :name_two, actor) }
+        actors.select { |actor| subject.open? context(percentage_as_integer, :name_two, actor) }
       end
 
       it 'does not enable both features for same set of actors' do
@@ -51,5 +49,29 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
         end
       end
     end
+
+    context 'for fractional percentage' do
+      let(:decimal) { 0.001 }
+      let(:percentage) { decimal * 100 }
+      let(:number_of_actors) { 10_000 }
+
+      let(:actors) do
+        (1..number_of_actors).map { |n| Flipper::Actor.new(n) }
+      end
+
+      subject { described_class.new }
+
+      it 'enables feature for accurate number of actors' do
+        margin_of_error = 0.02 * number_of_actors
+        expected_open_count = number_of_actors * decimal
+
+        open_count = actors.select do |actor|
+          context = context(percentage, :feature, actor)
+          subject.open?(context)
+        end.size
+
+        expect(open_count).to be_within(margin_of_error).of(expected_open_count)
+      end
+    end
   end
 end

data/spec/flipper/gates/percentage_of_time_spec.rb

@@ -6,4 +6,34 @@ RSpec.describe Flipper::Gates::PercentageOfTime do
   subject do
     described_class.new
   end
+
+  def context(percentage_of_time_value, feature = feature_name, thing = nil)
+    Flipper::FeatureCheckContext.new(
+      feature_name: feature,
+      values: Flipper::GateValues.new(percentage_of_time: percentage_of_time_value),
+      thing: thing || Flipper::Types::Actor.new(Flipper::Actor.new(1))
+    )
+  end
+
+  describe '#open?' do
+    context 'for fractional percentage' do
+      let(:decimal) { 0.001 }
+      let(:percentage) { decimal * 100 }
+      let(:number_of_invocations) { 10_000 }
+
+      subject { described_class.new }
+
+      it 'enables feature for accurate percentage of time' do
+        margin_of_error = 0.02 * number_of_invocations
+        expected_open_count = number_of_invocations * decimal
+
+        open_count = (1..number_of_invocations).select do |_actor|
+          context = context(percentage, :feature, Flipper::Actor.new("1"))
+          subject.open?(context)
+        end.size
+
+        expect(open_count).to be_within(margin_of_error).of(expected_open_count)
+      end
+    end
+  end
 end

data/spec/flipper/typecast_spec.rb

@@ -36,6 +36,43 @@ RSpec.describe Flipper::Typecast do
     end
   end
 
+  {
+    nil => 0.0,
+    '' => 0.0,
+    0 => 0.0,
+    1 => 1.0,
+    1.1 => 1.1,
+    '0.01' => 0.01,
+    '1' => 1.0,
+    '99' => 99.0,
+  }.each do |value, expected|
+    context "#to_float for #{value.inspect}" do
+      it "returns #{expected}" do
+        expect(described_class.to_float(value)).to be(expected)
+      end
+    end
+  end
+
+  {
+    nil => 0,
+    '' => 0,
+    0 => 0,
+    0.0 => 0.0,
+    1 => 1,
+    1.1 => 1.1,
+    '0.01' => 0.01,
+    '1' => 1,
+    '1.1' => 1.1,
+    '99' => 99,
+    '99.9' => 99.9,
+  }.each do |value, expected|
+    context "#to_percentage for #{value.inspect}" do
+      it "returns #{expected}" do
+        expect(described_class.to_percentage(value)).to be(expected)
+      end
+    end
+  end
+
   {
     nil => Set.new,
     '' => Set.new,
@@ -55,6 +92,24 @@ RSpec.describe Flipper::Typecast do
     end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
   end
 
+  it 'raises argument error for float value that cannot be converted to an float' do
+    expect do
+      described_class.to_float(['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to a float))
+  end
+
+  it 'raises argument error for bad integer percentage' do
+    expect do
+      described_class.to_percentage(['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
+  end
+
+  it 'raises argument error for bad float percentage' do
+    expect do
+      described_class.to_percentage(['asdf.0'])
+    end.to raise_error(ArgumentError, %(["asdf.0"] cannot be converted to a float))
+  end
+
   it 'raises argument error for set value that cannot be converted to a set' do
     expect do
       described_class.to_set('asdf')

data/spec/flipper_spec.rb

@@ -8,28 +8,173 @@ RSpec.describe Flipper do
     end
   end
 
-  describe '.group_exists' do
-    it 'returns true if the group is already created' do
-      group = described_class.register('admins', &:admin?)
-      expect(described_class.group_exists?(:admins)).to eq(true)
+  describe '.configure' do
+    it 'yield configuration instance' do
+      described_class.configure do |config|
+        expect(config).to be_instance_of(Flipper::Configuration)
+      end
     end
+  end
 
-    it 'returns false when the group is not yet registered' do
-      expect(described_class.group_exists?(:non_existing)).to eq(false)
+  describe '.configuration' do
+    it 'returns configuration instance' do
+      expect(described_class.configuration).to be_instance_of(Flipper::Configuration)
     end
   end
 
-  describe '.groups_registry' do
-    it 'returns a registry instance' do
-      expect(described_class.groups_registry).to be_instance_of(Flipper::Registry)
+  describe '.configuration=' do
+    it "sets configuration instance" do
+      configuration = Flipper::Configuration.new
+      described_class.configuration = configuration
+      expect(described_class.configuration).to be(configuration)
     end
   end
 
-  describe '.groups_registry=' do
-    it 'sets groups_registry registry' do
-      registry = Flipper::Registry.new
-      described_class.groups_registry = registry
-      expect(described_class.instance_variable_get('@groups_registry')).to eq(registry)
+  describe '.instance' do
+    it 'returns DSL instance using result of default invocation' do
+      instance = described_class.new(Flipper::Adapters::Memory.new)
+      described_class.configure do |config|
+        config.default { instance }
+      end
+      expect(described_class.instance).to be(instance)
+      expect(described_class.instance).to be(described_class.instance) # memoized
+    end
+  end
+
+  describe "delegation to instance" do
+    let(:group) { Flipper::Types::Group.new(:admins) }
+    let(:actor) { Flipper::Actor.new("1") }
+
+    before do
+      described_class.configure do |config|
+        config.default { described_class.new(Flipper::Adapters::Memory.new) }
+      end
+    end
+
+    it 'delegates enabled? to instance' do
+      expect(described_class.enabled?(:search)).to eq(described_class.instance.enabled?(:search))
+      described_class.instance.enable(:search)
+      expect(described_class.enabled?(:search)).to eq(described_class.instance.enabled?(:search))
+    end
+
+    it 'delegates enable to instance' do
+      described_class.enable(:search)
+      expect(described_class.instance.enabled?(:search)).to be(true)
+    end
+
+    it 'delegates disable to instance' do
+      described_class.disable(:search)
+      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)
+    end
+
+    it 'delegates boolean to instance' do
+      expect(described_class.boolean).to eq(described_class.instance.boolean)
+    end
+
+    it 'delegates enable_actor to instance' do
+      described_class.enable_actor(:search, actor)
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+    end
+
+    it 'delegates disable_actor to instance' do
+      described_class.disable_actor(:search, actor)
+      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)
+    end
+
+    it 'delegates disable_group to instance' do
+      described_class.disable_group(:search, group)
+      expect(described_class.instance[:search].enabled_groups).not_to include(group)
+    end
+
+    it 'delegates enable_percentage_of_actors to instance' do
+      described_class.enable_percentage_of_actors(:search, 5)
+      expect(described_class.instance[:search].percentage_of_actors_value).to be(5)
+    end
+
+    it 'delegates disable_percentage_of_actors to instance' do
+      described_class.disable_percentage_of_actors(:search)
+      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)
+    end
+
+    it 'delegates disable_percentage_of_time to instance' do
+      described_class.disable_percentage_of_time(:search)
+      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)
+      expect(described_class.features).to include(described_class.instance[:search])
+    end
+
+    it 'delegates feature to instance' do
+      expect(described_class.feature(:search)).to eq(described_class.instance.feature(:search))
+    end
+
+    it 'delegates [] to instance' do
+      expect(described_class[:search]).to eq(described_class.instance[:search])
+    end
+
+    it 'delegates preload to instance' do
+      described_class.instance.enable(:search)
+      expect(described_class.preload([:search])).to eq(described_class.instance.preload([:search]))
+    end
+
+    it 'delegates preload_all to instance' do
+      described_class.instance.enable(:search)
+      described_class.instance.enable(:stats)
+      expect(described_class.preload_all).to eq(described_class.instance.preload_all)
+    end
+
+    it 'delegates add to instance' do
+      expect(described_class.add(:search)).to eq(described_class.instance.add(:search))
+    end
+
+    it 'delegates remove to instance' do
+      expect(described_class.remove(:search)).to eq(described_class.instance.remove(:search))
+    end
+
+    it 'delegates import to instance' do
+      other = described_class.new(Flipper::Adapters::Memory.new)
+      other.enable(:search)
+      described_class.import(other)
+      expect(described_class.enabled?(:search)).to be(true)
     end
   end
 
@@ -57,6 +202,28 @@ RSpec.describe Flipper do
     end
   end
 
+  describe '.groups' do
+    it 'returns array of group instances' do
+      admins = described_class.register(:admins, &:admin?)
+      preview_features = described_class.register(:preview_features, &:preview_features?)
+      expect(described_class.groups).to eq(Set[
+              admins,
+              preview_features,
+            ])
+    end
+  end
+
+  describe '.group_names' do
+    it 'returns array of group names' do
+      described_class.register(:admins, &:admin?)
+      described_class.register(:preview_features, &:preview_features?)
+      expect(described_class.group_names).to eq(Set[
+              :admins,
+              :preview_features,
+            ])
+    end
+  end
+
   describe '.unregister_groups' do
     it 'clear group registry' do
       expect(described_class.groups_registry).to receive(:clear)
@@ -64,6 +231,17 @@ RSpec.describe Flipper do
     end
   end
 
+  describe '.group_exists' do
+    it 'returns true if the group is already created' do
+      group = described_class.register('admins', &:admin?)
+      expect(described_class.group_exists?(:admins)).to eq(true)
+    end
+
+    it 'returns false when the group is not yet registered' do
+      expect(described_class.group_exists?(:non_existing)).to eq(false)
+    end
+  end
+
   describe '.group' do
     context 'for registered group' do
       before do
@@ -95,25 +273,17 @@ RSpec.describe Flipper do
     end
   end
 
-  describe '.groups' do
-    it 'returns array of group instances' do
-      admins = described_class.register(:admins, &:admin?)
-      preview_features = described_class.register(:preview_features, &:preview_features?)
-      expect(described_class.groups).to eq(Set[
-              admins,
-              preview_features,
-            ])
+  describe '.groups_registry' do
+    it 'returns a registry instance' do
+      expect(described_class.groups_registry).to be_instance_of(Flipper::Registry)
     end
   end
 
-  describe '.group_names' do
-    it 'returns array of group names' do
-      described_class.register(:admins, &:admin?)
-      described_class.register(:preview_features, &:preview_features?)
-      expect(described_class.group_names).to eq(Set[
-              :admins,
-              :preview_features,
-            ])
+  describe '.groups_registry=' do
+    it 'sets groups_registry registry' do
+      registry = Flipper::Registry.new
+      described_class.groups_registry = registry
+      expect(described_class.instance_variable_get('@groups_registry')).to eq(registry)
     end
   end
 end