Merge pull request #551 from splitio/rbs-integrations-tests

Integrations tests

Author: chillaq

lib/splitclient-rb.rb

@@ -105,6 +105,7 @@
 require 'splitclient-rb/engine/metrics/binary_search_latency_tracker'
 require 'splitclient-rb/engine/models/split'
 require 'splitclient-rb/engine/models/label'
+require 'splitclient-rb/engine/models/segment_type'
 require 'splitclient-rb/engine/models/treatment'
 require 'splitclient-rb/engine/auth_api_client'
 require 'splitclient-rb/engine/back_off'

lib/splitclient-rb/cache/fetchers/split_fetcher.rb

@@ -25,9 +25,10 @@ def call
         def fetch_splits(fetch_options = { cache_control_headers: false, till: nil })
           @semaphore.synchronize do
             data = splits_since(@splits_repository.get_change_number, @rule_based_segments_repository.get_change_number, fetch_options)
-            SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@splits_repository, data[:ff][:d], data[:ff][:t], @config)
+            SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@splits_repository, data[:ff][:d], data[:ff][:t], @config, @splits_api.clear_storage)
             SplitIoClient::Helpers::RepositoryHelper.update_rule_based_segment_repository(@rule_based_segments_repository, data[:rbs][:d], data[:rbs][:t], @config)
             @splits_repository.set_segment_names(data[:segment_names])
+            @rule_based_segments_repository.set_segment_names(data[:segment_names])
             @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
             { segment_names: data[:segment_names], success: true }

lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -43,10 +43,7 @@ def initialize(config, flag_sets_repository, flag_set_filter)
           end
           @flag_sets = flag_sets_repository
           @flag_set_filter = flag_set_filter
-          unless @config.mode.equal?(:consumer)
-            @adapter.set_string(namespace_key('.splits.till'), '-1')
-            @adapter.initialize_map(namespace_key('.segments.registered'))
-          end
+          initialize_keys
         end
 
         def update(to_add, to_delete, new_change_number)
@@ -127,6 +124,7 @@ def clear
           @tt_cache.clear
 
           @adapter.clear(namespace_key)
+          initialize_keys
         end
 
         def kill(change_number, split_name, default_treatment)
@@ -167,6 +165,13 @@ def flag_set_filter
 
         private
 
+        def initialize_keys
+          unless @config.mode.equal?(:consumer)
+            @adapter.set_string(namespace_key('.splits.till'), '-1')
+            @adapter.initialize_map(namespace_key('.segments.registered'))
+          end
+        end
+
         def add_feature_flag(split)
           return unless split[:name]
           existing_split = get_split(split[:name])

lib/splitclient-rb/clients/split_client.rb

@@ -22,6 +22,7 @@ def initialize(sdk_key, repositories, status_manager, config, impressions_manage
       @api_key = sdk_key
       @splits_repository = repositories[:splits]
       @segments_repository = repositories[:segments]
+      @rule_based_segments_repository = repositories[:rule_based_segments]
       @impressions_repository = repositories[:impressions]
       @events_repository = repositories[:events]
       @status_manager = status_manager
@@ -115,6 +116,7 @@ def destroy
 
       @splits_repository.clear
       @segments_repository.clear
+      @rule_based_segments_repository.clear
 
       SplitIoClient.load_factory_registry
       SplitIoClient.split_factory_registry.remove(@api_key)

lib/splitclient-rb/engine/api/client.rb

@@ -50,6 +50,9 @@ def post_api(url, api_key, data, headers = {}, params = {})
         raise e, 'Split SDK failed to connect to backend to post information', e.backtrace
       end
 
+      def sdk_url_overriden?
+        @config.sdk_url_overriden?
+      end
       private
 
       def api_client

lib/splitclient-rb/engine/api/splits.rb

@@ -5,35 +5,79 @@ module Api
     # Retrieves split definitions from the Split Backend
     class Splits < Client
 
+      PROXY_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+      SPEC_1_1 = "1.1"
+
       def initialize(api_key, config, telemetry_runtime_producer)
         super(config)
         @api_key = api_key
         @telemetry_runtime_producer = telemetry_runtime_producer
         @flag_sets_filter = @config.flag_sets_filter
+        @spec_version = SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+        @last_proxy_check_timestamp = 0
+        @clear_storage = false
+        @old_spec_since = nil
       end
 
       def since(since, since_rbs, fetch_options = { cache_control_headers: false, till: nil, sets: nil})
         start = Time.now
+        
+        if check_last_proxy_check_timestamp
+            @spec_version = SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @config.logger.debug("Switching to new Feature flag spec #{@spec_version} and fetching.")
+            @old_spec_since = since
+            since = -1
+            since_rbs = -1
+            fetch_options = { cache_control_headers: false, till: nil, sets: nil}
+        end
+
+        if @spec_version == Splits::SPEC_1_1
+          since = @old_spec_since unless @old_spec_since.nil?
+          params = { s: @spec_version, since: since }
+          @old_spec_since = nil
+        else
+          params = { s: @spec_version, since: since, rbSince: since_rbs }
+        end
 
-        params = { s: SplitIoClient::Spec::FeatureFlags::SPEC_VERSION, since: since, rbSince: since_rbs }
         params[:sets] = @flag_sets_filter.join(",") unless @flag_sets_filter.empty?
         params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
         @config.logger.debug("Fetching from splitChanges with #{params}: ")
         response = get_api("#{@config.base_uri}/splitChanges", @api_key, params, fetch_options[:cache_control_headers])
+
         if response.status == 414
           @config.logger.error("Error fetching feature flags; the amount of flag sets provided are too big, causing uri length error.")
           raise ApiException.new response.body, 414
         end
+
+        if response.status == 400 and sdk_url_overriden? and @spec_version == SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @config.logger.warn("Detected proxy response error, changing spec version from #{@spec_version} to #{Splits::SPEC_1_1} and re-fetching.")
+            @spec_version = Splits::SPEC_1_1
+            @last_proxy_check_timestamp = Time.now
+            return since(since, 0, fetch_options = {cache_control_headers: fetch_options[:cache_control_headers], till: fetch_options[:till],
+                sets: fetch_options[:sets]})          
+        end
+
         if response.success?
-          result = objects_with_segment_names(response.body)
+          result = JSON.parse(response.body, symbolize_names: true)
+          if @spec_version == Splits::SPEC_1_1
+            result = convert_to_newSPEC(result)
+          end
+          
+          result[:rbs][:d] = check_rbs_data(result[:rbs][:d])
+          result = objects_with_segment_names(result)
 
+          if @spec_version == SplitIoClient::Spec::FeatureFlags::SPEC_VERSION
+            @clear_storage = @last_proxy_check_timestamp != 0
+            @last_proxy_check_timestamp = 0
+          end
+
           unless result[:ff][:d].empty?
             @config.split_logger.log_if_debug("#{result[:ff][:d].length} feature flags retrieved. since=#{since}")
           end
           @config.split_logger.log_if_transport("Feature flag changes response: #{result[:ff].to_s}")
 
           unless result[:rbs][:d].empty?
-            @config.split_logger.log_if_debug("#{result[:ff][:d].length} rule based segments retrieved. since=#{since_rbs}")
+            @config.split_logger.log_if_debug("#{result[:rbs][:d].length} rule based segments retrieved. since=#{since_rbs}")
           end
           @config.split_logger.log_if_transport("rule based segments changes response: #{result[:rbs].to_s}")
 
@@ -52,21 +96,42 @@ def since(since, since_rbs, fetch_options = { cache_control_headers: false, till
         end
       end
 
+      def clear_storage
+        @clear_storage
+      end
+
       private
 
-      def objects_with_segment_names(objects_json)
-        parsed_objects = JSON.parse(objects_json, symbolize_names: true)
+      def check_rbs_data(rbs_data)
+        rbs_data.each do |rb_segment|
+          rb_segment[:excluded] = {:keys => [], :segments => []} if rb_segment[:excluded].nil?
+          rb_segment[:excluded][:keys] = [] if rb_segment[:excluded][:keys].nil?
+          rb_segment[:excluded][:segments] = [] if rb_segment[:excluded][:segments].nil?
+        end
+        rbs_data
+      end
+
+      def objects_with_segment_names(parsed_objects)
+        parsed_objects[:segment_names] = Set.new
         parsed_objects[:segment_names] =
           parsed_objects[:ff][:d].each_with_object(Set.new) do |split, splits|
             splits << Helpers::Util.segment_names_by_object(split, "IN_SEGMENT")
           end.flatten
-        if not parsed_objects[:ff][:rbs].nil?
-          parsed_objects[:segment_names].merge parsed_objects[:ff][:rbs].each_with_object(Set.new) do |rule_based_segment, rule_based_segments|
-            rule_based_segments << Helpers::Util.segment_names_by_object(rule_based_segment, "IN_SEGMENT")
-          end.flatten
+
+        parsed_objects[:rbs][:d].each do |rule_based_segment|
+          parsed_objects[:segment_names].merge Helpers::Util.segment_names_in_rb_segment(rule_based_segment, "IN_SEGMENT")
         end
+        
         parsed_objects
       end
+
+      def check_last_proxy_check_timestamp
+        @spec_version == Splits::SPEC_1_1 and ((Time.now - @last_proxy_check_timestamp) >= Splits::PROXY_CHECK_INTERVAL_SECONDS)
+      end
+
+      def convert_to_newSPEC(body)
+        {:ff => {:d => body[:splits], :s => body[:since], :t => body[:till]}, :rbs => {:d => [], :s => -1, :t => -1}}
+      end
     end
   end
 end

lib/splitclient-rb/engine/matchers/rule_based_segment_matcher.rb

@@ -25,13 +25,10 @@ def match?(args)
       rule_based_segment = @rule_based_segments_repository.get_rule_based_segment(@segment_name)
       return false if rule_based_segment.nil?
 
-      return false if rule_based_segment[:excluded][:keys].include?([args[:value]])
+      key = update_key(args)
+      return false if rule_based_segment[:excluded][:keys].include?(key)
 
-      rule_based_segment[:excluded][:segments].each do |segment|
-        return false if segment[:type] == 'standard' and @segments_repository.in_segment?(segment[:name], args[:value])
-        
-        return false if segment[:type] == 'rule-based' and SplitIoClient::RuleBasedSegmentMatcher.new(@segments_repository, @rule_based_segments_repository, segment[:name], @config).match?(args)
-      end
+      return false unless check_excluded_segments(rule_based_segment, key, args)
 
       matches = false
       rule_based_segment[:conditions].each do |c|
@@ -42,5 +39,34 @@ def match?(args)
       @logger.debug("[InRuleSegmentMatcher] #{@segment_name} is in rule based segment -> #{matches}")
       matches
     end
+
+    private
+
+    def check_excluded_segments(rule_based_segment, key, args)
+      rule_based_segment[:excluded][:segments].each do |segment|
+        return false if segment[:type] == SplitIoClient::Engine::Models::SegmentType::STANDARD && @segments_repository.in_segment?(segment[:name], key)
+
+        return false if segment[:type] == SplitIoClient::Engine::Models::SegmentType::RULE_BASED_SEGMENT && match_rbs(
+          @rule_based_segments_repository.get_rule_based_segment(segment[:name]), args
+        )
+      end
+      true
+    end
+
+    def update_key(args)
+      if args[:value].nil? || args[:value].empty?
+        args[:matching_key]
+      else
+        args[:value]
+      end
+    end
+
+    def match_rbs(rule_based_segment, args)
+      rbs_matcher = RuleBasedSegmentMatcher.new(@segments_repository, @rule_based_segments_repository,
+                                                rule_based_segment[:name], @config)
+      rbs_matcher.match?(matching_key: args[:matching_key],
+                         bucketing_key: args[:value],
+                         attributes: args[:attributes])
+    end
   end
 end

lib/splitclient-rb/engine/models/segment_type.rb

@@ -0,0 +1,4 @@
+class SplitIoClient::Engine::Models::SegmentType
+  STANDARD = 'standard'
+  RULE_BASED_SEGMENT = 'rule-based'
+end

lib/splitclient-rb/engine/parser/condition.rb

@@ -253,7 +253,7 @@ def negate
     # @return [void]
     def set_partitions
       partitions_list = []
-      return partitions_list unless @data.key?('partitions')
+      return partitions_list unless @data.key?(:partitions) or @data.key?('partitions')
 
       @data[:partitions].each do |p|
         partition = SplitIoClient::Partition.new(p)

lib/splitclient-rb/engine/parser/evaluator.rb

@@ -5,6 +5,7 @@ class Evaluator
         def initialize(segments_repository, splits_repository, rb_segment_repository, config)
           @splits_repository = splits_repository
           @segments_repository = segments_repository
+          @rb_segment_repository = rb_segment_repository
           @config = config
         end
 
@@ -58,7 +59,6 @@ def match(split, keys, attributes)
 
               in_rollout = true
             end
-
             condition_matched = Helpers::EvaluatorHelper::matcher_type(condition, @segments_repository, @rb_segment_repository).match?(
               matching_key: keys[:matching_key],
               bucketing_key: keys[:bucketing_key],