sdk-reforge 1.9.0

data/test/test_caching_http_connection.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Reforge
+  class CachingHttpConnectionTest < Minitest::Test
+    def setup
+      @uri = 'https://api.example.com'
+      @sdk_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, @sdk_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, @sdk_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, @sdk_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, @sdk_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, @sdk_key)
+        instance2 = CachingHttpConnection.new(@uri, @sdk_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, @sdk_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_client.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestClient < Minitest::Test
+  LOCAL_ONLY = Reforge::Options::DATASOURCES::LOCAL_ONLY
+
+  PROJECT_ENV_ID = 1
+  KEY = 'the-key'
+  DEFAULT_VALUE = 'default_value'
+  DESIRED_VALUE = 'desired_value'
+
+  IRRELEVANT = 'this should never show up'
+
+  DEFAULT_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+  DESIRED_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DESIRED_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 test_get_with_missing_default
+    client = new_client
+    # it raises by default
+    err = assert_raises(Reforge::Errors::MissingDefaultError) do
+      assert_nil client.get('missing_value')
+    end
+
+    assert_match(/No value found for key/, err.message)
+    assert_match(/on_no_default/, err.message)
+
+    # you can opt-in to return `nil` instead
+    client = new_client(on_no_default: Reforge::Options::ON_NO_DEFAULT::RETURN_NIL)
+    assert_nil client.get('missing_value')
+  end
+
+
+
+
+
+  def test_initialization_with_an_options_object
+    options_hash = {
+      namespace: 'test-namespace',
+      prefab_datasources: LOCAL_ONLY
+    }
+
+    options = Reforge::Options.new(options_hash)
+
+    client = Reforge::Client.new(options)
+
+    assert_equal client.namespace, 'test-namespace'
+  end
+
+  def test_initialization_with_a_hash
+    options_hash = {
+      namespace: 'test-namespace',
+      prefab_datasources: LOCAL_ONLY
+    }
+
+    client = Reforge::Client.new(options_hash)
+
+    assert_equal client.namespace, 'test-namespace'
+  end
+
+  def test_evaluation_summary_aggregator
+    fake_api_key = '123-development-yourapikey-SDK'
+
+    # it is nil by default
+    assert_nil new_client(sdk_key: fake_api_key).evaluation_summary_aggregator
+
+    # it is nil when local_only even if collect_max_evaluation_summaries is true
+    assert_nil new_client(prefab_datasources: LOCAL_ONLY,
+                                  collect_evaluation_summaries: true, ).evaluation_summary_aggregator
+
+    # it is nil when collect_max_evaluation_summaries is false
+    assert_nil new_client(sdk_key: fake_api_key,
+                                  prefab_datasources: :all,
+                                  collect_evaluation_summaries: false).evaluation_summary_aggregator
+
+    # it is not nil when collect_max_evaluation_summaries is true and the datasource is not local_only
+    assert_equal Reforge::EvaluationSummaryAggregator,
+                 new_client(sdk_key: fake_api_key,
+                            prefab_datasources: :all,
+                            collect_evaluation_summaries: true).evaluation_summary_aggregator.class
+
+    assert_logged [
+      "Reforge::ConfigClient -- No success loading checkpoints"
+    ]
+  end
+
+  def test_get_with_basic_value
+    config = basic_value_config
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: true,
+                        context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    assert_equal DESIRED_VALUE, client.get(config.key, IRRELEVANT, 'user' => { 'key' => 99 })
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: DESIRED_VALUE_CONFIG,
+          conditional_value_index: 0,
+          weighted_value_index: nil,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [Reforge::Context.new({ user: { 'key' => 99 } })]
+  end
+
+  def test_get_with_basic_value_with_context
+    config = basic_value_config
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: true,
+                        context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    client.with_context('user' => { 'key' => 99 }) do
+      assert_equal DESIRED_VALUE, client.get(config.key)
+    end
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: DESIRED_VALUE_CONFIG,
+          conditional_value_index: 0,
+          weighted_value_index: nil,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [Reforge::Context.new({ user: { 'key' => 99 } })]
+  end
+
+  def test_get_with_weighted_values
+    config = PrefabProto::Config.new(
+      id: 123,
+      key: KEY,
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 98], ['def', 1],
+                                                                                    ['ghi', 1]]))
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: true,
+                       context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    2.times do
+      assert_equal 'abc', client.get(config.key, IRRELEVANT, 'user' => { 'key' => '1' })
+    end
+
+    3.times do
+      assert_equal 'def', client.get(config.key, IRRELEVANT, 'user' => { 'key' => '12' })
+    end
+
+    assert_equal 'ghi',
+                 client.get(config.key, IRRELEVANT, 'user' => { 'key' => '4', admin: true })
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'abc'),
+          conditional_value_index: 0,
+          weighted_value_index: 0,
+          selected_index: nil
+        } => 2,
+
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'def'),
+          conditional_value_index: 0,
+          weighted_value_index: 1,
+          selected_index: nil
+        } => 3,
+
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'ghi'),
+          conditional_value_index: 0,
+          weighted_value_index: 2,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [
+      Reforge::Context.new(user: { 'key' => '1' }),
+      Reforge::Context.new(user: { 'key' => '12' }),
+      Reforge::Context.new(user: { 'key' => '4', admin: true })
+    ]
+  end
+
+  def test_in_seg
+    segment_key = 'segment_key'
+
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
+      key: segment_key,
+      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)
+          ]
+        )
+      ]
+    )
+
+    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::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: segment_key)
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: [config, segment_config], project_env_id: PROJECT_ENV_ID,
+                        collect_evaluation_summaries: true, context_upload_mode: :periodic_example, allow_telemetry_in_local_mode: true)
+
+    assert_equal DEFAULT_VALUE, client.get(config.key)
+    assert_equal DEFAULT_VALUE,
+                 client.get(config.key, IRRELEVANT, user: { key: 'abc', email: 'example@prefab.cloud' })
+    assert_equal DESIRED_VALUE, client.get(config.key, IRRELEVANT, user: { key: 'def', email: 'example@hotmail.com' })
+
+    assert_summary client, {
+      [segment_key, :SEGMENT] => {
+        { config_id: 0, config_row_index: 0, conditional_value_index: 1, selected_value: FALSE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 2,
+        { config_id: 0, config_row_index: 0, conditional_value_index: 0, selected_value: TRUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 1
+      },
+      [KEY, :NOT_SET_CONFIG_TYPE] => {
+        { config_id: 0, config_row_index: 0, conditional_value_index: 0, selected_value: DEFAULT_VALUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 2,
+        { config_id: 0, config_row_index: 1, conditional_value_index: 0, selected_value: DESIRED_VALUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 1
+      }
+    }
+
+    assert_example_contexts client, [
+      Reforge::Context.new(user: { key: 'abc', email: 'example@prefab.cloud' }),
+      Reforge::Context.new(user: { key: 'def', email: 'example@hotmail.com' })
+    ]
+  end
+
+  def test_get_log_level
+    config = PrefabProto::Config.new(
+      id: 999,
+      key: 'log-level',
+      config_type: PrefabProto::ConfigType::LOG_LEVEL,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::INFO)
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID,
+                        collect_evaluation_summaries: true, allow_telemetry_in_local_mode: true)
+
+    assert_equal :INFO, client.get(config.key, IRRELEVANT)
+
+    # nothing is summarized for log levels
+    assert_summary client, {}
+  end
+
+
+
+  def test_with_datafile
+    datafile = "#{Dir.pwd}/test/fixtures/datafile.json"
+    client = new_client(datafile: datafile, prefab_datasources: :all)
+
+    assert client.get('flag.list.environments')
+    assert_equal "hello world", client.get('my.test.string')
+  end
+
+  private
+
+  def basic_value_config
+    PrefabProto::Config.new(
+      id: 123,
+      key: KEY,
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+  end
+end

data/test/test_config_client.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestConfigClient < Minitest::Test
+  def setup
+    super
+    options = Reforge::Options.new(
+      prefab_datasources: Reforge::Options::DATASOURCES::LOCAL_ONLY,
+      x_use_local_cache: true,
+    )
+
+    @config_client = Reforge::ConfigClient.new(MockBaseClient.new(options), 10)
+  end
+
+
+  def test_initialization_timeout_error
+    options = Reforge::Options.new(
+      sdk_key: '123-ENV-KEY-SDK',
+      initialization_timeout_sec: 0.01
+    )
+
+    err = assert_raises(Reforge::Errors::InitializationTimeoutError) do
+      Reforge::Client.new(options).config_client.get('anything')
+    end
+
+    assert_match(/couldn't initialize in 0.01 second timeout/, err.message)
+  end
+
+
+  def test_invalid_api_key_error
+    options = Reforge::Options.new(
+      sdk_key: ''
+    )
+
+    err = assert_raises(Reforge::Errors::InvalidSdkKeyError) do
+      Reforge::Client.new(options).config_client.get('anything')
+    end
+
+    assert_match(/No SDK key/, err.message)
+
+    options = Reforge::Options.new(
+      sdk_key: 'invalid'
+    )
+
+    err = assert_raises(Reforge::Errors::InvalidSdkKeyError) do
+      Reforge::Client.new(options).config_client.get('anything')
+    end
+
+    assert_match(/format is invalid/, err.message)
+  end
+
+  def test_caching
+    @config_client.send(:cache_configs,
+                        PrefabProto::Configs.new(configs:
+                                                   [PrefabProto::Config.new(key: 'test', id: 1,
+                                                                            rows: [PrefabProto::ConfigRow.new(
+                                                                              values: [
+                                                                                PrefabProto::ConditionalValue.new(
+                                                                                  value: PrefabProto::ConfigValue.new(string: "test value")
+                                                                                )
+                                                                              ]
+                                                                            )])],
+                                                 config_service_pointer: PrefabProto::ConfigServicePointer.new(project_id: 3, project_env_id: 5)))
+    @config_client.send(:load_cache)
+    assert_equal "test value", @config_client.get("test")
+  end
+
+  def test_cache_path_respects_xdg
+    options = Reforge::Options.new(
+      prefab_datasources: Reforge::Options::DATASOURCES::LOCAL_ONLY,
+      x_use_local_cache: true,
+      sdk_key: "123-ENV-KEY-SDK",)
+
+    config_client = Reforge::ConfigClient.new(MockBaseClient.new(options), 10)
+    assert_equal "#{Dir.home}/.cache/prefab.cache.123.json", config_client.send(:cache_path)
+
+    with_env('XDG_CACHE_HOME', '/tmp') do
+      config_client = Reforge::ConfigClient.new(MockBaseClient.new(options), 10)
+      assert_equal "/tmp/prefab.cache.123.json", config_client.send(:cache_path)
+    end
+  end
+
+end