updates

Author: fahad19

README.md

@@ -41,7 +41,7 @@ This SDK is compatible with [Featurevisor](https://featurevisor.com/) v2.0 proje
 - [Close](#close)
 - [CLI usage](#cli-usage)
   - [Test](#test)
-  - [Test against example-1](#test-against-example-1)
+  - [Test against local monorepo's example-1](#test-against-local-monorepos-example-1)
   - [Benchmark](#benchmark)
   - [Assess distribution](#assess-distribution)
 - [Development](#development)
@@ -694,14 +694,17 @@ $ bundle exec featurevisor test \
 
 `--with-scopes` and `--with-tags` make the Ruby test runner build scoped/tagged datafiles in memory (via `npx featurevisor build --json`) and evaluate matching assertions against those exact datafiles.
 
+If an assertion references `scope` and `--with-scopes` is not provided, the runner still evaluates the assertion by merging that scope's configured context into the assertion context (without building scoped datafiles).
+
 For compatibility, camelCase aliases are also supported: `--withScopes` and `--withTags`.
 
-### Test against example-1
+### Test against local monorepo's example-1
 
 ```bash
 $ cd /absolute/path/to/featurevisor-ruby
-$ bundle exec featurevisor test --projectDirectoryPath=/path/to/featurevisor/project
-$ bundle exec featurevisor test --projectDirectoryPath=/path/to/featurevisor/project --with-scopes
+$ bundle exec featurevisor test --projectDirectoryPath=./monorepo/examples/example-1
+$ bundle exec featurevisor test --projectDirectoryPath=./monorepo/examples/example-1 --with-scopes
+$ bundle exec featurevisor test --projectDirectoryPath=./monorepo/examples/example-1 --with-tags
 ```
 
 ### Benchmark

bin/commands/test.rb

@@ -300,25 +300,26 @@ def run_tests(tests, datafiles_by_key, segments_by_key, level, config)
                     errors: "      ✘ no datafile found for assertion scope/tag/environment combination\n",
                     duration: 0
                   }
-                  next
                 end
 
-                instance = create_tester_instance(datafile, level, assertion)
-                scope_context = {}
+                if datafile
+                  instance = create_tester_instance(datafile, level, assertion)
+                  scope_context = {}
 
-                if assertion[:scope] && !@options.with_scopes
-                  # If not using scoped datafiles, mimic JS behavior by merging scope context.
-                  scope_context = get_scope_context(config, assertion[:scope])
-                end
+                  if assertion[:scope] && !@options.with_scopes
+                    # If not using scoped datafiles, mimic JS behavior by merging scope context.
+                    scope_context = get_scope_context(config, assertion[:scope])
+                  end
 
-                # Show datafile if requested
-                if @options.show_datafile
-                  puts ""
-                  puts JSON.pretty_generate(datafile)
-                  puts ""
-                end
+                  # 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, scope_context)
+                  test_result = run_test_feature(assertion, test[:feature], instance, level, scope_context)
+                end
               elsif test[:segment]
                 segment_key = test[:segment]
                 segment = segments_by_key[segment_key]
@@ -608,6 +609,55 @@ def run_test_feature_child(assertion, feature_key, instance, level)
           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
 
         {
@@ -707,6 +757,40 @@ def create_override_options(assertion)
         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.respond_to?(:parent) && instance.respond_to?(:sticky)
+          parent = instance.parent
+          combined_context = if instance.respond_to?(:context)
+            { **(instance.context || {}), **context }
+          else
+            context
+          end
+
+          combined_options = {
+            sticky: instance.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

lib/featurevisor/evaluate.rb

@@ -386,8 +386,8 @@ def self.evaluate(options)
 
               required_variation_value = nil
 
-              if required_variation_evaluation[:variation_value]
-                required_variation_value = required_variation_evaluation[:variation_value]
+              if has_key?(required_variation_evaluation, :variation_value)
+                required_variation_value = fetch_with_symbol_key(required_variation_evaluation, :variation_value)
               elsif required_variation_evaluation[:variation]
                 required_variation_value = required_variation_evaluation[:variation][:value]
               end

spec/evaluate_spec.rb

@@ -319,6 +319,92 @@
       expect(result[:required]).to eq(["required-feature"])
     end
 
+    it "should treat required variation value false as a valid match" do
+      feature = {
+        key: "test-feature",
+        required: [{ key: "required-feature", variation: false }]
+      }
+
+      allow(datafile_reader).to receive(:get_feature).and_return(feature)
+      allow(datafile_reader).to receive(:get_matched_force).and_return({
+        force: nil,
+        forceIndex: nil
+      })
+      allow(datafile_reader).to receive(:get_matched_traffic).and_return(nil)
+      allow(Featurevisor::Bucketer).to receive(:get_bucket_key).and_return("test.123")
+      allow(Featurevisor::Bucketer).to receive(:get_bucketed_number).and_return(50)
+
+      allow(Featurevisor::Evaluate).to receive(:evaluate).and_call_original
+      allow(Featurevisor::Evaluate).to receive(:evaluate).with(
+        hash_including(type: "flag", feature_key: "required-feature")
+      ).and_return({
+        type: "flag",
+        feature_key: "required-feature",
+        enabled: true
+      })
+      allow(Featurevisor::Evaluate).to receive(:evaluate).with(
+        hash_including(type: "variation", feature_key: "required-feature")
+      ).and_return({
+        type: "variation",
+        feature_key: "required-feature",
+        variation_value: false
+      })
+
+      result = Featurevisor::Evaluate.evaluate(
+        type: "flag",
+        feature_key: feature,
+        context: {},
+        logger: logger,
+        hooks_manager: hooks_manager,
+        datafile_reader: datafile_reader
+      )
+
+      expect(result[:reason]).not_to eq(Featurevisor::EvaluationReason::REQUIRED)
+    end
+
+    it "should treat required variation value 0 as a valid match" do
+      feature = {
+        key: "test-feature",
+        required: [{ key: "required-feature", variation: 0 }]
+      }
+
+      allow(datafile_reader).to receive(:get_feature).and_return(feature)
+      allow(datafile_reader).to receive(:get_matched_force).and_return({
+        force: nil,
+        forceIndex: nil
+      })
+      allow(datafile_reader).to receive(:get_matched_traffic).and_return(nil)
+      allow(Featurevisor::Bucketer).to receive(:get_bucket_key).and_return("test.123")
+      allow(Featurevisor::Bucketer).to receive(:get_bucketed_number).and_return(50)
+
+      allow(Featurevisor::Evaluate).to receive(:evaluate).and_call_original
+      allow(Featurevisor::Evaluate).to receive(:evaluate).with(
+        hash_including(type: "flag", feature_key: "required-feature")
+      ).and_return({
+        type: "flag",
+        feature_key: "required-feature",
+        enabled: true
+      })
+      allow(Featurevisor::Evaluate).to receive(:evaluate).with(
+        hash_including(type: "variation", feature_key: "required-feature")
+      ).and_return({
+        type: "variation",
+        feature_key: "required-feature",
+        variation_value: 0
+      })
+
+      result = Featurevisor::Evaluate.evaluate(
+        type: "flag",
+        feature_key: feature,
+        context: {},
+        logger: logger,
+        hooks_manager: hooks_manager,
+        datafile_reader: datafile_reader
+      )
+
+      expect(result[:reason]).not_to eq(Featurevisor::EvaluationReason::REQUIRED)
+    end
+
     it "should handle errors gracefully" do
       options = {
         type: "flag",

spec/test_command_spec.rb

@@ -1,4 +1,5 @@
 require "featurevisor"
+require "stringio"
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "bin"))
 require "cli"
@@ -79,4 +80,65 @@
       expect(datafile[:schemaVersion]).to eq("2")
     end
   end
+
+  describe "test execution behavior" do
+    it "evaluates expectedEvaluations in child assertions" do
+      command = described_class.new(options)
+      instance = double("child-instance")
+
+      allow(instance).to receive(:is_enabled).and_return(true)
+      allow(instance).to receive(:get_variation).and_return("control")
+      allow(instance).to receive(:get_variable).and_return("v")
+      allow(instance).to receive(:evaluate_flag).and_return({ type: "flag", enabled: false })
+      allow(instance).to receive(:evaluate_variation).and_return({ type: "variation", variation_value: "control" })
+      allow(instance).to receive(:evaluate_variable).and_return({ type: "variable", variable_key: "k", variable_value: "v" })
+
+      assertion = {
+        expectedEvaluations: {
+          flag: {
+            enabled: true
+          }
+        }
+      }
+
+      result = command.send(:run_test_feature_child, assertion, "myFeature", instance, "warn")
+      expect(result[:has_error]).to be true
+      expect(result[:errors]).to include("expectedEvaluations.flag.enabled")
+    end
+
+    it "counts missing-datafile assertion as failed" do
+      command = described_class.new(options)
+
+      allow(command).to receive(:exit).and_raise(SystemExit.new(1))
+
+      tests = [
+        {
+          key: "features/missing.spec",
+          feature: "foo",
+          assertions: [
+            {
+              description: "missing datafile assertion",
+              environment: "production",
+              scope: "browsers"
+            }
+          ]
+        }
+      ]
+
+      output = StringIO.new
+      original_stdout = $stdout
+      $stdout = output
+      begin
+        expect do
+          command.send(:run_tests, tests, {}, {}, "warn", { scopes: [] })
+        end.to raise_error(SystemExit)
+      ensure
+        $stdout = original_stdout
+      end
+
+      expect(output.string).to include("no datafile found for assertion scope/tag/environment combination")
+      expect(output.string).to include("Test specs: 0 passed, 1 failed")
+      expect(output.string).to include("Assertions: 0 passed, 1 failed")
+    end
+  end
 end