prefab-cloud-ruby 0

data/test/integration_test.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+class IntegrationTest
+  attr_reader :func, :input, :expected, :data, :expected_data, :aggregator, :endpoint, :test_client
+
+  def initialize(test_data)
+    @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'])
+    @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 test_type
+    if @data
+      :telemetry
+    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)|
+        [k.to_sym, v]
+      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']]
+    else
+      [input['key']]
+    end
+  end
+
+  def parse_ff_input(input)
+    [input['flag'], input['default'], input['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']
+    }
+  end
+
+  def parse_error_type(error_type)
+    case error_type
+    when 'missing_default' then Prefab::Errors::MissingDefaultError
+    when 'initialization_timeout' then Prefab::Errors::InitializationTimeoutError
+    when 'unable_to_decrypt' then OpenSSL::Cipher::CipherError
+    when 'missing_env_var' then Prefab::Errors::MissingEnvVarError
+    when 'unable_to_coerce_env_var' then Prefab::Errors::EnvVarParseError
+    else
+      unless error_type.nil?
+        throw "Unknown error type: #{error_type}"
+      end
+    end
+  end
+
+  def base_client
+    @_base_client ||= Prefab::Client.new(base_client_options)
+  end
+
+  def base_client_options
+    @_options ||= Prefab::Options.new(**{
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: ['unit_tests'],
+      prefab_datasources: Prefab::Options::DATASOURCES::ALL,
+      api_key: ENV['PREFAB_INTEGRATION_TEST_API_KEY'],
+      prefab_api_url: 'https://api.staging-prefab.cloud',
+    }.merge(@client_overrides))
+  end
+
+  def capture_telemetry(client)
+    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(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,151 @@
+# frozen_string_literal: true
+
+module IntegrationTestHelpers
+  SUBMODULE_PATH = 'test/prefab-cloud-integration-test-data'
+  RAISE_IF_NO_TESTS_FOUND = ENV['PREFAB_INTEGRATION_TEST_RAISE'] == 'true'
+
+  def self.find_integration_tests
+    version = find_integration_test_version
+
+    files = find_versioned_test_files(version)
+
+    if files.none?
+      message = "No integration tests found for version: #{version}"
+      raise message if RAISE_IF_NO_TESTS_FOUND
+
+      puts message
+    end
+
+    files
+  end
+
+  def self.find_integration_test_version
+    File.read(File.join(SUBMODULE_PATH, 'version')).strip
+  rescue StandardError => e
+    puts "No version found for integration tests: #{e.message}"
+  end
+
+  def self.find_versioned_test_files(version)
+    if version.nil?
+      []
+    else
+      Dir[File.join(SUBMODULE_PATH, "tests/#{version}/**/*")]
+        .select { |file| file =~ /\.ya?ml$/ }
+    end
+  end
+
+  SEVERITY_LOOKUP = Prefab::LogPathAggregator::SEVERITY_KEY.invert
+
+  def self.prepare_post_data(it)
+    case it.aggregator
+    when "log_path"
+      aggregator = it.test_client.log_path_aggregator
+
+      it.data.each do |data|
+        data['counts'].each_pair do |severity, count|
+          count.times { aggregator.push(data['logger_name'], SEVERITY_LOOKUP[severity]) }
+        end
+      end
+
+      expected_loggers = Hash.new { |h, k| h[k] = PrefabProto::Logger.new }
+
+      it.expected_data.each do |data|
+        data["counts"].each do |(severity, count)|
+          expected_loggers[data["logger_name"]][severity] = count
+          expected_loggers[data["logger_name"]]["logger_name"] = data["logger_name"]
+        end
+      end
+
+      [aggregator, ->(data) { data.loggers }, expected_loggers.values]
+    when "context_shape"
+      aggregator = it.test_client.context_shape_aggregator
+
+      context = Prefab::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.shapes }, expected]
+    when "evaluation_summary"
+      aggregator = it.test_client.evaluation_summary_aggregator
+
+      aggregator.instance_variable_set("@data", Concurrent::Hash.new)
+
+      it.data.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(Prefab::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, Prefab::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_parent_context_maybe(context, &block)
+    if context
+      Prefab::Context.with_context(context, &block)
+    else
+      yield
+    end
+  end
+end

data/test/support/common_helpers.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module CommonHelpers
+  require 'timecop'
+
+  def setup
+    $oldstderr, $stderr = $stderr, StringIO.new
+
+    $logs = nil
+    Timecop.freeze('2023-08-09 15:18:12 -0400')
+  end
+
+  def teardown
+    if $logs && !$logs.string.empty?
+      raise "Unexpected logs. Handle logs with assert_only_expected_logs or assert_logged\n\n#{$logs.string}"
+    end
+
+    if $stderr != $oldstderr && !$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
+
+    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
+
+  DEFAULT_NEW_CLIENT_OPTIONS = {
+    prefab_config_override_dir: 'none',
+    prefab_config_classpath_dir: 'test',
+    prefab_envs: ['unit_tests'],
+    prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+  }.freeze
+
+  def new_client(overrides = {})
+
+    config = overrides.delete(:config)
+    project_env_id = overrides.delete(:project_env_id)
+
+    Prefab::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 = {})
+    $logs ||= StringIO.new
+    Prefab::Options.new(
+      **DEFAULT_NEW_CLIENT_OPTIONS.merge(
+        overrides.merge(logdev: $logs)
+      )
+    )
+  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)
+    Prefab::Context.new(properties)
+  end
+
+  def assert_only_expected_logs
+    assert_equal "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient No success loading checkpoints\n", $logs.string
+    # mark nil to indicate we handled it
+    $logs = nil
+  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.
+    assert_equal expected, $logs.string.split("\n").uniq
+    # mark nil to indicate we handled it
+    $logs = nil
+  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
+    end
+
+    assert_equal expected, $stderr.string.split("\n")
+
+    # restore since we've handled it
+    $stderr = $oldstderr
+  end
+end

data/test/support/mock_base_client.rb

@@ -0,0 +1,42 @@
+# 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 = Prefab::Options.new)
+    @options = options
+    @namespace = namespace
+    @config_client = MockConfigClient.new
+    Prefab::LoggerClient.new(options.logdev)
+    @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