sdk-reforge 1.9.0

data/test/test_internal_logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestInternalLogger < Minitest::Test
+
+  def test_levels
+    logger_a = Reforge::InternalLogger.new(A)
+    logger_b = Reforge::InternalLogger.new(B)
+
+    assert_equal :warn, logger_a.level
+    assert_equal :warn, logger_b.level
+
+    Reforge::InternalLogger.using_reforge_log_filter!
+    assert_equal :trace, logger_a.level
+    assert_equal :trace, logger_b.level
+  end
+
+end
+
+class A
+end
+
+class B
+end

data/test/test_javascript_stub.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class JavascriptStubTest < Minitest::Test
+  PROJECT_ENV_ID = 1
+  DEFAULT_VALUE = 'default_value'
+  DEFAULT_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+  TRUE_CONFIG = PrefabProto::ConfigValue.new(bool: true)
+  FALSE_CONFIG = PrefabProto::ConfigValue.new(bool: false)
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
+    values: [
+      PrefabProto::ConditionalValue.new(value: DEFAULT_VALUE_CONFIG)
+    ]
+  )
+
+  def setup
+    super
+
+    log_level = PrefabProto::Config.new(
+      id: 999,
+      key: 'log-level',
+      config_type: PrefabProto::ConfigType::LOG_LEVEL,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [],
+              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::INFO)
+            )
+          ]
+        )
+      ]
+    )
+
+    config_for_sdk = PrefabProto::Config.new(
+      id: 123,
+      key: 'basic-config',
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [DEFAULT_ROW],
+      send_to_client_sdk: true
+    )
+
+    config_not_for_sdk = PrefabProto::Config.new(
+      id: 787,
+      key: 'non-sdk-basic-config',
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [DEFAULT_ROW]
+    )
+
+    json_config = PrefabProto::Config.new(
+      id: 234,
+      key: 'json-config',
+      config_type: PrefabProto::ConfigType::CONFIG,
+      send_to_client_sdk: true,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(value: PrefabProto::ConfigValue.new(json: PrefabProto::Json.new(json: '{"key":"value"}')))
+          ]
+        )
+      ]
+    )
+
+    duration_config = PrefabProto::Config.new(
+      id: 236,
+      key: 'duration-config',
+      config_type: PrefabProto::ConfigType::CONFIG,
+      send_to_client_sdk: true,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(value: PrefabProto::ConfigValue.new(duration: PrefabProto::IsoDuration.new(definition: "P4DT12H30M5S")))
+          ]
+        )
+      ]
+    )
+
+    ff = PrefabProto::Config.new(
+      id: 456,
+      key: 'feature-flag',
+      config_type: PrefabProto::ConfigType::FEATURE_FLAG,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: TRUE_CONFIG,
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(['hotmail.com', 'gmail.com']),
+                  property_name: 'user.email'
+                )
+              ]
+            ),
+            PrefabProto::ConditionalValue.new(value: FALSE_CONFIG)
+          ]
+        )
+      ]
+    )
+
+    @client = new_client(
+      config: [log_level, config_for_sdk, config_not_for_sdk, ff, json_config, duration_config],
+      project_env_id: PROJECT_ENV_ID,
+      collect_evaluation_summaries: true,
+      context_upload_mode: :periodic_example,
+      allow_telemetry_in_local_mode: true
+    )
+  end
+
+  def test_bootstrap
+    result = Reforge::JavaScriptStub.new(@client).bootstrap({})
+
+
+    File.open('/tmp/prefab_config.json', 'w') do |f|
+      f.write(result)
+    end
+    assert_equal %(
+window._prefabBootstrap = {
+  evaluations: {"log-level":{"value":{"logLevel":"INFO"}},"basic-config":{"value":{"string":"default_value"}},"feature-flag":{"value":{"bool":false}},"json-config":{"value":{"json":"{\\"key\\":\\"value\\"}"}},"duration-config":{"value":{"duration":{"ms":390605000.0,"seconds":390605.0}}}},
+  context: {}
+}
+    ).strip, result.strip
+
+    result = Reforge::JavaScriptStub.new(@client).bootstrap({ user: { email: 'gmail.com' } })
+
+    File.open('/tmp/prefab_config.json', 'w') do |f|
+      f.write(result)
+    end
+
+    assert_equal %(
+window._prefabBootstrap = {
+  evaluations: {"log-level":{"value":{"logLevel":"INFO"}},"basic-config":{"value":{"string":"default_value"}},"feature-flag":{"value":{"bool":true}},"json-config":{"value":{"json":"{\\"key\\":\\"value\\"}"}},"duration-config":{"value":{"duration":{"ms":390605000.0,"seconds":390605.0}}}},
+  context: {"user":{"email":"gmail.com"}}
+}
+
+    ).strip, result.strip
+  end
+
+  def test_generate_stub
+    result = Reforge::JavaScriptStub.new(@client).generate_stub({})
+
+    assert_equal %(
+window.prefab = window.prefab || {};
+window.prefab.config = {"log-level":"INFO","basic-config":"default_value","feature-flag":false,"json-config":"{\\"key\\":\\"value\\"}","duration-config":{"ms":390605000.0,"seconds":390605.0}};
+window.prefab.get = function(key) {
+  var value = window.prefab.config[key];
+
+  return value;
+};
+window.prefab.isEnabled = function(key) {
+  var value = window.prefab.config[key] === true;
+
+  return value;
+};
+    ).strip, result.strip
+
+    result = Reforge::JavaScriptStub.new(@client).generate_stub({ user: { email: 'gmail.com' } }, 'myEvalCallback')
+
+    assert_equal %(
+window.prefab = window.prefab || {};
+window.prefab.config = {"log-level":"INFO","basic-config":"default_value","feature-flag":true,"json-config":"{\\"key\\":\\"value\\"}","duration-config":{"ms":390605000.0,"seconds":390605.0}};
+window.prefab.get = function(key) {
+  var value = window.prefab.config[key];
+  myEvalCallback(key, value);
+  return value;
+};
+window.prefab.isEnabled = function(key) {
+  var value = window.prefab.config[key] === true;
+  myEvalCallback(key, value);
+  return value;
+};
+
+    ).strip, result.strip
+  end
+end

data/test/test_local_config_parser.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestLocalConfigParser < Minitest::Test
+  FILE_NAME = 'example-config.yaml'
+  DEFAULT_MATCH = 'default'
+
+  def setup
+    super
+    @mock_resolver = MockResolver.new
+  end
+
+  def test_parse_int_config
+    key = :sample_int
+    parsed = Reforge::LocalConfigParser.parse(key, 123, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal DEFAULT_MATCH, parsed[:match]
+    assert_equal :CONFIG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+    assert_equal 123, config.rows[0].values[0].value.int
+  end
+
+  def test_flag_with_a_value
+    key = :flag_with_a_value
+    value = stringify_keys({ feature_flag: true, value: 'all-features' })
+    parsed = Reforge::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal key, parsed[:match]
+    assert_equal :FEATURE_FLAG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+
+    value_row = config.rows[0].values[0]
+    assert_equal 'all-features', Reforge::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}, @mock_resolver).unwrap
+  end
+
+  def test_flag_in_user_key
+    key = :flag_in_user_key
+    value = stringify_keys({ 'feature_flag': 'true', value: true,
+                             criterion: { operator: 'PROP_IS_ONE_OF', property: 'user.key', values: %w[abc123 xyz987] } })
+    parsed = Reforge::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal key, parsed[:match]
+    assert_equal :FEATURE_FLAG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+    assert_equal 1, config.rows[0].values[0].criteria.size
+
+    value_row = config.rows[0].values[0]
+    assert_equal true, Reforge::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}, @mock_resolver).unwrap
+
+    assert_equal 'user.key', value_row.criteria[0].property_name
+    assert_equal :PROP_IS_ONE_OF, value_row.criteria[0].operator
+    assert_equal %w[abc123 xyz987], value_row.criteria[0].value_to_match.string_list.values
+  end
+
+  def test_provided_values
+    with_env('LOOKUP_ENV', 'from env') do 
+      key = :test_provided
+      value = stringify_keys({type: 'provided', source: 'ENV_VAR', lookup: 'LOOKUP_ENV'})
+      parsed = Reforge::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+      config = parsed[:config]
+
+      assert_equal FILE_NAME, parsed[:source]
+      assert_equal 'LOOKUP_ENV', parsed[:match]
+      assert_equal :CONFIG, config.config_type
+      assert_equal key.to_s, config.key
+      assert_equal 1, config.rows.size
+      assert_equal 1, config.rows[0].values.size
+      
+      value_row = config.rows[0].values[0]            
+      provided = value_row.value.provided
+      assert_equal :ENV_VAR, provided.source
+      assert_equal 'LOOKUP_ENV', provided.lookup
+      assert_equal 'from env', Reforge::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).unwrap
+      reportable_value = Reforge::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).reportable_value
+      assert_equal 'from env', reportable_value
+    end
+  end
+
+  def test_confidential_provided_values
+    with_env('LOOKUP_ENV', 'from env') do
+      key = :test_provided
+      value = stringify_keys({type: 'provided', source: 'ENV_VAR', lookup: 'LOOKUP_ENV', confidential: true})
+      parsed = Reforge::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+      config = parsed[:config]
+
+      value_row = config.rows[0].values[0]
+      provided = value_row.value.provided
+      assert_equal :ENV_VAR, provided.source
+      assert_equal 'LOOKUP_ENV', provided.lookup
+      assert_equal 'from env', Reforge::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).unwrap
+      reportable_value = Reforge::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).reportable_value
+      assert reportable_value.start_with? Reforge::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+    end
+  end
+
+  def test_confidential_values
+    key = :test_confidential
+    value = stringify_keys({value: 'a confidential string', confidential: true})
+    parsed = Reforge::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal :CONFIG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+
+    value_row = config.rows[0].values[0]
+    config_value = value_row.value
+    assert_equal 'a confidential string', Reforge::ConfigValueUnwrapper.deepest_value(config_value, key, {}, @mock_resolver).unwrap
+    reportable_value = Reforge::ConfigValueUnwrapper.deepest_value(config_value, key, {}, @mock_resolver).reportable_value
+    assert reportable_value.start_with? Reforge::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+  end
+
+  private
+
+  def stringify_keys(hash)
+    deep_transform_keys(hash, &:to_s)
+  end
+
+  def deep_transform_keys(hash, &block)
+    result = {}
+    hash.each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? deep_transform_keys(value, &block) : value
+    end
+    result
+  end
+
+  class MockResolver
+    def get(key)
+      raise "unexpected key"
+    end
+  end
+end

data/test/test_logger_initialization.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestLoggerInitialization < Minitest::Test
+
+  def test_init_out_of_order
+    # assert nothing blows up
+    Reforge.log_filter
+  end
+
+end

data/test/test_options.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestOptions < Minitest::Test
+  API_KEY = 'abcdefg'
+
+  def test_api_override_env_var
+    assert_equal Reforge::Options::DEFAULT_SOURCES, Reforge::Options.new.sources
+
+    # blank doesn't take effect
+    with_env('PREFAB_API_URL_OVERRIDE', '') do
+      assert_equal Reforge::Options::DEFAULT_SOURCES, Reforge::Options.new.sources
+    end
+
+    # non-blank does take effect
+    with_env('PREFAB_API_URL_OVERRIDE', 'https://override.example.com') do
+      assert_equal ["https://override.example.com"], Reforge::Options.new.sources
+    end
+  end
+
+  def test_overriding_sources
+    assert_equal Reforge::Options::DEFAULT_SOURCES, Reforge::Options.new.sources
+
+    # a plain string ends up wrapped in an array
+    source = 'https://example.com'
+    assert_equal [source], Reforge::Options.new(sources: source).sources
+
+    sources = ['https://example.com', 'https://example2.com']
+    assert_equal sources, Reforge::Options.new(sources: sources).sources
+  end
+
+  def test_works_with_named_arguments
+    assert_equal API_KEY, Reforge::Options.new(sdk_key: API_KEY).sdk_key
+  end
+
+  def test_works_with_hash
+    assert_equal API_KEY, Reforge::Options.new({ sdk_key: API_KEY }).sdk_key
+  end
+
+  def test_collect_max_paths
+    assert_equal 1000, Reforge::Options.new.collect_max_paths
+    assert_equal 100, Reforge::Options.new(collect_max_paths: 100).collect_max_paths
+  end
+
+  def test_collect_max_paths_with_local_only
+    options = Reforge::Options.new(collect_max_paths: 100,
+                                  prefab_datasources: Reforge::Options::DATASOURCES::LOCAL_ONLY)
+    assert_equal 0, options.collect_max_paths
+  end
+
+  def test_collect_max_paths_with_collect_logger_counts_false
+    options = Reforge::Options.new(collect_max_paths: 100,
+                                  collect_logger_counts: false)
+    assert_equal 0, options.collect_max_paths
+  end
+
+  def test_collect_max_evaluation_summaries
+    assert_equal 100_000, Reforge::Options.new.collect_max_evaluation_summaries
+    assert_equal 0, Reforge::Options.new(collect_evaluation_summaries: false).collect_max_evaluation_summaries
+    assert_equal 3,
+                 Reforge::Options.new(collect_max_evaluation_summaries: 3).collect_max_evaluation_summaries
+  end
+
+  def test_context_upload_mode_periodic
+    options = Reforge::Options.new(context_upload_mode: :periodic_example, context_max_size: 100)
+    assert_equal 100, options.collect_max_example_contexts
+
+    options = Reforge::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_example_contexts
+  end
+
+  def test_context_upload_mode_shape_only
+    options = Reforge::Options.new(context_upload_mode: :shape_only, context_max_size: 100)
+    assert_equal 100, options.collect_max_shapes
+
+    options = Reforge::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_shapes
+  end
+
+  def test_context_upload_mode_none
+    options = Reforge::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_example_contexts
+
+    options = Reforge::Options.new(context_upload_mode: :none)
+    assert_equal 0, options.collect_max_shapes
+  end
+
+  def test_loading_a_datafile
+    options = Reforge::Options.new(datafile: "#{Dir.pwd}/test/fixtures/datafile.json")
+    assert_equal "#{Dir.pwd}/test/fixtures/datafile.json", options.datafile
+  end
+end

data/test/test_prefab.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestPrefab < Minitest::Test
+
+
+
+  private
+
+  def init_once
+    unless Reforge.instance_variable_get("@singleton")
+      Reforge.init(prefab_options)
+    end
+  end
+end

data/test/test_rate_limit_cache.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class RateLimitCacheTest < Minitest::Test
+  def test_set_and_fresh
+    cache = Reforge::RateLimitCache.new(5)
+    cache.set('key')
+    assert cache.fresh?('key')
+  end
+
+  def test_fresh_with_no_set
+    cache = Reforge::RateLimitCache.new(5)
+    refute cache.fresh?('key')
+  end
+
+  def test_get_after_expiration
+    cache = Reforge::RateLimitCache.new(5)
+
+    Timecop.freeze(Time.now - 6) do
+      cache.set('key')
+      assert cache.fresh?('key')
+    end
+
+    refute cache.fresh?('key')
+
+    # but the data is still there
+    assert cache.data.get('key')
+  end
+
+  def test_prune
+    cache = Reforge::RateLimitCache.new(5)
+
+    Timecop.freeze(Time.now - 6) do
+      cache.set('key')
+      assert cache.fresh?('key')
+    end
+
+    cache.prune
+
+    refute cache.fresh?('key')
+  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