sdk-reforge 1.9.0

data/test/test_duration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DurationTest < Minitest::Test
+  MINUTES_IN_SECONDS = 60
+  HOURS_IN_SECONDS = 60 * MINUTES_IN_SECONDS
+  DAYS_IN_SECONDS = 24 * HOURS_IN_SECONDS
+
+  TESTS = [
+    ['PT0M0S', 0],
+    ['PT6M', 6 * MINUTES_IN_SECONDS],
+    ['PT90S', 90],
+    ['P1D', DAYS_IN_SECONDS],
+    ['PT1.5M', 1.5 * MINUTES_IN_SECONDS],
+    ['P0.75D', 0.75 * DAYS_IN_SECONDS],
+    ['PT1M90.3S', MINUTES_IN_SECONDS + 90.3],
+    ['PT1H', HOURS_IN_SECONDS],
+    ['PT1.3H', 1.3 * HOURS_IN_SECONDS],
+    ['P1.5DT1.5M', 1.5 * DAYS_IN_SECONDS + MINUTES_IN_SECONDS * 1.5],
+    ['P1.5DT1.5H1.5M', 1.5 * DAYS_IN_SECONDS + 1.5 * HOURS_IN_SECONDS + MINUTES_IN_SECONDS * 1.5],
+    ['P1.5DT1.5H1.5M3.5S', 1.5 * DAYS_IN_SECONDS + 1.5 * HOURS_IN_SECONDS + MINUTES_IN_SECONDS * 1.5 + 3.5],
+    ['P1DT2H3M4S', DAYS_IN_SECONDS + 2 * HOURS_IN_SECONDS + 3 * MINUTES_IN_SECONDS + 4],
+    ['PT1H30M', HOURS_IN_SECONDS + 30 * MINUTES_IN_SECONDS],
+    ['P0.5DT0.25H', 0.5 * DAYS_IN_SECONDS + 0.25 * HOURS_IN_SECONDS],
+    ['PT15M30S', 15 * MINUTES_IN_SECONDS + 30],
+    ['PT0.000347222H', 0.000347222 * HOURS_IN_SECONDS],
+    ['PT23H59M59S', 23 * HOURS_IN_SECONDS + 59 * MINUTES_IN_SECONDS + 59],
+    ['P0.25DT3.75H', 0.25 * DAYS_IN_SECONDS + 3.75 * HOURS_IN_SECONDS],
+  ]
+
+  def test_parsing
+    TESTS.each do |test|
+      assert_equal test[1], Reforge::Duration.parse(test[0]), "Failed parsing #{test[0]}"
+    end
+  end
+end

data/test/test_encryption.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEncryption < Minitest::Test
+  def test_encryption
+    secret = Reforge::Encryption.generate_new_hex_key
+
+    enc = Reforge::Encryption.new(secret)
+
+    clear_text = "hello world"
+    encrypted = enc.encrypt(clear_text)
+    decrypted = enc.decrypt(encrypted)
+    assert_equal clear_text, decrypted
+  end
+end

data/test/test_evaluation_summary_aggregator.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestEvaluationSummaryAggregator < Minitest::Test
+  EFFECTIVELY_NEVER = 99_999 # we sync manually
+
+  EXAMPLE_VALUE_1 = PrefabProto::ConfigValue.new(bool: true)
+  EXAMPLE_VALUE_2 = PrefabProto::ConfigValue.new(bool: false)
+
+  EXAMPLE_COUNTER = {
+    config_id: 1,
+    selected_index: 2,
+    config_row_index: 3,
+    conditional_value_index: 4,
+    weighted_value_index: 5,
+    seleced_value: EXAMPLE_VALUE_1
+  }.freeze
+
+  def test_increments_counts
+    aggregator = Reforge::EvaluationSummaryAggregator.new(client: MockBaseClient.new, max_keys: 10,
+                                                         sync_interval: EFFECTIVELY_NEVER)
+
+    aggregator.record(config_key: 'foo', config_type: 'bar', counter: EXAMPLE_COUNTER)
+
+    assert_equal 1, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+
+    2.times { aggregator.record(config_key: 'foo', config_type: 'bar', counter: EXAMPLE_COUNTER) }
+    assert_equal 3, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+
+    another_counter = EXAMPLE_COUNTER.merge(selected_index: EXAMPLE_COUNTER[:selected_index] + 1)
+
+    aggregator.record(config_key: 'foo', config_type: 'bar', counter: another_counter)
+    assert_equal 3, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+    assert_equal 1, aggregator.data[%w[foo bar]][another_counter]
+  end
+
+  def test_prepare_data
+    aggregator = Reforge::EvaluationSummaryAggregator.new(client: MockBaseClient.new, max_keys: 10,
+                                                         sync_interval: EFFECTIVELY_NEVER)
+
+    expected = {
+      ['config-1', :CONFIG] => {
+        { config_id: 1, selected_index: 2, config_row_index: 3, conditional_value_index: 4,
+          weighted_value_index: 5, selected_value: EXAMPLE_VALUE_1 } => 3,
+        { config_id: 1, selected_index: 3, config_row_index: 7, conditional_value_index: 8,
+          weighted_value_index: 10, selected_value: EXAMPLE_VALUE_2 } => 1
+      },
+      ['config-2', :FEATURE_FLAG] => {
+        { config_id: 2, selected_index: 3, config_row_index: 5, conditional_value_index: 7,
+          weighted_value_index: 6, selected_value: EXAMPLE_VALUE_1 } => 9
+      }
+    }
+
+    add_example_data(aggregator)
+    assert_equal expected, aggregator.prepare_data
+    assert aggregator.data.empty?
+  end
+
+  def test_sync
+    Timecop.freeze('2023-08-09 15:18:12 -0400') do
+      awhile_ago = Time.now - 60
+      now = Time.now
+
+      client = MockBaseClient.new
+
+      aggregator = nil
+
+      Timecop.freeze(awhile_ago) do
+        # start the aggregator in the past
+        aggregator = Reforge::EvaluationSummaryAggregator.new(client: client, max_keys: 10,
+                                                           sync_interval: EFFECTIVELY_NEVER)
+      end
+
+      add_example_data(aggregator)
+
+      expected_post = PrefabProto::TelemetryEvents.new(
+        instance_hash: client.instance_hash,
+        events: [
+          PrefabProto::TelemetryEvent.new(
+            summaries: PrefabProto::ConfigEvaluationSummaries.new(
+              start: awhile_ago.to_i * 1000,
+              end: now.to_i * 1000,
+              summaries: [
+                PrefabProto::ConfigEvaluationSummary.new(
+                  key: 'config-1',
+                  type: :CONFIG,
+                  counters: [
+                    PrefabProto::ConfigEvaluationCounter.new(
+                      config_id: 1,
+                      selected_index: 2,
+                      config_row_index: 3,
+                      conditional_value_index: 4,
+                      weighted_value_index: 5,
+                      selected_value: EXAMPLE_VALUE_1,
+                      count: 3
+                    ),
+                    PrefabProto::ConfigEvaluationCounter.new(
+                      config_id: 1,
+                      selected_index: 3,
+                      config_row_index: 7,
+                      conditional_value_index: 8,
+                      weighted_value_index: 10,
+                      selected_value: EXAMPLE_VALUE_2,
+                      count: 1
+                    )
+                  ]
+                ),
+                PrefabProto::ConfigEvaluationSummary.new(
+                  key: 'config-2',
+                  type: :FEATURE_FLAG,
+                  counters: [
+                    PrefabProto::ConfigEvaluationCounter.new(
+                      config_id: 2,
+                      selected_index: 3,
+                      config_row_index: 5,
+                      conditional_value_index: 7,
+                      weighted_value_index: 6,
+                      selected_value: EXAMPLE_VALUE_1,
+                      count: 9
+                    )
+                  ]
+                )
+              ]
+            )
+          )
+        ]
+      )
+
+      requests = wait_for_post_requests(client) do
+        Timecop.freeze(now) do
+          aggregator.sync
+        end
+      end
+
+      assert_equal [[
+        '/api/v1/telemetry',
+        expected_post
+      ]], requests
+    end
+  end
+
+  private
+
+  def add_example_data(aggregator)
+    data = {
+      ['config-1', :CONFIG] => {
+        { config_id: 1, selected_index: 2, config_row_index: 3, conditional_value_index: 4,
+          weighted_value_index: 5, selected_value: EXAMPLE_VALUE_1 } => 3,
+        { config_id: 1, selected_index: 3, config_row_index: 7, conditional_value_index: 8,
+          weighted_value_index: 10, selected_value: EXAMPLE_VALUE_2 } => 1
+      },
+      ['config-2', :FEATURE_FLAG] => {
+        { config_id: 2, selected_index: 3, config_row_index: 5, conditional_value_index: 7,
+          weighted_value_index: 6, selected_value: EXAMPLE_VALUE_1 } => 9
+      }
+    }
+
+    aggregator.instance_variable_set('@data', data)
+  end
+end

data/test/test_example_contexts_aggregator.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestExampleContextsAggregator < Minitest::Test
+  def test_record
+    aggregator = Reforge::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 2,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Reforge::Context.new(user: { key: 'abc' }, device: { key: 'def', mobile: true })
+
+    aggregator.record(context)
+    assert_equal [context], aggregator.data
+
+    # This doesn't get updated because we already have a context for this user/device
+    aggregator.record(context)
+    assert_equal [context], aggregator.data
+
+    new_context = Reforge::Context.new(
+      user: { key: 'ghi', admin: true },
+      team: { key: '999' }
+    )
+
+    aggregator.record(new_context)
+    assert_equal [context, new_context], aggregator.data
+
+    # this doesn't get recorded because we're at max_contexts
+    aggregator.record(Reforge::Context.new(user: { key: 'new' }))
+    assert_equal [context, new_context], aggregator.data
+  end
+
+  def test_prepare_data
+    aggregator = Reforge::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Reforge::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+
+    assert_equal [context], aggregator.prepare_data
+    assert aggregator.data.empty?
+  end
+
+  def test_record_with_expiry
+    aggregator = Reforge::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Reforge::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+
+    assert_equal [context], aggregator.data
+
+    Timecop.travel(Time.now + (60 * 60) - 1) do
+      aggregator.record(context)
+
+      # This doesn't get updated because we already have a context for this user/device in the timeframe
+      assert_equal [context], aggregator.data
+    end
+
+    Timecop.travel(Time.now + ((60 * 60) + 1)) do
+      # this is new because we've passed the expiry
+      aggregator.record(context)
+
+      assert_equal [context, context], aggregator.data
+    end
+  end
+
+  def test_sync
+    now = Time.now
+
+    client = MockBaseClient.new
+
+    aggregator = Reforge::ExampleContextsAggregator.new(client: client, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Reforge::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+    aggregator.record(context)
+
+    # This is the same as above so we shouldn't get anything new
+    aggregator.record(context)
+
+    aggregator.record(
+      Reforge::Context.new(
+        user: { key: 'ghi' },
+        device: { key: 'jkl', mobile: false }
+      )
+    )
+
+    aggregator.record(Reforge::Context.new(user: { key: 'kev', name: 'kevin', age: 48.5 }))
+
+    assert_equal 3, aggregator.cache.data.size
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          example_contexts: PrefabProto::ExampleContexts.new(
+            examples: [
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'abc')
+                      }
+                    ),
+                    PrefabProto::Context.new(
+                      type: 'device',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'def'),
+                        'mobile' => PrefabProto::ConfigValue.new(bool: true)
+                      }
+                    )
+                  ]
+                )
+              ),
+
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'ghi')
+                      }
+                    ),
+                    PrefabProto::Context.new(
+                      type: 'device',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'jkl'),
+                        'mobile' => PrefabProto::ConfigValue.new(bool: false)
+                      }
+                    )
+                  ]
+                )
+              ),
+
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'kev'),
+                        'name' => PrefabProto::ConfigValue.new(string: 'kevin'),
+                        'age' => PrefabProto::ConfigValue.new(double: 48.5)
+                      }
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      ]
+    )
+
+    requests = wait_for_post_requests(client) do
+      Timecop.freeze(now + (60 * 60) - 1) do
+        aggregator.sync
+      end
+    end
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+
+    # this hasn't changed because not enough time has passed
+    assert_equal 3, aggregator.cache.data.size
+
+    # a sync past the expiry should clear the cache
+    Timecop.freeze(now + (60 * 60) + 1) do
+      # we need a new piece of data for the sync to happen
+      aggregator.record(Reforge::Context.new(user: { key: 'bozo', name: 'Bozo', age: 99 }))
+
+      requests = wait_for_post_requests(client) do
+        aggregator.sync
+      end
+    end
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          example_contexts: PrefabProto::ExampleContexts.new(
+            examples: [
+              PrefabProto::ExampleContext.new(
+                timestamp: (now.utc.to_i + (60 * 60) + 1) * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'bozo'),
+                        'name' => PrefabProto::ConfigValue.new(string: 'Bozo'),
+                        'age' => PrefabProto::ConfigValue.new(int: 99)
+                      }
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      ]
+    )
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+
+    # The last sync should have cleared the cache of everything except the latest context
+    assert_equal 1, aggregator.cache.data.size
+    assert_equal ['user:bozo'], aggregator.cache.data.keys
+  end
+end

data/test/test_exponential_backoff.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestExponentialBackoff < Minitest::Test
+  def test_backoff
+    backoff = Reforge::ExponentialBackoff.new(max_delay: 120)
+
+    assert_equal 2, backoff.call
+    assert_equal 4, backoff.call
+    assert_equal 8, backoff.call
+    assert_equal 16, backoff.call
+    assert_equal 32, backoff.call
+    assert_equal 64, backoff.call
+    assert_equal 120, backoff.call
+    assert_equal 120, backoff.call
+  end
+end

data/test/test_feature_flag_client.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestFeatureFlagClient < Minitest::Test
+  DEFAULT = 'default'
+
+
+
+
+  private
+
+  def new_client(overrides = {})
+    super(overrides).feature_flag_client
+  end
+end

data/test/test_fixed_size_hash.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'test_helper'
+
+module Reforge
+  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_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/focus'
+require 'minitest/reporters'
+Minitest::Reporters.use! unless ENV['RM_INFO']
+
+require 'reforge-sdk'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'support', '**', '*.rb')).each do |file|
+  require file
+end
+
+Minitest::Test.class_eval do
+  include CommonHelpers
+  extend CommonHelpers
+end

data/test/test_integration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'integration_test_helpers'
+require 'integration_test'
+require 'yaml'
+
+class TestIntegration < Minitest::Test
+  IntegrationTestHelpers.find_integration_tests.map do |test_file|
+    tests = YAML.load(File.read(test_file))['tests']
+    test_names = []
+
+    tests.each do |test|
+      test['cases'].each do |test_case|
+        new_name = "test_#{test['name']}_#{test_case['name']}"
+
+        if test_names.include?(new_name)
+          raise "Duplicate test name: #{new_name}"
+        end
+
+        test_names << new_name
+
+        define_method(:"#{new_name}") do
+          it = IntegrationTest.new(test_case)
+
+          IntegrationTestHelpers.with_block_context_maybe(it.block_context) do
+            case it.test_type
+            when :raise
+              err = assert_raises(it.expected[:error]) do
+                it.test_client.send(it.func, *it.input)
+              end
+              assert_match(/#{it.expected[:message]}/, err.message)
+            when :nil
+              assert_nil it.test_client.send(it.func, *it.input)
+            when :simple_equality
+              if it.func == :enabled?
+                flag, _default, context = *it.input
+                assert_equal it.expected[:value], it.test_client.send(it.func, flag, context)
+              else
+                assert_equal it.expected[:value], it.test_client.send(it.func, *it.input)
+              end
+            when :log_level
+              assert_equal it.expected[:value].to_sym, it.test_client.send(it.func, *it.input)
+            when :telemetry
+              aggregator, get_actual_data, expected = IntegrationTestHelpers.prepare_post_data(it)
+              aggregator.sync
+
+              wait_for -> { it.last_post_result&.status == 200 }
+
+              assert_equal "/api/v1/telemetry", it.last_post_endpoint
+
+              actual = get_actual_data[it.last_data_sent]
+
+              expected.all? do |expected|
+                assert actual.include?(expected), "#{actual} should include #{expected}"
+              end
+            when :duration
+              assert_equal it.expected[:millis], it.test_client.send(it.func, *it.input).in_seconds * 1000
+            else
+              raise "Unknown test type: #{it.test_type}"
+            end
+
+            if test_case["name"].match(/doesn't raise on init timeout/)
+              assert_logged [
+                "Reforge::ConfigClient -- Couldn't Initialize In 0.01. Key any-key. Returning what we have"
+              ]
+            end
+          ensure
+            it.teardown
+          end
+        end
+      end
+    end
+  end
+end