sdk-reforge 1.9.0

data/test/integration_test.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+class IntegrationTest
+  attr_reader :func, :input, :expected, :data, :expected_data, :aggregator, :endpoint, :test_client, :block_context
+
+  def initialize(test_data)
+    @global_context = test_data['contexts']['global'] if test_data['contexts']
+    @block_context = test_data['contexts']['block'] if test_data['contexts']
+    @local_context = test_data['contexts']['local'] if test_data['contexts']
+
+    @client_overrides = parse_client_overrides(test_data['client_overrides'])
+    @func = parse_function(test_data['function'])
+    @input = parse_input(test_data['input'])
+    @expected = parse_expected(test_data['expected'])
+    @type = test_data['type']
+    @data = test_data['data']
+    @expected_data = test_data['expected_data'] || []
+    @aggregator = test_data['aggregator']
+    @endpoint = test_data['endpoint']
+    @test_client = capture_telemetry(base_client)
+  end
+
+  def teardown
+    test_client.stop
+  end
+
+  def test_type
+    if @data
+      :telemetry
+    elsif @type == "DURATION"
+      :duration
+    elsif @input[0] && @input[0].start_with?('log-level.')
+      :log_level
+    elsif @expected[:status] == 'raise'
+      :raise
+    elsif @expected[:value].nil?
+      :nil
+    else
+      :simple_equality
+    end
+  end
+
+  def last_data_sent
+    test_client.last_data_sent
+  end
+
+  def last_post_result
+    test_client.last_post_result
+  end
+
+  def last_post_endpoint
+    test_client.last_post_endpoint
+  end
+
+  private
+
+  def parse_client_overrides(overrides)
+    Hash[
+      (overrides || {}).map do |(k, v)|
+        if k.to_s == "reforge_api_url"
+          [:sources, [v]]
+        else
+          [k.to_sym, v]
+        end
+      end
+    ]
+  end
+
+  def parse_function(function)
+    case function
+    when 'get_or_raise' then :get
+    when 'enabled' then :enabled?
+    else :"#{function}"
+    end
+  end
+
+  def parse_input(input)
+    return nil if input.nil?
+
+    if input['key']
+      parse_config_input(input)
+    elsif input['flag']
+      parse_ff_input(input)
+    end
+  end
+
+  def parse_config_input(input)
+    if !input['default'].nil?
+      [input['key'], input['default'], @local_context]
+    elsif @local_context
+      [input['key'], Reforge::NO_DEFAULT_PROVIDED, @local_context]
+    else
+      [input['key']]
+    end
+  end
+
+  def parse_ff_input(input)
+    [input['flag'], input['default'], @local_context]
+  end
+
+  def parse_expected(expected)
+    return {} if expected.nil?
+
+    {
+      status: expected['status'],
+      error: parse_error_type(expected['error']),
+      message: expected['message'],
+      value: expected['value'],
+      millis: expected['millis'],
+    }
+  end
+
+  def parse_error_type(error_type)
+    case error_type
+    when 'missing_default' then Reforge::Errors::MissingDefaultError
+    when 'initialization_timeout' then Reforge::Errors::InitializationTimeoutError
+    when 'unable_to_decrypt' then OpenSSL::Cipher::CipherError
+    when 'missing_env_var' then Reforge::Errors::MissingEnvVarError
+    when 'unable_to_coerce_env_var' then Reforge::Errors::EnvVarParseError
+    else
+      unless error_type.nil?
+        throw "Unknown error type: #{error_type}"
+      end
+    end
+  end
+
+  def base_client
+    @_base_client ||= Reforge::Client.new(base_client_options)
+  end
+
+  def base_client_options
+    @_options ||= Reforge::Options.new(**{
+      prefab_datasources: Reforge::Options::DATASOURCES::ALL,
+      sdk_key: ENV['REFORGE_INTEGRATION_TEST_SDK_KEY'],
+      sources: [
+        'https://primary.goatsofreforge.com',
+        'https://secondary.goatsofreforge.com',
+      ],
+      global_context: @global_context || {},
+    }.merge(@client_overrides))
+  end
+
+  def capture_telemetry(client)
+    super_method = client.method(:post)
+
+    client.define_singleton_method(:post) do |url, data|
+      client.instance_variable_set(:@last_data_sent, data)
+      client.instance_variable_set(:@last_post_endpoint, url)
+
+      result = super_method.call(url, data)
+
+      client.instance_variable_set(:@last_post_result, result)
+
+      result
+    end
+
+    client.define_singleton_method(:last_data_sent) do
+      client.instance_variable_get(:@last_data_sent)
+    end
+
+    client.define_singleton_method(:last_post_endpoint) do
+      client.instance_variable_get(:@last_post_endpoint)
+    end
+
+    client.define_singleton_method(:last_post_result) do
+      client.instance_variable_get(:@last_post_result)
+    end
+
+    client
+  end
+end

data/test/integration_test_helpers.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module IntegrationTestHelpers
+  SUBMODULE_PATH = 'test/shared-integration-test-data'
+
+  def self.find_integration_tests
+    files = find_test_files
+
+    if files.none?
+      raise "No integration tests found"
+    end
+
+    files
+  end
+
+  def self.find_test_files
+    Dir[File.join(SUBMODULE_PATH, "tests/current/**/*")]
+      .select { |file| file =~ /\.ya?ml$/ }
+  end
+
+  def self.prepare_post_data(it)
+    case it.aggregator
+    when "context_shape"
+      aggregator = it.test_client.context_shape_aggregator
+
+      context = Reforge::Context.new(it.data)
+
+      aggregator.push(context)
+
+      expected = it.expected_data.map do |data|
+        PrefabProto::ContextShape.new(
+          name: data["name"],
+          field_types: data["field_types"]
+        )
+      end
+
+      [aggregator, ->(data) { data.events[0].context_shapes.shapes }, expected]
+    when "evaluation_summary"
+      aggregator = it.test_client.evaluation_summary_aggregator
+
+      aggregator.instance_variable_set("@data", Concurrent::Hash.new)
+
+      it.data["keys"].each do |key|
+        it.test_client.get(key)
+      end
+
+      expected_data = []
+      it.expected_data.each do |data|
+        value = if data["value_type"] == "string_list"
+                  PrefabProto::StringList.new(values: data["value"])
+                else
+                  data["value"]
+                end
+        expected_data << PrefabProto::ConfigEvaluationSummary.new(
+          key: data["key"],
+          type: data["type"].to_sym,
+          counters: [
+            PrefabProto::ConfigEvaluationCounter.new(
+              count: data["count"],
+              config_id: 0,
+              selected_value: PrefabProto::ConfigValue.new(data["value_type"] => value),
+              config_row_index: data["summary"]["config_row_index"],
+              conditional_value_index: data["summary"]["conditional_value_index"] || 0,
+              weighted_value_index: data["summary"]["weighted_value_index"],
+              reason: :UNKNOWN
+            )
+          ]
+        )
+      end
+
+      [aggregator, ->(data) {
+                     data.events[0].summaries.summaries.each { |e|
+                       e.counters.each { |c|
+                         c.config_id = 0
+                       }
+                     }
+                   }, expected_data]
+    when "example_contexts"
+      aggregator = it.test_client.example_contexts_aggregator
+
+      it.data.each do |key, values|
+        aggregator.record(Reforge::Context.new({ key => values }))
+      end
+
+      expected_data = []
+      it.expected_data.each do |k, vs|
+        expected_data << PrefabProto::ExampleContext.new(
+          timestamp: 0,
+          contextSet: PrefabProto::ContextSet.new(
+            contexts: [
+              PrefabProto::Context.new(
+                type: k,
+                values: vs.each_pair.map do |key, value|
+                  [key, Reforge::ConfigValueWrapper.wrap(value)]
+                end.to_h
+              )
+            ]
+          )
+        )
+      end
+      [aggregator, ->(data) { data.events[0].example_contexts.examples.each { |e| e.timestamp = 0 } }, expected_data]
+    else
+      puts "unknown aggregator #{it.aggregator}"
+    end
+  end
+
+  def self.with_block_context_maybe(context, &block)
+    if context
+      Reforge::Context.with_context(context, &block)
+    else
+      yield
+    end
+  end
+end

data/test/support/common_helpers.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module CommonHelpers
+  require 'timecop'
+
+  def setup
+    $oldstderr, $stderr = $stderr, StringIO.new
+
+    $logs = StringIO.new
+    Reforge::Context.global_context.clear
+    Reforge::Context.default_context.clear
+    SemanticLogger.add_appender(io: $logs, filter: Reforge.log_filter)
+    SemanticLogger.sync!
+  end
+
+  def teardown
+    if $logs && !$logs.string.empty?
+      log_lines = $logs.string.split("\n").reject do |line|
+        line.match(/Reforge::ConfigClient -- No success loading checkpoints/)
+      end
+
+      if log_lines.size > 0
+        $logs = nil
+        raise "Unexpected logs. Handle logs with assert_logged\n\n#{log_lines}"
+      end
+    end
+
+    #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.')
+        # Filter out ld-eventsource frozen string literal warnings in Ruby 3.4+
+        stderr_lines = $stderr.string.split("\n").reject do |line|
+          line.include?('ld-eventsource') && line.include?('literal string will be frozen in the future')
+        end
+
+        if !stderr_lines.empty?
+          raise "Unexpected stderr. Handle stderr with assert_stderr\n\n#{stderr_lines.join("\n")}"
+        end
+      end
+    end
+
+    # Only restore stderr if we have a valid oldstderr
+    if $oldstderr
+      $stderr = $oldstderr
+    end
+
+    Timecop.return
+  end
+
+  def with_env(key, value, &block)
+    old_value = ENV.fetch(key, nil)
+
+    ENV[key] = value
+    block.call
+  ensure
+    ENV[key] = old_value
+  end
+
+  EFFECTIVELY_NEVER = 99_999 # we sync manually
+
+  DEFAULT_NEW_CLIENT_OPTIONS = {
+    prefab_datasources: Reforge::Options::DATASOURCES::LOCAL_ONLY,
+    collect_sync_interval: EFFECTIVELY_NEVER,
+  }.freeze
+
+  def new_client(overrides = {})
+    config = overrides.delete(:config)
+    project_env_id = overrides.delete(:project_env_id)
+
+    Reforge::Client.new(prefab_options(overrides)).tap do |client|
+      inject_config(client, config) if config
+
+      client.resolver.project_env_id = project_env_id if project_env_id
+    end
+  end
+
+  def prefab_options(overrides = {})
+    Reforge::Options.new(
+      **DEFAULT_NEW_CLIENT_OPTIONS.merge(overrides)
+    )
+  end
+
+  def string_list(values)
+    PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
+  end
+
+  def inject_config(client, config)
+    resolver = client.config_client.instance_variable_get('@config_resolver')
+    store = resolver.instance_variable_get('@local_store')
+
+    Array(config).each do |c|
+      store[c.key] = { config: c }
+    end
+  end
+
+  def inject_project_env_id(client, project_env_id)
+    resolver = client.config_client.instance_variable_get('@config_resolver')
+    resolver.project_env_id = project_env_id
+  end
+
+  FakeResponse = Struct.new(:status, :body)
+
+  def wait_for(condition, max_wait: 2, sleep_time: 0.01)
+    wait_time = 0
+    while !condition.call
+      wait_time += sleep_time
+      sleep sleep_time
+
+      raise "Waited #{max_wait} seconds for the condition to be true, but it never was" if wait_time > max_wait
+    end
+  end
+
+  def wait_for_post_requests(client, max_wait: 2, sleep_time: 0.01)
+    # we use ivars to avoid re-mocking the post method on subsequent calls
+    client.instance_variable_set("@_requests", [])
+
+    if !client.instance_variable_get("@_already_faked_post")
+      client.define_singleton_method(:post) do |*params|
+        @_requests.push(params)
+
+        FakeResponse.new(200, '')
+      end
+    end
+
+    client.instance_variable_set("@_already_faked_post", true)
+
+    yield
+
+    # let the flush thread run
+    wait_for -> { client.instance_variable_get("@_requests").size > 0 }, max_wait: max_wait, sleep_time: sleep_time
+
+    client.instance_variable_get("@_requests")
+  end
+
+  def assert_summary(client, data)
+    raise 'Evaluation summary aggregator not enabled' unless client.evaluation_summary_aggregator
+
+    assert_equal data, client.evaluation_summary_aggregator.data
+  end
+
+  def assert_example_contexts(client, data)
+    raise 'Example contexts aggregator not enabled' unless client.example_contexts_aggregator
+
+    assert_equal data, client.example_contexts_aggregator.data
+  end
+
+  def weighted_values(values_and_weights, hash_by_property_name: 'user.key')
+    values = values_and_weights.map do |value, weight|
+      weighted_value(value, weight)
+    end
+
+    PrefabProto::WeightedValues.new(weighted_values: values, hash_by_property_name: hash_by_property_name)
+  end
+
+  def weighted_value(string, weight)
+    PrefabProto::WeightedValue.new(
+      value: PrefabProto::ConfigValue.new(string: string), weight: weight
+    )
+  end
+
+  def context(properties)
+    Reforge::Context.new(properties)
+  end
+
+  def assert_logged(expected)
+    # we do a uniq here because logging can happen in a separate thread so the
+    # number of times a log might happen could be slightly variable.
+    actuals = $logs.string.split("\n").uniq
+    expected.each do |expectation|
+      matched = false
+
+      actuals.each do |actual|
+        matched = true if actual.match(expectation)
+      end
+
+      assert(matched, "expectation: #{expectation}, got: #{actuals}")
+    end
+    # mark nil to indicate we handled it
+    $logs = nil
+  end
+
+  def assert_stderr(expected)
+    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 expected.empty?, "Expected stderr to include: #{expected}, but it did not"
+
+    # restore since we've handled it
+    $stderr = $oldstderr
+  end
+end

data/test/support/mock_base_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class MockBaseClient
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+  attr_reader :namespace, :logger, :config_client, :options, :posts
+
+  def initialize(options = Reforge::Options.new)
+    @options = options
+    @namespace = namespace
+    @config_client = MockConfigClient.new
+    @posts = []
+  end
+
+  def instance_hash
+    'mock-base-client-instance-hash'
+  end
+
+  def project_id
+    1
+  end
+
+  def post(_, _)
+    raise 'Use wait_for_post_requests'
+  end
+
+  def log
+    @logger
+  end
+
+  def context_shape_aggregator; end
+
+  def evaluation_summary_aggregator; end
+
+  def example_contexts_aggregator; end
+
+  def config_value(key)
+    @config_values[key]
+  end
+end

data/test/support/mock_config_client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class MockConfigClient
+  def initialize(config_values = {})
+    @config_values = config_values
+  end
+
+  def get(key, default = nil)
+    @config_values.fetch(key, default)
+  end
+
+  def get_config(key)
+    PrefabProto::Config.new(value: @config_values[key], key: key)
+  end
+
+  def mock_this_config(key, config_value)
+    @config_values[key] = config_value
+  end
+end

data/test/support/mock_config_loader.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true