prefab-cloud-ruby 1.8.8.pre.1 → 1.8.9

data/test/support/common_helpers.rb

@@ -11,7 +11,6 @@ module CommonHelpers
     Prefab::Context.default_context.clear
     SemanticLogger.add_appender(io: $logs, filter: Prefab.log_filter)
     SemanticLogger.sync!
-    Timecop.freeze('2023-08-09 15:18:12 -0400')
   end
 
   def teardown
@@ -26,14 +25,19 @@ module CommonHelpers
       end
     end
 
-    if $stderr != $oldstderr && !$stderr.string.empty?
+    #note this skips the output check in environments like rubymine that hijack the output. Alternative is a method missing error on string
+
+    if $stderr != $oldstderr && $stderr.respond_to?(:string) && !$stderr.string.empty?
       # we ignore 2.X because of the number of `instance variable @xyz not initialized` warnings
       if !RUBY_VERSION.start_with?('2.')
         raise "Unexpected stderr. Handle stderr with assert_stderr\n\n#{$stderr.string}"
       end
     end
 
-    $stderr = $oldstderr
+    # Only restore stderr if we have a valid oldstderr
+    if $oldstderr
+      $stderr = $oldstderr
+    end
 
     Timecop.return
   end
@@ -174,18 +178,18 @@ module CommonHelpers
   end
 
   def assert_stderr(expected)
-    assert ($stderr.string.split("\n").uniq & expected).size > 0
-
-    # Ruby 2.X has a lot of warnings about instance variables not being
-    # initialized so we don't try to assert on stderr for those versions.
-    # Instead we just stop after asserting that our expected errors are
-    # included in the output.
-    if RUBY_VERSION.start_with?('2.')
-      puts $stderr.string
-      return
+    skip "Cannot verify stderr in current environment" unless $stderr.respond_to?(:string)
+    $stderr.string.split("\n").uniq.each do |line|
+      matched = false
+
+      expected.reject! do |expectation|
+        matched = true if line.include?(expectation)
+      end
+
+      assert(matched, "expectation: #{expected}, got: #{line}")
     end
 
-    assert_equal expected.uniq, $stderr.string.split("\n").uniq
+    assert expected.empty?, "Expected stderr to include: #{expected}, but it did not"
 
     # restore since we've handled it
     $stderr = $oldstderr

data/test/test_caching_http_connection.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Prefab
+  class CachingHttpConnectionTest < Minitest::Test
+    def setup
+      @uri = 'https://api.example.com'
+      @api_key = 'test-key'
+      @path = '/some/path'
+
+      # Reset the cache before each test
+      CachingHttpConnection.reset_cache!
+
+      # Setup the mock HTTP connection
+      @http_connection = Minitest::Mock.new
+      @http_connection.expect(:uri, @uri)
+
+      # Stub the HttpConnection constructor
+      HttpConnection.stub :new, @http_connection do
+        @subject = CachingHttpConnection.new(@uri, @api_key)
+      end
+    end
+
+    def test_caches_responses_with_etag_and_max_age
+      response_body = 'response data'
+      response = Faraday::Response.new(
+        status: 200,
+        body: response_body,
+        response_headers: {
+          'ETag' => 'abc123',
+          'Cache-Control' => 'max-age=60'
+        }
+      )
+
+      # Expect two calls to uri (one for each request) and one call to get
+      @http_connection.expect(:uri, @uri)
+      @http_connection.expect(:get, response, [@path])
+
+      HttpConnection.stub :new, @http_connection do
+        # First request should miss cache
+        first_response = @subject.get(@path)
+        assert_equal response_body, first_response.body
+        assert_equal 'MISS', first_response.headers['X-Cache']
+
+        # Second request should hit cache
+        second_response = @subject.get(@path)
+        assert_equal response_body, second_response.body
+        assert_equal 'HIT', second_response.headers['X-Cache']
+      end
+
+      @http_connection.verify
+    end
+
+    def test_respects_max_age_directive
+      response = Faraday::Response.new(
+        status: 200,
+        body: 'fresh data',
+        response_headers: {
+          'ETag' => 'abc123',
+          'Cache-Control' => 'max-age=60'
+        }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+
+      # First request
+      mock.expect(:get, response, [@path])
+      # After max-age expires, new request with etag
+      mock.expect(:get, response, [@path, { 'If-None-Match' => 'abc123' }])
+
+      Timecop.freeze do
+        subject = CachingHttpConnection.new(@uri, @api_key)
+        subject.instance_variable_set('@connection', mock)
+
+        # Initial request
+        subject.get(@path)
+
+        # Within max-age window
+        Timecop.travel(59)
+        cached_response = subject.get(@path)
+        assert_equal 'HIT', cached_response.headers['X-Cache']
+
+        # After max-age window
+        Timecop.travel(61)
+        new_response = subject.get(@path)
+        assert_equal 'MISS', new_response.headers['X-Cache']
+      end
+
+      mock.verify
+    end
+    def test_handles_304_not_modified
+      initial_response = Faraday::Response.new(
+        status: 200,
+        body: 'cached data',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      not_modified_response = Faraday::Response.new(
+        status: 304,
+        body: '',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+
+      # First request with single arg
+      mock.expect(:get, initial_response, [@path])
+
+      # Second request with both path and headers
+      mock.expect(:get, not_modified_response, [@path, { 'If-None-Match' => 'abc123' }])
+
+      subject = CachingHttpConnection.new(@uri, @api_key)
+      subject.instance_variable_set('@connection', mock)
+
+      # Initial request to populate cache
+      first_response = subject.get(@path)
+      assert_equal 'cached data', first_response.body
+      assert_equal 'MISS', first_response.headers['X-Cache']
+
+      # Subsequent request gets 304
+      cached_response = subject.get(@path)
+      assert_equal 'cached data', cached_response.body
+      assert_equal 200, cached_response.status
+      assert_equal 'HIT', cached_response.headers['X-Cache']
+
+      mock.verify
+    end
+
+    def test_does_not_cache_no_store_responses
+      response = Faraday::Response.new(
+        status: 200,
+        body: 'uncacheable data',
+        response_headers: { 'Cache-Control' => 'no-store' }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+      # Both gets with single arg
+      mock.expect(:get, response, [@path])
+      mock.expect(:get, response, [@path])
+
+      subject = CachingHttpConnection.new(@uri, @api_key)
+      subject.instance_variable_set('@connection', mock)
+
+      2.times do
+        result = subject.get(@path)
+        assert_equal 'MISS', result.headers['X-Cache']
+      end
+
+      mock.verify
+    end
+    def test_cache_is_shared_across_instances
+      HttpConnection.stub :new, @http_connection do
+        instance1 = CachingHttpConnection.new(@uri, @api_key)
+        instance2 = CachingHttpConnection.new(@uri, @api_key)
+
+        assert_same instance1.class.cache, instance2.class.cache
+      end
+    end
+
+    def test_cache_can_be_reset
+      old_cache = CachingHttpConnection.cache
+      CachingHttpConnection.reset_cache!
+      refute_same CachingHttpConnection.cache, old_cache
+    end
+
+    def test_adds_if_none_match_header_when_cached
+      # First response to be cached
+      initial_response = Faraday::Response.new(
+        status: 200,
+        body: 'cached data',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      # Second request should have If-None-Match header
+      not_modified_response = Faraday::Response.new(
+        status: 304,
+        body: '',
+        response_headers: { 'ETag' => 'abc123' }
+      )
+
+      mock = Minitest::Mock.new
+      def mock.uri
+        'https://api.example.com'
+      end
+
+      # First request should not have If-None-Match
+      mock.expect(:get, initial_response, [@path])
+
+      # Second request should have If-None-Match header
+      mock.expect(:get, not_modified_response, [@path, { 'If-None-Match' => 'abc123' }])
+
+      subject = CachingHttpConnection.new(@uri, @api_key)
+      subject.instance_variable_set('@connection', mock)
+
+      # Initial request to populate cache
+      first_response = subject.get(@path)
+      assert_equal 'cached data', first_response.body
+      assert_equal 'MISS', first_response.headers['X-Cache']
+
+      # Second request should use If-None-Match
+      cached_response = subject.get(@path)
+      assert_equal 'cached data', cached_response.body
+      assert_equal 'HIT', cached_response.headers['X-Cache']
+
+      mock.verify
+    end
+  end
+end

data/test/test_context.rb

@@ -141,14 +141,6 @@ class TestContext < Minitest::Test
             "id" => PrefabProto::ConfigValue.new(int: 2),
             "name" => PrefabProto::ConfigValue.new(string: "team-name")
           }
-        ),
-
-        PrefabProto::Context.new(
-          type: "prefab",
-          values: {
-            'current-time' => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
-            'namespace' => PrefabProto::ConfigValue.new(string: namespace)
-          }
         )
       ]
     ), contexts.to_proto(namespace)
@@ -226,13 +218,6 @@ class TestContext < Minitest::Test
             "name" => PrefabProto::ConfigValue.new(string: "team-name")
           }
         ),
-        # via to_proto
-        PrefabProto::Context.new(
-          type: "prefab",
-          values: {
-            'current-time' => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
-          }
-        )
       ]
     )
 

data/test/test_context_shape.rb

@@ -36,7 +36,7 @@ class TestContextShape < Minitest::Test
 
   # If this test fails, it means that we've added a new type to the ConfigValue
   def test_mapping_is_exhaustive
-    unsupported = [:bytes, :limit_definition, :log_level, :weighted_values, :int_range, :provided, :duration, :json]
+    unsupported = [:bytes, :limit_definition, :log_level, :weighted_values, :int_range, :provided, :duration, :json, :schema]
     type_fields = PrefabProto::ConfigValue.descriptor.lookup_oneof("type").entries
     supported = type_fields.entries.reject do |entry|
       unsupported.include?(entry.name.to_sym)

data/test/test_criteria_evaluator.rb

@@ -808,6 +808,288 @@ 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
+
+  def test_date_before_with_current_time
+    future_time = Time.now.utc + 3600 # 1 hour in the future
+    config = create_prefab_config(
+      operator: PrefabProto::Criterion::CriterionOperator::PROP_BEFORE,
+      property_name: 'prefab.current-time',
+      value_to_match: future_time.iso8601
+    )
+    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
+  end
+
+  def test_date_after_with_current_time
+    past_time = Time.now.utc - 3600 # 1 hour in the past
+    config = create_prefab_config(
+      operator: PrefabProto::Criterion::CriterionOperator::PROP_AFTER,
+      property_name: 'prefab.current-time',
+      value_to_match: past_time.iso8601
+    )
+    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
+  end
+
   private
 
   def string_list(values)
@@ -844,4 +1126,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