feature 1.1.0 → 1.2.0

data/lib/feature/repository/yaml_repository.rb

@@ -11,6 +11,17 @@ module Feature
     #   repository = YamlRepository.new('/path/to/yaml/file')
     #   # use repository with Feature
     #
+    # A yaml config also can have this format:
+    #   features:
+    #     development:
+    #       a_feature: true
+    #     production:
+    #       a_feature: false
+    #
+    # This way you have to use:
+    #   repository = YamlRepository.new('/path/to/yaml/file', '_your_environment_')
+    #   # use repository with Feature
+    #
     class YamlRepository
       require 'erb'
       require 'yaml'
@@ -20,7 +31,7 @@ module Feature
       # @param [String] yaml_file_name the yaml config filename
       # @param [String] environment optional environment to use from config
       #
-      def initialize(yaml_file_name, environment='')
+      def initialize(yaml_file_name, environment = '')
         @yaml_file_name = yaml_file_name
         @environment = environment
       end
@@ -30,37 +41,44 @@ module Feature
       # @return [Array<Symbol>] list of active features
       #
       def active_features
-        features_hash = read_and_parse_file_data
-        features = features_hash.keys.select { |feature_key| features_hash[feature_key] }
-        features.sort.map(&:to_sym)
+        data = read_file(@yaml_file_name)
+        get_active_features(data, @environment)
       end
 
-      # Read and parses the feature config file
+      # Read given file, perform erb evaluation and yaml parsing
       #
-      # @return [Hash] Hash containing :feature => true/false entries for representing active/inactive features
+      # @param file_name [String] the file name fo the yaml config
+      # @return [Hash]
       #
-      def read_and_parse_file_data
-        raw_data = File.read(@yaml_file_name)
+      def read_file(file_name)
+        raw_data = File.read(file_name)
         evaluated_data = ERB.new(raw_data).result
-        data = YAML.load(evaluated_data)
-        data = data[@environment] unless @environment.empty?
+        YAML.load(evaluated_data)
+      end
+      private :read_file
 
-        if !data.is_a?(Hash) or !data.has_key?('features')
-          raise ArgumentError, "content of #{@yaml_file_name} does not contain proper config"
+      # Extracts active features from given hash
+      #
+      # @param data [Hash] hash parsed from yaml file
+      # @param selector [String] uses the value for this key as source of feature data
+      #
+      def get_active_features(data, selector)
+        data = data[selector] unless selector.empty?
+
+        if !data.is_a?(Hash) || !data.key?('features')
+          fail ArgumentError, 'yaml config does not contain proper config'
         end
 
-        if data['features']
-          invalid_value = data['features'].values.detect { |value| ![true, false].include?(value) }
-          if invalid_value
-            raise ArgumentError, "#{invalid_value} is not allowed value in config, use true/false"
-          end
+        return [] unless data['features']
 
-          data['features']
-        else
-          {}
+        invalid_value = data['features'].values.select { |value| ![true, false].include?(value) }
+        unless invalid_value.empty?
+          fail ArgumentError, "#{invalid_value.first} is not allowed value in config, use true/false"
         end
+
+        data['features'].keys.select { |key| data['features'][key] }.map(&:to_sym)
       end
-      private :read_and_parse_file_data
+      private :get_active_features
     end
   end
 end

data/lib/feature/testing.rb

@@ -7,7 +7,6 @@ require 'feature'
 # To enable Feature testing capabilities do:
 #   require 'feature/testing'
 module Feature
-
   # Execute the code block with the given feature active
   #
   # Example usage:

data/spec/feature/active_record_repository_spec.rb

@@ -5,36 +5,42 @@ include Feature::Repository
 describe Feature::Repository::ActiveRecordRepository do
   before(:each) do
     # Mock the model
-    @features = double("FeatureToggle")
+    @features = double('FeatureToggle')
     @repository = ActiveRecordRepository.new(@features)
   end
 
-  it "should have no active features after initialization" do
-    allow(@features).to receive(:where) { Hash.new }
+  it 'should have no active features after initialization' do
+    allow(@features).to receive(:where) { [] }
 
     expect(@repository.active_features).to eq([])
   end
 
-  it "should add an active feature" do
-    expect(@features).to receive(:exists?).with("feature_a").and_return(false)
-    expect(@features).to receive(:new).with(name: "feature_a", active: true).and_return(double(save: true))
+  it 'should have active features' do
+    allow(@features).to receive(:where).with(active: true) { [double(name: 'active')] }
+
+    expect(@repository.active_features).to eq([:active])
+  end
+
+  it 'should add an active feature' do
+    expect(@features).to receive(:exists?).with('feature_a').and_return(false)
+    expect(@features).to receive(:create!).with(name: 'feature_a', active: true)
 
     @repository.add_active_feature :feature_a
   end
 
-  it "should raise an exception when adding not a symbol as active feature" do
-    expect {
+  it 'should raise an exception when adding not a symbol as active feature' do
+    expect do
       @repository.add_active_feature 'feature_a'
-    }.to raise_error(ArgumentError, "given feature feature_a is not a symbol")
+    end.to raise_error(ArgumentError, 'feature_a is not a symbol')
   end
 
-  it "should raise an exception when adding a active feature already added as active" do
-    expect(@features).to receive(:new).with(name: "feature_a", active: true).and_return(double(save: true))
+  it 'should raise an exception when adding a active feature already added as active' do
+    expect(@features).to receive(:create!).with(name: 'feature_a', active: true)
     allow(@features).to receive(:exists?).and_return(false, true)
 
     @repository.add_active_feature :feature_a
-    expect {
+    expect do
       @repository.add_active_feature :feature_a
-    }.to raise_error(ArgumentError, "feature :feature_a already added to list of active features")
+    end.to raise_error(ArgumentError, 'feature :feature_a already added')
   end
 end

data/spec/feature/feature_spec.rb

@@ -1,89 +1,121 @@
 require 'spec_helper'
 
 describe Feature do
-  context "without FeatureRepository" do
-    it "should raise an exception when calling active?" do
+  context 'without FeatureRepository' do
+    it 'should raise an exception when calling active?' do
       expect do
         Feature.active?(:feature_a)
-      end.to raise_error("Feature is missing Repository for obtaining feature lists")
+      end.to raise_error('missing Repository for obtaining feature lists')
     end
 
-    it "should raise an exception when calling inactive?" do
+    it 'should raise an exception when calling inactive?' do
       expect do
         Feature.inactive?(:feature_a)
-      end.to raise_error("Feature is missing Repository for obtaining feature lists")
+      end.to raise_error('missing Repository for obtaining feature lists')
     end
 
-    it "should raise an exception when calling with" do
+    it 'should raise an exception when calling with' do
       expect do
         Feature.with(:feature_a) do
         end
-      end.to raise_error("Feature is missing Repository for obtaining feature lists")
+      end.to raise_error('missing Repository for obtaining feature lists')
     end
 
-    it "should raise an exception when calling without" do
+    it 'should raise an exception when calling without' do
       expect do
         Feature.without(:feature_a) do
         end
-      end.to raise_error("Feature is missing Repository for obtaining feature lists")
+      end.to raise_error('missing Repository for obtaining feature lists')
     end
   end
 
-  context "setting Repository" do
+  context 'setting Repository' do
     before(:each) do
       @repository = Feature::Repository::SimpleRepository.new
-      Feature.set_repository @repository
     end
 
-    it "should raise an exception when add repository with wrong class" do
-      expect do
-        Feature.set_repository("not a repository")
-      end.to raise_error(ArgumentError, "given repository does not respond to active_features")
+    context 'with auto_refresh set to false' do
+      before(:each) do
+        Feature.set_repository @repository
+      end
+      it 'should raise an exception when add repository with wrong class' do
+        expect do
+          Feature.set_repository('not a repository')
+        end.to raise_error(ArgumentError, 'given repository does not respond to active_features')
+      end
+
+      it 'should get active features lazy on first usage' do
+        @repository.add_active_feature(:feature_a)
+        # the line below will be the first usage of feature in this case
+        expect(Feature.active?(:feature_a)).to be_truthy
+      end
+
+      it 'should get active features from repository once' do
+        Feature.active?(:does_not_matter)
+        @repository.add_active_feature(:feature_a)
+        expect(Feature.active?(:feature_a)).to be_falsey
+      end
+
+      it 'should reload active features on first call only' do
+        @repository.add_active_feature(:feature_a)
+        expect(@repository).to receive(:active_features).exactly(1).times
+                           .and_return(@repository.active_features)
+        Feature.active?(:feature_a)
+        Feature.active?(:feature_a)
+      end
     end
 
-    it "should get active features from repository once" do
-      @repository.add_active_feature(:feature_a)
-      expect(Feature.active?(:feature_a)).to be_falsey
+    context 'with auto_refresh set to true' do
+      before(:each) do
+        Feature.set_repository @repository, true
+      end
+      it 'should reload active features on every call' do
+        @repository.add_active_feature(:feature_a)
+        expect(@repository).to receive(:active_features).exactly(2).times
+                           .and_return(@repository.active_features)
+        Feature.active?(:feature_a)
+        Feature.active?(:feature_a)
+      end
     end
   end
 
-  context "refresh features" do
+  context 'refresh features' do
     before(:each) do
       @repository = Feature::Repository::SimpleRepository.new
       Feature.set_repository @repository
     end
 
-    it "should refresh active feature lists from repository" do
+    it 'should refresh active feature lists from repository' do
       @repository.add_active_feature(:feature_a)
       Feature.refresh!
       expect(Feature.active?(:feature_a)).to be_truthy
     end
   end
 
-  context "request features" do
+  context 'request features' do
     before(:each) do
       repository = Feature::Repository::SimpleRepository.new
       repository.add_active_feature :feature_active
       Feature.set_repository repository
     end
 
-    it "should affirm active feature is active" do
+    it 'should affirm active feature is active' do
       expect(Feature.active?(:feature_active)).to be_truthy
     end
 
-    it "should not affirm active feature is inactive" do
+    it 'should not affirm active feature is inactive' do
       expect(Feature.inactive?(:feature_active)).to be_falsey
     end
 
-    it "should affirm inactive feature is inactive" do
+    it 'should affirm inactive feature is inactive' do
       expect(Feature.inactive?(:feature_inactive)).to be_truthy
     end
 
-    it "should not affirm inactive feature is active" do
+    it 'should not affirm inactive feature is active' do
       expect(Feature.active?(:feature_inactive)).to be_falsey
     end
 
-    it "should call block with active feature in active list" do
+    it 'should call block with active feature in active list' do
       reached = false
 
       Feature.with(:feature_active) do
@@ -93,7 +125,7 @@ describe Feature do
       expect(reached).to be_truthy
     end
 
-    it "should not call block with active feature not in active list" do
+    it 'should not call block with active feature not in active list' do
       reached = false
 
       Feature.with(:feature_inactive) do
@@ -103,13 +135,13 @@ describe Feature do
       expect(reached).to be_falsey
     end
 
-    it "should raise exception when no block given to with" do
+    it 'should raise exception when no block given to with' do
       expect do
         Feature.with(:feature_active)
-      end.to raise_error(ArgumentError, "no block given to with")
+      end.to raise_error(ArgumentError, 'no block given to with')
     end
 
-    it "should call block without inactive feature in inactive list" do
+    it 'should call block without inactive feature in inactive list' do
       reached = false
 
       Feature.without(:feature_inactive) do
@@ -119,7 +151,7 @@ describe Feature do
       expect(reached).to be_truthy
     end
 
-    it "should not call block without inactive feature in inactive list" do
+    it 'should not call block without inactive feature in inactive list' do
       reached = false
 
       Feature.without(:feature_active) do
@@ -129,33 +161,33 @@ describe Feature do
       expect(reached).to be_falsey
     end
 
-    it "should raise exception when no block given to without" do
+    it 'should raise exception when no block given to without' do
       expect do
         Feature.without(:feature_inactive)
-      end.to raise_error(ArgumentError, "no block given to without")
+      end.to raise_error(ArgumentError, 'no block given to without')
     end
 
     describe 'switch()' do
       context 'given a value' do
-        it "should return the first value if the feature is active" do
+        it 'should return the first value if the feature is active' do
           retval = Feature.switch(:feature_active, 1, 2)
           expect(retval).to eq(1)
         end
 
-        it "should return the second value if the feature is inactive" do
+        it 'should return the second value if the feature is inactive' do
           retval = Feature.switch(:feature_inactive, 1, 2)
           expect(retval).to eq(2)
         end
       end
 
       context 'given a proc/lambda' do
-        it "should call the first proc/lambda if the feature is active" do
-          retval = Feature.switch(:feature_active, lambda { 1 }, lambda { 2 })
+        it 'should call the first proc/lambda if the feature is active' do
+          retval = Feature.switch(:feature_active, -> { 1 }, -> { 2 })
           expect(retval).to eq(1)
         end
 
-        it "should call the second proc/lambda if the feature is active" do
-          retval = Feature.switch(:feature_inactive, lambda { 1 }, lambda { 2 })
+        it 'should call the second proc/lambda if the feature is active' do
+          retval = Feature.switch(:feature_inactive, -> { 1 }, -> { 2 })
           expect(retval).to eq(2)
         end
       end

data/spec/feature/redis_repository_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+include Feature::Repository
+
+describe Feature::Repository::RedisRepository do
+  before(:each) do
+    @repository = RedisRepository.new('application_features')
+  end
+
+  it 'should have no active features after initialization' do
+    expect(@repository.active_features).to eq([])
+  end
+
+  it 'should add an active feature' do
+    @repository.add_active_feature :feature_a
+    expect(@repository.active_features).to eq([:feature_a])
+  end
+
+  it 'should only show active feature' do
+    Redis.current.hset('application_features', 'inactive_a', false)
+    Redis.current.hset('application_features', 'inactive_b', false)
+    Redis.current.hset('application_features', 'feature_a', true)
+    Redis.current.hset('application_features', 'feature_b', true)
+
+    expect(@repository.active_features).to eq([:feature_a, :feature_b])
+  end
+
+  it 'should raise an exception when adding not a symbol as active feature' do
+    expect do
+      @repository.add_active_feature 'feature_a'
+    end.to raise_error(ArgumentError, 'feature_a is not a symbol')
+  end
+
+  it 'should raise an exception when adding a active feature already added as active' do
+    @repository.add_active_feature :feature_a
+    expect do
+      @repository.add_active_feature :feature_a
+    end.to raise_error(ArgumentError, 'feature :feature_a already added')
+  end
+
+end

data/spec/feature/simple_repository_spec.rb

@@ -7,25 +7,31 @@ describe Feature::Repository::SimpleRepository do
     @repository = SimpleRepository.new
   end
 
-  it "should have no active features after initialization" do
+  it 'should have no active features after initialization' do
     expect(@repository.active_features).to eq([])
   end
 
-  it "should add an active feature" do
+  it 'should add an active feature' do
     @repository.add_active_feature :feature_a
     expect(@repository.active_features).to eq([:feature_a])
   end
 
-  it "should raise an exception when adding not a symbol as active feature" do
+  it 'should add an feature without having impact on internal structure' do
+    list = @repository.active_features
+    @repository.add_active_feature :feature_a
+    expect(list).to eq([])
+  end
+
+  it 'should raise an exception when adding not a symbol as active feature' do
     expect do
       @repository.add_active_feature 'feature_a'
-    end.to raise_error(ArgumentError, "given feature feature_a is not a symbol")
+    end.to raise_error(ArgumentError, 'feature_a is not a symbol')
   end
 
-  it "should raise an exception when adding a active feature already added as active" do
+  it 'should raise an exception when adding a active feature already added as active' do
     @repository.add_active_feature :feature_a
     expect do
       @repository.add_active_feature :feature_a
-    end.to raise_error(ArgumentError, "feature :feature_a already added to list of active features")
+    end.to raise_error(ArgumentError, 'feature :feature_a already added')
   end
 end