featurevisor 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acf664663389bb7b3789a16f0e29c84aeb13e623f26bb38465e3bc8a8dcc984e
-  data.tar.gz: 0ab04bbea29092bcfd22361bda28ab6e36879b346d579b5a204780a3bbfb2eaa
+  metadata.gz: 2cc7d95c6c897b09f4092c105b73b9776c6e4b6d1851dad7c2108ea8cced6b2b
+  data.tar.gz: 9b06c4ac0e499345af18967d161ef102b5636edd82dbf2013e15ae790ad7e832
 SHA512:
-  metadata.gz: e123cd15ff03b6230ca26de9cdee003414b59f5b075a116b946f7b90562123980f083a4c670748d71cefcdcee0c96197e13fceb6d8a8b6bd841d0cd419167ba6
-  data.tar.gz: ef355cc9d0f2e6660510545c9f78ccefd031c71a9a52646d36ec28fe4bac1c5d38e18c8b6f2b1d9768f54f695fa7360c5e69e2d89ff9ba2cf0fa877d91a96a56
+  metadata.gz: b2df8d3afe705ea850e4a77458c17d8090f4bf3b0ec27da761ef3447f8952ba0e2f970d0b1f75962c0c3402f01a2c8fe10b341a694eda2d17d5e004730f3aa51
+  data.tar.gz: ebd5698bbd941fbd2778350e6b7602375912a8455f0bd6af8ecd3034ca56d97b23c5803089c57a3a956fb638062838e65adeb3d38126bf4e72f5468512a54634

data/README.md

@@ -454,7 +454,7 @@ load_datafile(f, "checkout")
 
 ### Updating datafile
 
-You can set the datafile as many times as you want in your application, which will result in emitting a [`datafile_set`](#datafile_set) event that you can listen and react to accordingly.
+You can set the datafile as many times as you want in your application, which will result in emitting a [`datafile_set`](#datafile-set) event that you can listen and react to accordingly.
 
 The triggers for setting the datafile again can be:
 
@@ -520,7 +520,7 @@ f = Featurevisor.create_featurevisor(
 
 Every diagnostic has `:level`, `:code`, `:message`, and an object-shaped `:details` hash. Optional `:module`, `:moduleName`, and `:originalError` fields describe provenance. Evaluation metadata belongs in `:details`.
 
-Diagnostic handlers are isolated from SDK behavior. An exception in a handler does not stop other handlers or evaluations.
+Diagnostic handlers are isolated from SDK behaviour. An exception in a handler does not stop other handlers or evaluations.
 
 
 ## Events
@@ -635,10 +635,12 @@ And optionally these properties depending on whether you are evaluating a featur
 
 ## Modules
 
-Modules allow you to intercept the evaluation process and customize SDK behavior.
+Modules allow you to intercept the evaluation process and customize SDK behaviour.
 
 For feature evaluations, all `before` callbacks run in registration order, followed by all `before_evaluation` callbacks. After evaluation and caller defaults, all `after_evaluation` callbacks run, followed by all `after` callbacks. Global variable evaluations use only `before_evaluation` and `after_evaluation`. Required feature checks run through the complete module pipeline, and transformed defaults are preserved.
 
+`before` and `after` remain available as deprecated feature-only compatibility callbacks. Use `before_evaluation` and `after_evaluation` for new modules so the same callbacks can handle feature and global variable evaluations.
+
 ### Defining a module
 
 A module is a simple hash with a unique recommended `name` and optional lifecycle functions:
@@ -663,8 +665,8 @@ my_custom_module = {
     })
   },
 
-  # before evaluation
-  before: ->(options) {
+  # before feature or global variable evaluation
+  before_evaluation: ->(options) {
     # update context before evaluation
     options[:context] = options[:context].merge({
       someAdditionalAttribute: 'value'
@@ -672,21 +674,15 @@ my_custom_module = {
     options
   },
 
-  # unified callback for feature and global variable evaluations
-  before_evaluation: ->(options) { options },
-
-  # after evaluation
-  after: ->(evaluation, options) {
+  # after feature or global variable evaluation
+  after_evaluation: ->(evaluation, options) {
     reason = evaluation[:reason]
     if reason == 'error'
       # log error
-      return
     end
+    evaluation
   },
 
-  # unified callback for feature and global variable evaluations
-  after_evaluation: ->(evaluation, options) { evaluation },
-
   # configure bucket key
   bucket_key: ->(options) {
     # return custom bucket key
@@ -822,7 +818,7 @@ $ bundle exec featurevisor test \
 
 The Ruby test runner builds base datafiles and Target datafiles in memory via `npx featurevisor build --json`. When an assertion contains `target`, it is evaluated against the matching Target datafile.
 
-All three commands accept repeatable `--target=<target>` options. `test` builds only the selected Target datafiles and runs untargeted assertions plus assertions for those targets. `benchmark` and `assess-distribution` run independently against every selected Target datafile. Without `--target`, existing project-wide behavior is preserved. Project definitions, test specs, Target discovery, and datafile generation continue to come from the Node.js CLI.
+All three commands accept repeatable `--target=<target>` options. `test` builds only the selected Target datafiles and runs untargeted assertions plus assertions for those targets. `benchmark` and `assess-distribution` run independently against every selected Target datafile. Without `--target`, existing project-wide behaviour is preserved. Project definitions, test specs, Target discovery, and datafile generation continue to come from the Node.js CLI.
 
 ### Test against local monorepo's example-1
 
@@ -950,7 +946,7 @@ The build produces `featurevisor-VERSION.gem` and `featurevisor-openfeature-VERS
 - Run `bundle install`
 - Push commit to `main` branch
 - Wait for CI to complete
-- Tag the release with the same version number, for example `v3.0.0`
+- Tag the release with the same version number, for example `v3.1.0`
 - The workflow verifies that the tag matches the shared version
 - The workflow publishes `featurevisor` first, followed by `featurevisor-openfeature`
 

data/bin/commands/test.rb

@@ -223,18 +223,13 @@ module FeaturevisorCLI
         environment = assertion.key?(:environment) ? assertion[:environment] : false
         environment = false if environment.nil?
 
-        target_key = assertion[:target] ? target_datafile_key(environment, assertion[:target]) : nil
-        base_key = base_datafile_key(environment)
+        return datafiles_by_key[target_datafile_key(environment, assertion[:target])] if assertion[:target]
 
-        if target_key && datafiles_by_key.key?(target_key)
-          return datafiles_by_key[target_key]
-        end
-
-        datafiles_by_key[base_key]
+        datafiles_by_key[base_datafile_key(environment)]
       end
 
       def create_tester_instance(datafile, level, assertion)
-        sticky = parse_sticky(assertion[:sticky])
+        sticky = parse_sticky(assertion[:stickyFeatures] || assertion[:sticky])
         sticky_variables = assertion[:stickyVariables].is_a?(Hash) ? assertion[:stickyVariables] : {}
 
         Featurevisor.create_featurevisor(
@@ -301,13 +296,26 @@ module FeaturevisorCLI
                     puts ""
                   end
 
-                  test_result = run_test_feature(assertion, test[:feature], instance, level)
+                  begin
+                    test_result = run_test_feature(assertion, test[:feature], instance, level)
+                  ensure
+                    instance.close
+                  end
                 end
               elsif test[:variable]
                 datafile = resolve_datafile_for_assertion(assertion, datafiles_by_key)
                 if datafile
+                  if @options.show_datafile
+                    puts ""
+                    puts JSON.pretty_generate(datafile)
+                    puts ""
+                  end
                   instance = create_tester_instance(datafile, level, assertion)
-                  test_result = run_test_variable(assertion, test[:variable], instance)
+                  begin
+                    test_result = run_test_variable(assertion, test[:variable], instance)
+                  ensure
+                    instance.close
+                  end
                 else
                   test_result = { has_error: true, errors: "      ✘ no datafile found for assertion target/environment combination\n", duration: 0 }
                 end
@@ -358,28 +366,61 @@ module FeaturevisorCLI
       end
 
       def run_test_variable(assertion, variable_key, instance)
-        context = parse_context(assertion[:context])
+        instance.set_context(parse_context(assertion[:context]), true)
         options = {}
         options[:default_variable_value] = assertion[:defaultVariableValue] if assertion.key?(:defaultVariableValue)
         started = Time.now
         errors = ""
 
-        if assertion.key?(:expectedValue)
-          actual = instance.get_variable(variable_key, context, options)
-          unless compare_values(actual, assertion[:expectedValue])
-            errors += "      ✘ expectedValue: expected #{assertion[:expectedValue].inspect} but received #{actual.inspect}\n"
+        errors += test_variable_expectation(assertion, variable_key, instance, options)
+
+        Array(assertion[:children]).each_with_index do |child_assertion, child_index|
+          child = instance.spawn(
+            parse_context(child_assertion[:context]),
+            sticky_features: parse_sticky(child_assertion[:stickyFeatures]),
+            sticky_variables: child_assertion[:stickyVariables].is_a?(Hash) ? child_assertion[:stickyVariables] : {}
+          )
+          begin
+            child_options = {}
+            if child_assertion.key?(:defaultVariableValue)
+              child_options[:default_variable_value] = child_assertion[:defaultVariableValue]
+            end
+            errors += test_variable_expectation(
+              child_assertion,
+              variable_key,
+              child,
+              child_options,
+              "children[#{child_index}]."
+            )
+          ensure
+            child.close
           end
         end
 
+        { has_error: !errors.empty?, errors: errors, duration: Time.now - started }
+      end
+
+      def test_variable_expectation(assertion, variable_key, evaluator, options, prefix = "")
+        evaluation = evaluator.evaluate_variable(variable_key, {}, options)
+        errors = ""
+        if assertion.key?(:expectedValue) && !compare_values(evaluation[:variable_value], assertion[:expectedValue])
+          errors += "      ✘ #{prefix}expectedValue: expected #{format_test_value(assertion[:expectedValue])} but received #{format_test_value(evaluation[:variable_value])}\n"
+        end
         if assertion[:expectedEvaluation].is_a?(Hash)
-          evaluation = instance.evaluate_variable(variable_key, context, options)
           assertion[:expectedEvaluation].each do |key, expected|
             actual = get_evaluation_value(evaluation, key)
-            errors += "      ✘ expectedEvaluation.#{key}: expected #{expected.inspect} but received #{actual.inspect}\n" unless compare_values(actual, expected)
+            unless compare_values(actual, expected)
+              errors += "      ✘ #{prefix}expectedEvaluation.#{key}: expected #{format_test_value(expected)} but received #{format_test_value(actual)}\n"
+            end
           end
         end
+        errors
+      end
 
-        { has_error: !errors.empty?, errors: errors, duration: Time.now - started }
+      def format_test_value(value)
+        JSON.generate(value)
+      rescue JSON::GeneratorError
+        value.inspect
       end
 
       def run_test_feature(assertion, feature_key, instance, level)
@@ -518,20 +559,16 @@ module FeaturevisorCLI
               child_context = parse_context(child[:context])
 
               # Create override options for child with sticky values
-              child_override_options = create_override_options(child)
-
-              # Pass sticky values to child instance
-              child_instance = instance.spawn(child_context, child_override_options)
-
-              # Set sticky values for child if they exist
-              # Create a local copy to ensure it's never nil
-              child_sticky = sticky || {}
-              if !child_sticky.empty?
-                child_instance.set_sticky_features(child_sticky, false)
+              child_instance = instance.spawn(
+                child_context,
+                sticky_features: sticky || {}
+              )
+              begin
+                child_result = run_test_feature_child(child, feature_key, child_instance, level)
+              ensure
+                child_instance.close
               end
 
-              child_result = run_test_feature_child(child, feature_key, child_instance, level)
-
               if child_result[:has_error]
                 has_error = true
                 errors += child_result[:errors]

data/lib/featurevisor/version.rb

@@ -1,3 +1,3 @@
 module Featurevisor
-  VERSION = "3.0.0"
+  VERSION = "3.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: featurevisor
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Fahad Heylaal