Integrations tests

Author: chillaq

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

@@ -28,6 +28,7 @@ def fetch_splits(fetch_options = { cache_control_headers: false, till: nil })
             SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@splits_repository, data[:ff][:d], data[:ff][:t], @config)
             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/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/splits.rb

@@ -33,7 +33,7 @@ def since(since, since_rbs, fetch_options = { cache_control_headers: false, till
           @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}")
 
@@ -56,15 +56,24 @@ def since(since, since_rbs, fetch_options = { cache_control_headers: false, till
 
       def objects_with_segment_names(objects_json)
         parsed_objects = JSON.parse(objects_json, symbolize_names: true)
+        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_by_object(rule_based_segment, "IN_SEGMENT")
+        end
+
+        parsed_objects[:rbs][:d].each do |rule_based_segment| 
+          rule_based_segment[:excluded][:segments].each do |segment|
+            if segment[:type] == "standard"
+              parsed_objects[:segment_names].add(segment[:name])
+            end
+          end
         end
+        
         parsed_objects
       end
     end

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

@@ -25,13 +25,18 @@ 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]])
+      if args[:value].nil? or args[:value].empty?
+        key = args[:matching_key]
+      else
+        key = args[:value]   
+      end
+      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] == 'standard' and @segments_repository.in_segment?(segment[:name], key)
 
         if segment[:type] == 'rule-based'
-          return true if match_rbs(@rule_based_segments_repository.get_rule_based_segment(segment[:name])[:conditions], args)
+          return false if match_rbs(@rule_based_segments_repository.get_rule_based_segment(segment[:name]), args)
         end
       end
 
@@ -49,18 +54,13 @@ def match?(args)
 
     private
 
-    def match_rbs(conditions, args)
-      conditions.each do |condition|
-        next if condition.empty?
-
-        return true if Helpers::EvaluatorHelper::matcher_type(SplitIoClient::Condition.new(condition, @config), 
-              @segments_repository, @rule_based_segments_repository).match?(
-                matching_key: args[:matching_key],
-                bucketing_key: args[:value],
-                attributes: args[:attributes]
+    def match_rbs(rule_based_segment, args)      
+      rbs_matcher = RuleBasedSegmentMatcher.new(@segments_repository, @rule_based_segments_repository, rule_based_segment[:name], @config)
+      return rbs_matcher.match?(
+                  matching_key: args[:matching_key],
+                  bucketing_key: args[:value],
+                  attributes: args[:attributes]
               )
-      end
-      return false
     end
   end
 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],

lib/splitclient-rb/helpers/evaluator_helper.rb

@@ -8,7 +8,7 @@ def self.matcher_type(condition, segments_repository, rb_segment_repository)
         segments_repository.adapter.pipelined do
           condition.matchers.each do |matcher|
             matchers << if matcher[:negate]
-                          condition.negation_matcher(matcher_instance(matcher[:matcherType], condition, matcher))
+                          condition.negation_matcher(matcher_instance(matcher[:matcherType], condition, matcher, segments_repository, rb_segment_repository))
                         else
                           matcher_instance(matcher[:matcherType], condition, matcher, segments_repository, rb_segment_repository)
                         end

lib/splitclient-rb/split_factory.rb

@@ -55,7 +55,7 @@ def initialize(api_key, config_hash = {})
 
       @status_manager = Engine::StatusManager.new(@config)
       @split_validator = SplitIoClient::Validators.new(@config)
-      @evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @config)
+      @evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @rule_based_segment_repository, @config)
 
       start!
 
@@ -179,7 +179,7 @@ def build_telemetry_components
     end
 
     def build_fetchers
-      @split_fetcher = SplitFetcher.new(@splits_repository, @rule_based_segments_repository, @api_key, @config, @runtime_producer)
+      @split_fetcher = SplitFetcher.new(@splits_repository, @rule_based_segment_repository, @api_key, @config, @runtime_producer)
       @segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, @config, @runtime_producer)
     end
 
@@ -221,7 +221,7 @@ def build_repositories
       end
       @splits_repository = SplitsRepository.new(@config, @flag_sets_repository, @flag_sets_filter)
       @segments_repository = SegmentsRepository.new(@config)
-      @rule_based_segment_repository = RuleBasedSegmentRepository.new(@config)
+      @rule_based_segment_repository = RuleBasedSegmentsRepository.new(@config)
       @impressions_repository = ImpressionsRepository.new(@config)
       @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
     end

spec/allocations/splitclient-rb/clients/split_client_spec.rb

@@ -10,6 +10,7 @@
   let(:splits_repository) { SplitIoClient::Cache::Repositories::SplitsRepository.new(config, flag_sets_repository, flag_set_filter) }
   let(:segments_repository) { SplitIoClient::Cache::Repositories::SegmentsRepository.new(config) }
   let(:impressions_repository) { SplitIoClient::Cache::Repositories::ImpressionsRepository.new(config) }
+  let(:rule_based_segments_repository) { SplitIoClient::Cache::Repositories::RuleBasedSegmentsRepository.new(config) }
   let(:impression_counter) { SplitIoClient::Engine::Common::ImpressionCounter.new }
   let(:evaluation_producer) { SplitIoClient::Telemetry::EvaluationProducer.new(config) }
   let(:impression_observer) { SplitIoClient::Observers::ImpressionObserver.new }
@@ -19,7 +20,7 @@
   let(:api_key) { 'SplitClient-key' }
   let(:telemetry_api) { SplitIoClient::Api::TelemetryApi.new(config, api_key, runtime_producer) }
   let(:impressions_api) { SplitIoClient::Api::Impressions.new(api_key, config, runtime_producer) }
-  let(:evaluator) { SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, config) }
+  let(:evaluator) { SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, rule_based_segments_repository, config) }
   let(:sender_adapter) do
     SplitIoClient::Cache::Senders::ImpressionsSenderAdapter.new(config,
                                                                 telemetry_api,

spec/cache/fetchers/segment_fetch_spec.rb

@@ -26,7 +26,7 @@
     stub_request(:get, 'https://sdk.split.io/api/segmentChanges/employees?since=1473863075059')
       .to_return(status: 200, body: segments_json2)
 
-    stub_request(:get, 'https://sdk.split.io/api/splitChanges?s=1.1&since=-1')
+    stub_request(:get, 'https://sdk.split.io/api/splitChanges?s=1.3&since=-1&rbSince=-1')
       .to_return(status: 200, body: splits_with_segments_json)
   end