featurevisor 0.2.0 → 1.0.0

data/bin/commands/test.rb

@@ -1,6 +1,7 @@
 require "json"
 require "find"
 require "open3"
+require "shellwords"
 
 module FeaturevisorCLI
   module Commands
@@ -19,17 +20,18 @@ module FeaturevisorCLI
 
         # Get project configuration
         config = get_config
-        environments = config[:environments] || []
-        segments_by_key = get_segments
-
-        # Use CLI schemaVersion option or fallback to config
-        schema_version = @options.schema_version
-        if schema_version.nil? || schema_version.empty?
-          schema_version = config[:schemaVersion]
+        environments = get_environments(config)
+        available_targets = get_targets
+        unknown_target = @options.targets.find { |target| !available_targets.include?(target) }
+        if unknown_target
+          puts "Unknown target \"#{unknown_target}\". Available targets: #{available_targets.empty? ? "none" : available_targets.join(", ")}."
+          exit 1
         end
+        targets = @options.targets.empty? ? available_targets : @options.targets
+        segments_by_key = get_segments
 
-        # Build datafiles for all environments
-        datafiles_by_environment = build_datafiles(environments, schema_version, @options.inflate)
+        # Build base and Target datafiles for all environments.
+        datafiles_by_key = build_datafiles(environments, targets, @options.inflate)
 
         puts ""
 
@@ -42,18 +44,15 @@ module FeaturevisorCLI
           return
         end
 
-        # Create SDK instances for each environment
-        sdk_instances_by_environment = create_sdk_instances(environments, datafiles_by_environment, level)
-
         # Run tests
-        run_tests(tests, sdk_instances_by_environment, datafiles_by_environment, segments_by_key, level)
+        run_tests(tests, datafiles_by_key, segments_by_key, level, config)
       end
 
       private
 
       def get_config
         puts "Getting config..."
-        command = "(cd #{@project_path} && npx featurevisor config --json)"
+        command = "(cd #{Shellwords.escape(@project_path)} && npx featurevisor config --json)"
         config_output = execute_command(command)
 
         begin
@@ -67,7 +66,7 @@ module FeaturevisorCLI
 
       def get_segments
         puts "Getting segments..."
-        command = "(cd #{@project_path} && npx featurevisor list --segments --json)"
+        command = "(cd #{Shellwords.escape(@project_path)} && npx featurevisor list --segments --json)"
         segments_output = execute_command(command)
 
         begin
@@ -86,40 +85,105 @@ module FeaturevisorCLI
         end
       end
 
-      def build_datafiles(environments, schema_version, inflate)
-        datafiles_by_environment = {}
+      def get_targets
+        puts "Getting targets..."
+        command = "(cd #{Shellwords.escape(@project_path)} && npx featurevisor list --targets --json)"
+        targets_output = execute_command(command)
+
+        begin
+          targets = JSON.parse(targets_output, symbolize_names: true)
+
+          if targets.is_a?(Array)
+            targets.filter_map do |target|
+              if target.is_a?(Hash)
+                target[:name] || target[:key]
+              else
+                target
+              end
+            end
+          elsif targets.is_a?(Hash)
+            targets.keys
+          else
+            []
+          end
+        rescue JSON::ParserError => e
+          puts "Error: Failed to parse targets JSON: #{e.message}"
+          puts "Command output: #{targets_output}"
+          exit 1
+        end
+      end
+
+      def get_environments(config)
+        environments = config[:environments]
+
+        return [false] if environments == false
+        return environments if environments.is_a?(Array) && !environments.empty?
+
+        [false]
+      end
+
+      def base_datafile_key(environment)
+        environment == false ? false : environment
+      end
+
+      def target_datafile_key(environment, target)
+        if environment == false
+          "false-target-#{target}"
+        else
+          "#{environment}-target-#{target}"
+        end
+      end
+
+      def build_datafiles(environments, targets, inflate)
+        datafiles_by_key = {}
 
         environments.each do |environment|
-          puts "Building datafile for environment: #{environment}..."
+          environment_label = environment == false ? "default (no environment)" : environment
+          puts "Building datafile for environment: #{environment_label}..."
 
-          command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--json"]
+          datafiles_by_key[base_datafile_key(environment)] = build_single_datafile(
+            environment: environment,
+            inflate: inflate
+          )
 
-          if schema_version && !schema_version.empty?
-            command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--schemaVersion=#{schema_version}", "--json"]
+          targets.each do |target|
+            puts "Building datafile for target: #{target}..."
+            datafiles_by_key[target_datafile_key(environment, target)] = build_single_datafile(
+              environment: environment,
+              inflate: inflate,
+              target: target
+            )
           end
+        end
 
-          if inflate && inflate > 0
-            if schema_version && !schema_version.empty?
-              command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--schemaVersion=#{schema_version}", "--inflate=#{inflate}", "--json"]
-            else
-              command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--inflate=#{inflate}", "--json"]
-            end
-          end
+        datafiles_by_key
+      end
 
-          command = command_parts.join(" ")
-          datafile_output = execute_command(command)
+      def build_single_datafile(environment:, inflate:, target: nil)
+        command_parts = ["npx", "featurevisor", "build", "--json"]
 
-          begin
-            datafile = JSON.parse(datafile_output, symbolize_names: true)
-            datafiles_by_environment[environment] = datafile
-          rescue JSON::ParserError => e
-            puts "Error: Failed to parse datafile JSON for #{environment}: #{e.message}"
-            puts "Command output: #{datafile_output}"
-            exit 1
-          end
+        if environment != false && !environment.nil?
+          command_parts << "--environment=#{Shellwords.escape(environment.to_s)}"
+        end
+
+        if inflate && inflate > 0
+          command_parts << "--inflate=#{inflate}"
+        end
+
+        if target
+          command_parts << "--target=#{Shellwords.escape(target.to_s)}"
         end
 
-        datafiles_by_environment
+        command = "(cd #{Shellwords.escape(@project_path)} && #{command_parts.join(' ')})"
+        datafile_output = execute_command(command)
+
+        begin
+          JSON.parse(datafile_output, symbolize_names: true)
+        rescue JSON::ParserError => e
+          puts "Error: Failed to parse datafile JSON: #{e.message}"
+          puts "Command output: #{datafile_output}"
+          exit 1
+        end
       end
 
       def get_logger_level
@@ -133,17 +197,17 @@ module FeaturevisorCLI
       end
 
       def get_tests
-        command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "list", "--tests", "--applyMatrix", "--json"]
+        command_parts = ["npx", "featurevisor", "list", "--tests", "--applyMatrix", "--json"]
 
         if @options.key_pattern && !@options.key_pattern.empty?
-          command_parts << "--keyPattern=#{@options.key_pattern}"
+          command_parts << "--keyPattern=#{Shellwords.escape(@options.key_pattern)}"
         end
 
         if @options.assertion_pattern && !@options.assertion_pattern.empty?
-          command_parts << "--assertionPattern=#{@options.assertion_pattern}"
+          command_parts << "--assertionPattern=#{Shellwords.escape(@options.assertion_pattern)}"
         end
 
-        command = command_parts.join(" ")
+        command = "(cd #{Shellwords.escape(@project_path)} && #{command_parts.join(' ')})"
         tests_output = execute_command(command)
 
         begin
@@ -155,31 +219,44 @@ module FeaturevisorCLI
         end
       end
 
-      def create_sdk_instances(environments, datafiles_by_environment, level)
-        sdk_instances_by_environment = {}
+      def resolve_datafile_for_assertion(assertion, datafiles_by_key)
+        environment = assertion.key?(:environment) ? assertion[:environment] : false
+        environment = false if environment.nil?
 
-        environments.each do |environment|
-          datafile = datafiles_by_environment[environment]
-
-          # Create SDK instance
-          instance = Featurevisor.create_instance(
-            datafile: datafile,
-            log_level: level,
-            hooks: [
-              {
-                name: "tester-hook",
-                bucket_value: ->(options) { options.bucket_value }
-              }
-            ]
-          )
+        target_key = assertion[:target] ? target_datafile_key(environment, assertion[:target]) : nil
+        base_key = base_datafile_key(environment)
 
-          sdk_instances_by_environment[environment] = instance
+        if target_key && datafiles_by_key.key?(target_key)
+          return datafiles_by_key[target_key]
         end
 
-        sdk_instances_by_environment
+        datafiles_by_key[base_key]
       end
 
-      def run_tests(tests, sdk_instances_by_environment, datafiles_by_environment, segments_by_key, level)
+      def create_tester_instance(datafile, level, assertion)
+        sticky = parse_sticky(assertion[:sticky])
+
+        Featurevisor.create_featurevisor(
+          datafile: datafile,
+          sticky: sticky,
+          log_level: level,
+          modules: [
+            {
+              name: "test-module",
+              bucket_value: ->(options) do
+                at = assertion[:at]
+                if at.is_a?(Numeric)
+                  (at * 1000).to_i
+                else
+                  options[:bucket_value]
+                end
+              end
+            }
+          ]
+        )
+      end
+
+      def run_tests(tests, datafiles_by_key, segments_by_key, level, config)
         passed_tests_count = 0
         failed_tests_count = 0
         passed_assertions_count = 0
@@ -188,6 +265,12 @@ module FeaturevisorCLI
         tests.each do |test|
           test_key = test[:key]
           assertions = test[:assertions] || []
+          if test[:feature] && !@options.targets.empty?
+            assertions = assertions.select do |assertion|
+              assertion[:target].nil? || @options.targets.include?(assertion[:target])
+            end
+            next if assertions.empty?
+          end
           results = ""
           test_has_error = false
           test_duration = 0.0
@@ -197,43 +280,27 @@ module FeaturevisorCLI
               test_result = nil
 
               if test[:feature]
-                environment = assertion[:environment]
-                instance = sdk_instances_by_environment[environment]
-
-                # Show datafile if requested
-                if @options.show_datafile
-                  datafile = datafiles_by_environment[environment]
-                  puts ""
-                  puts JSON.pretty_generate(datafile)
-                  puts ""
+                datafile = resolve_datafile_for_assertion(assertion, datafiles_by_key)
+                if datafile.nil?
+                  test_result = {
+                    has_error: true,
+                    errors: "      ✘ no datafile found for assertion target/environment combination\n",
+                    duration: 0
+                  }
                 end
 
-                # If "at" parameter is provided, create a new instance with the specific hook
-                if assertion[:at]
-                  datafile = datafiles_by_environment[environment]
-
-                  instance = Featurevisor.create_instance(
-                    datafile: datafile,
-                    log_level: level,
-                    hooks: [
-                      {
-                        name: "tester-hook",
-                        bucket_value: ->(options) do
-                          # Match JavaScript implementation: assertion.at * (MAX_BUCKETED_NUMBER / 100)
-                          # MAX_BUCKETED_NUMBER is 100000, so this becomes assertion.at * 1000
-                          at = assertion[:at]
-                          if at.is_a?(Numeric)
-                            (at * 1000).to_i
-                          else
-                            options.bucket_value
-                          end
-                        end
-                      }
-                    ]
-                  )
-                end
+                if datafile
+                  instance = create_tester_instance(datafile, level, assertion)
 
-                test_result = run_test_feature(assertion, test[:feature], instance, level)
+                  # Show datafile if requested
+                  if @options.show_datafile
+                    puts ""
+                    puts JSON.pretty_generate(datafile)
+                    puts ""
+                  end
+
+                  test_result = run_test_feature(assertion, test[:feature], instance, level)
+                end
               elsif test[:segment]
                 segment_key = test[:segment]
                 segment = segments_by_key[segment_key]
@@ -325,7 +392,7 @@ module FeaturevisorCLI
           expected_variables = assertion[:expectedVariables]
           expected_variables.each do |variable_key, expected_value|
             # Set default variable value for this specific variable
-            if assertion[:defaultVariableValues] && assertion[:defaultVariableValues][variable_key]
+            if assertion[:defaultVariableValues].is_a?(Hash) && assertion[:defaultVariableValues].key?(variable_key)
               override_options[:default_variable_value] = assertion[:defaultVariableValues][variable_key]
             end
 
@@ -483,7 +550,7 @@ module FeaturevisorCLI
           expected_variables = assertion[:expectedVariables]
           expected_variables.each do |variable_key, expected_value|
             # Set default variable value for this specific variable
-            if assertion[:defaultVariableValues] && assertion[:defaultVariableValues][variable_key]
+            if assertion[:defaultVariableValues].is_a?(Hash) && assertion[:defaultVariableValues].key?(variable_key)
               override_options[:default_variable_value] = assertion[:defaultVariableValues][variable_key]
             end
 
@@ -522,6 +589,55 @@ module FeaturevisorCLI
           end
         end
 
+        # Test expectedEvaluations
+        if assertion[:expectedEvaluations]
+          expected_evaluations = assertion[:expectedEvaluations]
+
+          if expected_evaluations[:flag]
+            evaluation = evaluate_from_instance(instance, :flag, feature_key, context, override_options)
+            expected_evaluations[:flag].each do |key, expected_value|
+              actual_value = get_evaluation_value(evaluation, key)
+              if !compare_values(actual_value, expected_value)
+                has_error = true
+                errors += "      ✘ expectedEvaluations.flag.#{key}: expected #{expected_value} but received #{actual_value}\n"
+              end
+            end
+          end
+
+          if expected_evaluations[:variation]
+            evaluation = evaluate_from_instance(instance, :variation, feature_key, context, override_options)
+            expected_evaluations[:variation].each do |key, expected_value|
+              actual_value = get_evaluation_value(evaluation, key)
+              if !compare_values(actual_value, expected_value)
+                has_error = true
+                errors += "      ✘ expectedEvaluations.variation.#{key}: expected #{expected_value} but received #{actual_value}\n"
+              end
+            end
+          end
+
+          if expected_evaluations[:variables]
+            expected_evaluations[:variables].each do |variable_key, expected_eval|
+              if expected_eval.is_a?(Hash)
+                evaluation = evaluate_from_instance(
+                  instance,
+                  :variable,
+                  feature_key,
+                  context,
+                  override_options,
+                  variable_key
+                )
+                expected_eval.each do |key, expected_value|
+                  actual_value = get_evaluation_value(evaluation, key)
+                  if !compare_values(actual_value, expected_value)
+                    has_error = true
+                    errors += "      ✘ expectedEvaluations.variables.#{variable_key}.#{key}: expected #{expected_value} but received #{actual_value}\n"
+                  end
+                end
+              end
+            end
+          end
+        end
+
         duration = Time.now - start_time
 
         {
@@ -544,7 +660,7 @@ module FeaturevisorCLI
         }
 
         # Create SDK instance for segment testing
-        instance = Featurevisor.create_instance(
+        instance = Featurevisor.create_featurevisor(
           datafile: datafile,
           log_level: level
         )
@@ -614,13 +730,45 @@ module FeaturevisorCLI
       def create_override_options(assertion)
         options = {}
 
-        if assertion[:defaultVariationValue]
+        if assertion.key?(:defaultVariationValue)
           options[:default_variation_value] = assertion[:defaultVariationValue]
         end
 
         options
       end
 
+      def evaluate_from_instance(instance, type, feature_key, context, override_options, variable_key = nil)
+        method_name = :"evaluate_#{type}"
+
+        if instance.respond_to?(method_name)
+          if variable_key.nil?
+            return instance.send(method_name, feature_key, context, override_options)
+          end
+
+          return instance.send(method_name, feature_key, variable_key, context, override_options)
+        end
+
+        if instance.is_a?(Featurevisor::ChildInstance)
+          parent = instance.instance_variable_get(:@parent)
+          child_context = instance.instance_variable_get(:@context) || {}
+          child_sticky = instance.instance_variable_get(:@sticky)
+          combined_context = { **child_context, **context }
+
+          combined_options = {
+            __featurevisor_child_sticky: child_sticky,
+            **override_options
+          }
+
+          if variable_key.nil?
+            return parent.send(method_name, feature_key, combined_context, combined_options)
+          end
+
+          return parent.send(method_name, feature_key, variable_key, combined_context, combined_options)
+        end
+
+        {}
+      end
+
       def get_evaluation_value(evaluation, key)
         case key
         when :type
@@ -659,6 +807,8 @@ module FeaturevisorCLI
           evaluation[:variable_value]
         when :variableSchema
           evaluation[:variable_schema]
+        when :variableOverrideIndex
+          evaluation[:variable_override_index]
         else
           nil
         end

data/lib/featurevisor/child_instance.rb

@@ -3,8 +3,6 @@
 module Featurevisor
   # Child instance class for managing child contexts and sticky features
   class ChildInstance
-    attr_reader :parent, :context, :sticky, :emitter
-
     # Initialize a new child instance
     # @param options [Hash] Child instance options
     # @option options [Instance] :parent Parent instance
@@ -94,8 +92,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -113,8 +111,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -134,8 +132,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -155,8 +153,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -176,8 +174,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -197,8 +195,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -218,8 +216,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -239,8 +237,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -260,8 +258,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -281,8 +279,8 @@ module Featurevisor
           **context
         },
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end
@@ -300,8 +298,8 @@ module Featurevisor
         },
         feature_keys,
         {
-          sticky: @sticky,
-          **options
+          **options,
+          __featurevisor_child_sticky: @sticky
         }
       )
     end