Add the possibility to fetch all features already released to a given resource

lib/feature_flagger/control.rb

@@ -3,6 +3,7 @@ class Control
     attr_reader :storage
 
     RELEASED_FEATURES = 'released_features'
+    MINIMUM_VALID_FEATURE_PATH = 2.freeze
 
     def initialize(storage)
       @storage = storage
@@ -13,15 +14,21 @@ def released?(feature_key, resource_id)
     end
 
     def release(feature_key, resource_id)
-      @storage.add(feature_key, resource_id)
+      resource_name = extract_resource_name_from_feature_key(feature_key)
+      @storage.add(feature_key, resource_name, resource_id)
+    end
+
+    def releases(resource_name, resource_id)
+      @storage.fetch_releases(resource_name, resource_id, RELEASED_FEATURES)
     end
 
     def release_to_all(feature_key)
       @storage.add_all(RELEASED_FEATURES, feature_key)
     end
 
     def unrelease(feature_key, resource_id)
-      @storage.remove(feature_key, resource_id)
+      resource_name = extract_resource_name_from_feature_key(feature_key)
+      @storage.remove(feature_key, resource_name, resource_id)
     end
 
     def unrelease_to_all(feature_key)
@@ -43,5 +50,18 @@ def released_to_all?(feature_key)
     def search_keys(query)
       @storage.search_keys(query)
     end
+
+    private
+
+    def extract_resource_name_from_feature_key(feature_key)
+      feature_paths = feature_key.split(':')
+
+      raise InvalidResourceNameError unless feature_paths
+      raise InvalidResourceNameError if feature_paths.size < MINIMUM_VALID_FEATURE_PATH
+
+      feature_paths.first
+    end
+
+    class InvalidResourceNameError < StandardError; end
   end
 end

lib/feature_flagger/model.rb

@@ -26,6 +26,11 @@ def unrelease(*feature_key)
       FeatureFlagger.control.unrelease(feature.key, id)
     end
 
+    def releases
+      resource_name = self.class.feature_flagger_model_settings.entity_name
+      FeatureFlagger.control.releases(resource_name, id)
+    end
+
     private
 
     def feature_flagger_identifier

lib/feature_flagger/storage/redis.rb

@@ -1,11 +1,13 @@
 require 'redis'
 require 'redis-namespace'
+require_relative './redis_keys'
 
 module FeatureFlagger
   module Storage
     class Redis
-
       DEFAULT_NAMESPACE = :feature_flagger
+      RESOURCE_PREFIX = "_r".freeze
+      SCAN_EACH_BATCH_SIZE = 1000.freeze
 
       def initialize(redis)
         @redis = redis
@@ -17,23 +19,40 @@ def self.default_client
         new(ns)
       end
 
+      def fetch_releases(resource_name, resource_id, global_key)
+        resource_key = resource_key(resource_name, resource_id)
+        @redis.sunion(resource_key, global_key)
+      end
+
       def has_value?(key, value)
         @redis.sismember(key, value)
       end
 
-      def add(key, value)
-        @redis.sadd(key, value)
+      def add(feature_key, resource_name, resource_id)
+        resource_key = resource_key(resource_name, resource_id)
+
+        @redis.multi do |redis|
+          redis.sadd(feature_key, resource_id)
+          redis.sadd(resource_key, feature_key)
+        end
       end
 
-      def remove(key, value)
-        @redis.srem(key, value)
+      def remove(feature_key, resource_name, resource_id)
+        resource_key = resource_key(resource_name, resource_id)
+
+        @redis.multi do |redis|
+          redis.srem(feature_key, resource_id)
+          redis.srem(resource_key, feature_key)
+        end
       end
 
-      def remove_all(global_key, key)
+      def remove_all(global_key, feature_key)
         @redis.multi do |redis|
-          redis.srem(global_key, key)
-          redis.del(key)
+          redis.srem(global_key, feature_key)
+          redis.del(feature_key)
         end
+
+        remove_feature_key_from_resources(feature_key)
       end
 
       def add_all(global_key, key)
@@ -50,6 +69,32 @@ def all_values(key)
       def search_keys(query)
         @redis.scan_each(match: query)
       end
+
+      private
+
+      def resource_key(resource_name, resource_id)
+        FeatureFlagger::Storage::RedisKeys.resource_key(
+          RESOURCE_PREFIX,
+          resource_name,
+          resource_id,
+        )
+      end
+
+      def remove_feature_key_from_resources(feature_key)
+        cursor = 0
+
+        loop do
+          cursor, resource_keys = @redis.scan(cursor, match: "#{RESOURCE_PREFIX}:*", count: SCAN_EACH_BATCH_SIZE)
+
+          @redis.multi do |redis|
+            resource_keys.each do |key|
+              redis.srem(key, feature_key)
+            end
+          end
+
+          break if cursor == "0"
+        end
+      end
     end
   end
 end

lib/feature_flagger/storage/redis_keys.rb

@@ -0,0 +1,9 @@
+module FeatureFlagger
+  module Storage
+    module RedisKeys
+      def self.resource_key(prefix, resource_name, resource_id)
+        "#{prefix}:#{resource_name}:#{resource_id}"
+      end
+    end
+  end
+end

spec/feature_flagger/control_spec.rb

@@ -5,8 +5,9 @@ module FeatureFlagger
     let(:redis) { FakeRedis::Redis.new }
     let(:storage) { Storage::Redis.new(redis) }
     let(:control) { Control.new(storage) }
-    let(:key)         { 'key' }
+    let(:key)         { 'account:email_marketing:whitelabel' }
     let(:resource_id) { 'resource_id' }
+    let(:resource_name) { 'account' }
 
     before do
       redis.flushdb
@@ -19,19 +20,19 @@ module FeatureFlagger
         it { expect(result).to be_falsey }
 
         context 'and a feature is release to all' do
-          before { storage.add(FeatureFlagger::Control::RELEASED_FEATURES, key) }
+          before { storage.add(FeatureFlagger::Control::RELEASED_FEATURES, resource_name, key) }
 
           it { expect(result).to be_truthy }
         end
       end
 
       context 'when resource entity id has access to release_key' do
-        before { storage.add(key, resource_id) }
+        before { storage.add(key, resource_name, resource_id) }
 
         it { expect(result).to be_truthy }
 
         context 'and a feature is release to all' do
-          before { storage.add(FeatureFlagger::Control::RELEASED_FEATURES, key) }
+          before { storage.add(FeatureFlagger::Control::RELEASED_FEATURES, resource_name, key) }
 
           it { expect(result).to be_truthy }
         end
@@ -45,9 +46,17 @@ module FeatureFlagger
       end
     end
 
+    describe '#releases' do
+      it 'return all releases to a given resource' do
+        control.release(key, resource_id)
+        resource_name = 'account'
+        expect(control.releases(resource_name, resource_id)).to match_array(['account:email_marketing:whitelabel'])
+      end
+    end
+
     describe '#release_to_all' do
       it 'adds feature_key to storage' do
-        storage.add(key, 1)
+        storage.add(key, resource_name, 1)
         control.release_to_all(key)
         expect(storage).not_to have_value(key, 1)
         expect(storage).to have_value(FeatureFlagger::Control::RELEASED_FEATURES, key)
@@ -56,21 +65,21 @@ module FeatureFlagger
 
     describe '#unrelease' do
       it 'removes resource_id from storage' do
-        storage.add(key, resource_id)
+        storage.add(key, resource_name, resource_id)
         control.unrelease(key, resource_id)
         expect(storage).not_to have_value(key, resource_id)
       end
     end
 
     describe '#unrelease_to_all' do
       it 'removes feature_key to storage' do
-        storage.add(FeatureFlagger::Control::RELEASED_FEATURES, key)
+        storage.add(FeatureFlagger::Control::RELEASED_FEATURES, resource_name, key)
         control.unrelease_to_all(key)
         expect(storage).not_to have_value(FeatureFlagger::Control::RELEASED_FEATURES, key)
       end
 
       it 'removes added resources' do
-        storage.add(key, 1)
+        storage.add(key, resource_name, 1)
         control.unrelease_to_all(key)
         expect(storage).not_to have_value(key, 1)
         expect(storage).not_to have_value(FeatureFlagger::Control::RELEASED_FEATURES, key)
@@ -92,34 +101,32 @@ module FeatureFlagger
       subject { control.released_features_to_all }
 
       it 'returns all the values to given features' do
-        control.release(FeatureFlagger::Control::RELEASED_FEATURES, 'feature::name1')
-        control.release(FeatureFlagger::Control::RELEASED_FEATURES, 'feature::name2')
-        control.release(FeatureFlagger::Control::RELEASED_FEATURES, 'feature::name15')
-        expect(subject).to match_array %w[feature::name1 feature::name2 feature::name15]
+        control.release_to_all('account:feature:name1')
+        control.release_to_all('account:feature:name2')
+        control.release_to_all('account:feature:name15')
+        expect(subject).to match_array %w[account:feature:name1 account:feature:name2 account:feature:name15]
       end
     end
 
     describe '#released_to_all?' do
       let(:result) { control.released_to_all?(key) }
 
       context 'when feature was not released to all' do
-        before { storage.remove(FeatureFlagger::Control::RELEASED_FEATURES, key) }
-
         it { expect(result).to be_falsey }
       end
 
       context 'when feature was released to all' do
-        before { storage.add(FeatureFlagger::Control::RELEASED_FEATURES, key) }
+        before { storage.add_all(FeatureFlagger::Control::RELEASED_FEATURES, key) }
 
         it { expect(result).to be_truthy }
       end
     end
 
     describe '#search_keys' do
       before do
-        storage.add('namespace:1', 1)
-        storage.add('namespace:2', 2)
-        storage.add('exclusive', 3)
+        storage.add('namespace:1', resource_name, 1)
+        storage.add('namespace:2', resource_name, 2)
+        storage.add('exclusive', resource_name, 3)
       end
 
       context 'without matching result' do

spec/feature_flagger/model_spec.rb

@@ -24,6 +24,13 @@ def id; 14 end
         subject.release(key)
       end
     end
+
+    describe '#releases' do
+      it 'calls Control#release with appropriated methods' do
+        expect(control).to receive(:releases).with("feature_flagger_dummy_class", subject.id)
+        subject.releases
+      end
+    end
 
     describe '#unrelease' do
       it 'calls Control#unrelease with appropriated methods' do