prefab-cloud-ruby 1.8.7 → 1.8.8

data/test/test_criteria_evaluator.rb

@@ -238,6 +238,131 @@ class TestCriteriaEvaluator < Minitest::Test
     assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { email: 'example@hotmail.com' })).unwrapped_value
   end
 
+  def test_prop_starts_with_one_of
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_STARTS_WITH_ONE_OF,
+                  value_to_match: string_list(['one', 'two']),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'three dogs' })).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: { testProperty: 'one tree' })).unwrapped_value
+  end
+
+  def test_prop_does_not_start_with_one_of
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_DOES_NOT_START_WITH_ONE_OF,
+                  value_to_match: string_list(['one', 'two']),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: { testProperty: 'three dogs' })).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'one tree' })).unwrapped_value
+  end
+
+
+  def test_prop_contains_one_of
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_CONTAINS_ONE_OF,
+                  value_to_match: string_list(['one', 'two']),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'three dogs' })).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: { testProperty: 'see one tree' })).unwrapped_value
+  end
+
+  def test_prop_does_not_contain_one_of
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_DOES_NOT_CONTAIN_ONE_OF,
+                  value_to_match: string_list(['one', 'two']),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: { testProperty: 'three dogs' })).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'see one tree' })).unwrapped_value
+  end
+
   def test_in_seg
     segment_key = 'segment_key'
 
@@ -683,6 +808,266 @@ class TestCriteriaEvaluator < Minitest::Test
     assert_equal 'ghi', evaluator.evaluate(context).unwrapped_value
   end
 
+  def test_prop_regex_matches
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_MATCHES,
+                  value_to_match: PrefabProto::ConfigValue.new(string: "a+b+"),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'abc' })).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: { testProperty: 'aabb' })).unwrapped_value
+  end
+
+  def test_prop_regex_does_not_match
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_DOES_NOT_MATCH,
+                  value_to_match: PrefabProto::ConfigValue.new(string: "a+b+"),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: { testProperty: 'abc' })).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'aabb' })).unwrapped_value
+  end
+
+  def test_prop_regex_does_not_match_returns_false_bad_regex
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_DOES_NOT_MATCH,
+                  value_to_match: PrefabProto::ConfigValue.new(string: "[a+b+"),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'abc' })).unwrapped_value
+
+    assert_stderr [ "warning: character class has duplicated range: /^[a+b+$/" ]
+  end
+
+
+  def test_prop_regex_match_returns_false_bad_regex
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_MATCHES,
+                  value_to_match: PrefabProto::ConfigValue.new(string: "[a+b+"),
+                  property_name: 'user.testProperty'
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: { testProperty: 'abc' })).unwrapped_value
+
+    assert_stderr [ "warning: character class has duplicated range: /^[a+b+$/" ]
+  end
+
+  def test_less_than_works
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_LESS_THAN, property_name: 'user.age', value_to_match: 10)
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 10})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 9})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 9.5})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 10.1})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "9"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "9.2"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "not a number"})).unwrapped_value
+  end
+
+  def test_less_or_equal_to_works
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_LESS_THAN_OR_EQUAL, property_name: 'user.age', value_to_match: 10)
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 10})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 9})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 9.5})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 10.1})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "9"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "not a number"})).unwrapped_value
+  end
+
+
+  def test_greater_than_works
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_GREATER_THAN, property_name: 'user.age', value_to_match: 10)
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 10})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 9})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 9.5})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 10.1})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 12})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "19"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "not a number"})).unwrapped_value
+  end
+
+  def test_greater_than_or_equal_to_works
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_GREATER_THAN_OR_EQUAL, property_name: 'user.age', value_to_match: 10)
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 10})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 9})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: 9.5})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 10.1})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user: {age: 12})).unwrapped_value
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "19"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user: {age: "not a number"})).unwrapped_value
+  end
+
+  def test_date_before_works
+    date = "2024-12-01T00:00:00Z"
+    millis = Time.iso8601(date).utc.to_i * 1000
+    config_with_string = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_BEFORE, property_name: 'user.joinDate', value_to_match: date)
+    evaluator_with_string_config = Prefab::CriteriaEvaluator.new(config_with_string, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                              namespace: nil)
+    config_with_millis = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_BEFORE, property_name: 'user.joinDate', value_to_match: millis)
+    evaluator_with_millis_config = Prefab::CriteriaEvaluator.new(config_with_millis, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                                                 namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator_with_millis_config.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: millis-10000})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: "2024-11-01T00:00:00Z"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: millis+10000})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: "2024-12-02T00:00:00Z"})).unwrapped_value
+
+    assert_equal DEFAULT_VALUE, evaluator_with_string_config.evaluate(context({})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: millis-10000})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: "2024-11-01T00:00:00Z"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: millis+10000})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: "2024-12-02T00:00:00Z"})).unwrapped_value
+  end
+
+  def test_date_after_works
+    date = "2024-12-01T00:00:00Z"
+    millis = Time.iso8601(date).utc.to_i * 1000
+    config_with_string = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_AFTER, property_name: 'user.joinDate', value_to_match: date)
+    evaluator_with_string_config = Prefab::CriteriaEvaluator.new(config_with_string, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                                                 namespace: nil)
+    config_with_millis = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_AFTER, property_name: 'user.joinDate', value_to_match: millis)
+    evaluator_with_millis_config = Prefab::CriteriaEvaluator.new(config_with_millis, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client,
+                                                                 namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator_with_millis_config.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: millis-10000})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: "2024-11-01T00:00:00Z"})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: millis+10000})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_millis_config.evaluate(context(user: {joinDate: "2024-12-02T00:00:00Z"})).unwrapped_value
+
+    assert_equal DEFAULT_VALUE, evaluator_with_string_config.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: millis-10000})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: "2024-11-01T00:00:00Z"})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: millis+10000})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator_with_string_config.evaluate(context(user: {joinDate: "2024-12-02T00:00:00Z"})).unwrapped_value
+  end
+
+  def test_semver_less_than
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_SEMVER_LESS_THAN, property_name: 'user.version', value_to_match: "2.0.0")
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client, namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "nonsense"})).unwrapped_value
+
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user:{version: "1.0.0"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "2.0.0"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "3.0.0"})).unwrapped_value
+  end
+
+  def test_semver_equal_to
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_SEMVER_EQUAL, property_name: 'user.version', value_to_match: "2.0.0")
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client, namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "nonsense"})).unwrapped_value
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "1.0.0"})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user:{version: "2.0.0"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "3.0.0"})).unwrapped_value
+  end
+
+  def test_semver_greater_than
+    config = create_prefab_config(operator: PrefabProto::Criterion::CriterionOperator::PROP_SEMVER_GREATER_THAN, property_name: 'user.version', value_to_match: "2.0.0")
+    evaluator = Prefab::CriteriaEvaluator.new(config, project_env_id: PROJECT_ENV_ID, resolver: nil, base_client: @base_client, namespace: nil)
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context({})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "nonsense"})).unwrapped_value
+
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "1.0.0"})).unwrapped_value
+    assert_equal DEFAULT_VALUE, evaluator.evaluate(context(user:{version: "2.0.0"})).unwrapped_value
+    assert_equal DESIRED_VALUE, evaluator.evaluate(context(user:{version: "3.0.0"})).unwrapped_value
+  end
+
   private
 
   def string_list(values)
@@ -719,4 +1104,55 @@ class TestCriteriaEvaluator < Minitest::Test
       'fake-base-client-instance_hash'
     end
   end
+
+
+  def create_prefab_config(
+    key: KEY,
+    project_env_id: PROJECT_ENV_ID,
+    operator:,
+    value_to_match:,
+    property_name:,
+    desired_value_config: DESIRED_VALUE_CONFIG
+  )
+    PrefabProto::Config.new(
+      key: key,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: project_env_id,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: operator,
+                  value_to_match: build_config_value(value_to_match),
+                  property_name: property_name
+                )
+              ],
+              value: desired_value_config
+            )
+          ]
+        )
+      ]
+    )
+  end
+
+  def build_config_value(value)
+    case value
+    when Integer
+      PrefabProto::ConfigValue.new(int: value)
+    when Float
+      PrefabProto::ConfigValue.new(double: value)
+    when String
+      PrefabProto::ConfigValue.new(string: value)
+    when Array
+      if value.all? { |v| v.is_a?(String) }
+        PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: value))
+      else
+        raise ArgumentError, "Unsupported array type: Only arrays of strings are supported."
+      end
+    else
+      raise ArgumentError, "Unsupported value type: #{value.class}"
+    end
+  end
 end

data/test/test_fixed_size_hash.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'test_helper'
+
+module Prefab
+  class FixedSizeHashTest < Minitest::Test
+    def setup
+      @max_size = 3
+      @hash = FixedSizeHash.new(@max_size)
+    end
+
+    def test_acts_like_a_regular_hash_when_under_max_size
+      @hash[:a] = 1
+      @hash[:b] = 2
+
+      assert_equal 1, @hash[:a]
+      assert_equal 2, @hash[:b]
+      assert_equal 2, @hash.size
+    end
+
+    def test_enforces_max_size_by_evicting_first_added_item
+      @hash[:a] = 1
+      @hash[:b] = 2
+      @hash[:c] = 3
+      assert_equal @max_size, @hash.size
+
+      @hash[:d] = 4
+      assert_equal @max_size, @hash.size
+      assert_nil @hash[:a]  # First item should be evicted
+      assert_equal 4, @hash[:d]
+    end
+
+    def test_updating_existing_key_does_not_trigger_eviction
+      @hash[:a] = 1
+      @hash[:b] = 2
+      @hash[:c] = 3
+
+      @hash[:b] = 'new value'  # Update existing key
+
+      assert_equal @max_size, @hash.size
+      assert_equal 1, @hash[:a]  # First item should still be present
+      assert_equal 'new value', @hash[:b]
+      assert_equal 3, @hash[:c]
+    end
+
+    def test_handles_nil_values
+      @hash[:a] = nil
+      @hash[:b] = 2
+      @hash[:c] = 3
+      @hash[:d] = 4
+
+      assert_nil @hash[:a]  # First item should be evicted
+      assert_equal 4, @hash[:d]
+    end
+
+    def test_preserves_hash_methods
+      @hash[:a] = 1
+      @hash[:b] = 2
+
+      assert_equal [:a, :b], @hash.keys
+      assert_equal [1, 2], @hash.values
+      assert @hash.key?(:a)
+      refute @hash.key?(:z)
+    end
+
+    def test_handles_string_keys
+      @hash['a'] = 1
+      @hash['b'] = 2
+      @hash['c'] = 3
+      @hash['d'] = 4
+
+      assert_nil @hash['a']  # First item should be evicted
+      assert_equal 4, @hash['d']
+    end
+
+    def test_handles_object_keys
+      key1 = Object.new
+      key2 = Object.new
+      key3 = Object.new
+      key4 = Object.new
+
+      @hash[key1] = 1
+      @hash[key2] = 2
+      @hash[key3] = 3
+      @hash[key4] = 4
+
+      assert_nil @hash[key1]  # First item should be evicted
+      assert_equal 4, @hash[key4]
+    end
+
+    def test_can_be_initialized_empty
+      assert_equal 0, @hash.size
+    end
+
+    def test_enumerable_methods
+      @hash[:a] = 1
+      @hash[:b] = 2
+
+      mapped = @hash.map { |k, v| [k, v * 2] }.to_h
+      assert_equal({ a: 2, b: 4 }, mapped)
+
+      filtered = @hash.select { |_, v| v > 1 }
+      assert_equal({ b: 2 }, filtered.to_h)
+    end
+
+    def test_clear_maintains_max_size_constraint
+      @hash[:a] = 1
+      @hash[:b] = 2
+      @hash.clear
+
+      assert_equal 0, @hash.size
+
+      # Should still enforce max size after clear
+      (@max_size + 1).times { |i| @hash[i] = i }
+      assert_equal @max_size, @hash.size
+    end
+  end
+end

data/test/test_semver.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+class TestSemanticVersion < Minitest::Test
+  def test_parse_valid_version
+    version = SemanticVersion.parse('1.2.3')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_nil version.prerelease
+    assert_nil version.build_metadata
+  end
+
+  def test_parse_version_with_prerelease
+    version = SemanticVersion.parse('1.2.3-alpha.1')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_equal 'alpha.1', version.prerelease
+    assert_nil version.build_metadata
+  end
+
+  def test_parse_version_with_build_metadata
+    version = SemanticVersion.parse('1.2.3+build.123')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_nil version.prerelease
+    assert_equal 'build.123', version.build_metadata
+  end
+
+  def test_parse_full_version
+    version = SemanticVersion.parse('1.2.3-alpha.1+build.123')
+    assert_equal 1, version.major
+    assert_equal 2, version.minor
+    assert_equal 3, version.patch
+    assert_equal 'alpha.1', version.prerelease
+    assert_equal 'build.123', version.build_metadata
+  end
+
+  def test_parse_invalid_version
+    assert_raises(ArgumentError) { SemanticVersion.parse('invalid') }
+    assert_raises(ArgumentError) { SemanticVersion.parse('1.2') }
+    assert_raises(ArgumentError) { SemanticVersion.parse('1.2.3.4') }
+    assert_raises(ArgumentError) { SemanticVersion.parse('') }
+  end
+
+  def test_parse_quietly
+    assert_nil SemanticVersion.parse_quietly('invalid')
+    refute_nil SemanticVersion.parse_quietly('1.2.3')
+  end
+
+  def test_to_string
+    assert_equal '1.2.3', SemanticVersion.parse('1.2.3').to_s
+    assert_equal '1.2.3-alpha.1', SemanticVersion.parse('1.2.3-alpha.1').to_s
+    assert_equal '1.2.3+build.123', SemanticVersion.parse('1.2.3+build.123').to_s
+    assert_equal '1.2.3-alpha.1+build.123', SemanticVersion.parse('1.2.3-alpha.1+build.123').to_s
+  end
+
+  def test_equality
+    v1 = SemanticVersion.parse('1.2.3')
+    v2 = SemanticVersion.parse('1.2.3')
+    v3 = SemanticVersion.parse('1.2.4')
+    v4 = SemanticVersion.parse('1.2.3-alpha')
+    v5 = SemanticVersion.parse('1.2.3+build.123')
+
+    assert_equal v1, v2
+    refute_equal v1, v3
+    refute_equal v1, v4
+    assert_equal v1, v5  # build metadata is ignored in equality
+  end
+
+  def test_comparison
+    versions = [
+      '1.0.0-alpha',
+      '1.0.0-alpha.1',
+      '1.0.0-beta.2',
+      '1.0.0-beta.11',
+      '1.0.0-rc.1',
+      '1.0.0',
+      '2.0.0',
+      '2.1.0',
+      '2.1.1'
+    ].map { |v| SemanticVersion.parse(v) }
+
+    # Test that each version is less than the next version
+    (versions.length - 1).times do |i|
+      assert versions[i] < versions[i + 1], "Expected #{versions[i]} < #{versions[i + 1]}"
+    end
+  end
+
+  def test_prerelease_comparison
+    # Test specific prerelease comparison cases
+    cases = [
+      ['1.0.0-alpha', '1.0.0-alpha.1', -1],
+      ['1.0.0-alpha.1', '1.0.0-alpha.beta', -1],
+      ['1.0.0-alpha.beta', '1.0.0-beta', -1],
+      ['1.0.0-beta', '1.0.0-beta.2', -1],
+      ['1.0.0-beta.2', '1.0.0-beta.11', -1],
+      ['1.0.0-beta.11', '1.0.0-rc.1', -1],
+      ['1.0.0-rc.1', '1.0.0', -1]
+    ]
+
+    cases.each do |v1_str, v2_str, expected|
+      v1 = SemanticVersion.parse(v1_str)
+      v2 = SemanticVersion.parse(v2_str)
+      assert_equal expected, (v1 <=> v2), "Expected #{v1} <=> #{v2} to be #{expected}"
+    end
+  end
+end

data/test/test_sse_config_client.rb

@@ -2,6 +2,7 @@
 
 require 'test_helper'
 require 'webrick'
+require 'ostruct'
 
 class TestSSEConfigClient < Minitest::Test
   def test_client