prefab-cloud-ruby 0.20.0 → 0.22.0

data/test/integration_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+class IntegrationTest
+  attr_reader :func
+  attr_reader :input
+  attr_reader :expected
+  attr_reader :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'])
+    test_client = :"#{test_data['client']}"
+    @test_client = base_client.send(test_client)
+  end
+
+  def test_type
+    if @expected[:status] == 'raise'
+      :raise
+    elsif @expected[:value].nil?
+      :nil
+    elsif @func == :feature_is_on_for?
+      :feature_flag
+    else
+      :simple_equality
+    end
+  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 :feature_is_on_for?
+    else :"#{function}"
+    end
+  end
+
+  def parse_input(input)
+    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['lookup_key'], input['properties'] || {}]
+  end
+
+  def parse_expected(expected)
+    {
+      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
+    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',
+      prefab_grpc_url: 'grpc.staging-prefab.cloud:443'
+    }.merge(@client_overrides))
+  end
+end

data/test/integration_test_helpers.rb

@@ -0,0 +1,37 @@
+# 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
+end

data/test/test_client.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 
 class TestClient < Minitest::Test
@@ -7,25 +8,25 @@ class TestClient < Minitest::Test
   end
 
   def test_get
-    assert_equal "test sample value", @client.get("sample")
-    assert_equal 123, @client.get("sample_int")
+    assert_equal 'test sample value', @client.get('sample')
+    assert_equal 123, @client.get('sample_int')
   end
 
   def test_get_with_default
     # A `false` value is not replaced with the default
-    assert_equal false, @client.get("false_value", "red")
+    assert_equal false, @client.get('false_value', 'red')
 
     # A falsy value is not replaced with the default
-    assert_equal 0, @client.get("zero_value", "red")
+    assert_equal 0, @client.get('zero_value', 'red')
 
     # A missing value returns the default
-    assert_equal "buckets", @client.get("missing_value", "buckets")
+    assert_equal 'buckets', @client.get('missing_value', 'buckets')
   end
 
   def test_get_with_missing_default
     # it raises by default
     err = assert_raises(Prefab::Errors::MissingDefaultError) do
-      assert_nil @client.get("missing_value")
+      assert_nil @client.get('missing_value')
     end
 
     assert_match(/No value found for key/, err.message)
@@ -33,63 +34,87 @@ class TestClient < Minitest::Test
 
     # you can opt-in to return `nil` instead
     client = new_client(on_no_default: Prefab::Options::ON_NO_DEFAULT::RETURN_NIL)
-    assert_nil client.get("missing_value")
+    assert_nil client.get('missing_value')
   end
 
   def test_enabled
-    assert_equal false, @client.enabled?("does_not_exist")
-    assert_equal true, @client.enabled?("enabled_flag")
-    assert_equal false, @client.enabled?("disabled_flag")
-    assert_equal false, @client.enabled?("flag_with_a_value")
+    assert_equal false, @client.enabled?('does_not_exist')
+    assert_equal true, @client.enabled?('enabled_flag')
+    assert_equal false, @client.enabled?('disabled_flag')
+    assert_equal false, @client.enabled?('flag_with_a_value')
   end
 
   def test_ff_enabled_with_lookup_key
-    assert_equal false, @client.enabled?("in_lookup_key", "jimmy")
-    assert_equal true, @client.enabled?("in_lookup_key", "abc123")
-    assert_equal true, @client.enabled?("in_lookup_key", "xyz987")
+    assert_equal false, @client.enabled?('in_lookup_key', 'jimmy')
+    assert_equal true, @client.enabled?('in_lookup_key', 'abc123')
+    assert_equal true, @client.enabled?('in_lookup_key', 'xyz987')
   end
 
   def test_ff_get_with_lookup_key
-    assert_nil @client.get("in_lookup_key", "jimmy")
-    assert_equal "DEFAULT", @client.get("in_lookup_key", "jimmy", {}, "DEFAULT")
+    assert_nil @client.get('in_lookup_key', 'jimmy')
+    assert_equal 'DEFAULT', @client.get('in_lookup_key', 'jimmy', {}, 'DEFAULT')
 
-    assert_equal true, @client.get("in_lookup_key", "abc123")
-    assert_equal true, @client.get("in_lookup_key", "xyz987")
+    assert_equal true, @client.get('in_lookup_key', 'abc123')
+    assert_equal true, @client.get('in_lookup_key', 'xyz987')
   end
 
   def test_ff_enabled_with_attributes
-    assert_equal false, @client.enabled?("just_my_domain", "abc123", { domain: "gmail.com" })
-    assert_equal false, @client.enabled?("just_my_domain", "abc123", { domain: "prefab.cloud" })
-    assert_equal false, @client.enabled?("just_my_domain", "abc123", { domain: "example.com" })
+    assert_equal false, @client.enabled?('just_my_domain', 'abc123', { domain: 'gmail.com' })
+    assert_equal false, @client.enabled?('just_my_domain', 'abc123', { domain: 'prefab.cloud' })
+    assert_equal false, @client.enabled?('just_my_domain', 'abc123', { domain: 'example.com' })
   end
 
   def test_ff_get_with_attributes
-    assert_nil @client.get("just_my_domain", "abc123", { domain: "gmail.com" })
-    assert_equal "DEFAULT", @client.get("just_my_domain", "abc123", { domain: "gmail.com" }, "DEFAULT")
+    assert_nil @client.get('just_my_domain', 'abc123', { domain: 'gmail.com' })
+    assert_equal 'DEFAULT', @client.get('just_my_domain', 'abc123', { domain: 'gmail.com' }, 'DEFAULT')
 
-    assert_equal "new-version", @client.get("just_my_domain", "abc123", { domain: "prefab.cloud" })
-    assert_equal "new-version", @client.get("just_my_domain", "abc123", { domain: "example.com" })
+    assert_equal 'new-version', @client.get('just_my_domain', 'abc123', { domain: 'prefab.cloud' })
+    assert_equal 'new-version', @client.get('just_my_domain', 'abc123', { domain: 'example.com' })
   end
 
   def test_getting_feature_flag_value
-    assert_equal false, @client.enabled?("flag_with_a_value")
-    assert_equal "all-features", @client.get("flag_with_a_value")
+    assert_equal false, @client.enabled?('flag_with_a_value')
+    assert_equal 'all-features', @client.get('flag_with_a_value')
   end
 
   def test_ssl_certs
-    certs = @client.send(:ssl_certs).split("-----BEGIN CERTIFICATE-----")
+    certs = @client.send(:ssl_certs).split('-----BEGIN CERTIFICATE-----')
 
     # This is a smoke test to make sure multiple certs are loaded
     assert certs.length > 1
   end
 
+  def test_initialization_with_an_options_object
+    options_hash = {
+      namespace: 'test-namespace',
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    }
+
+    options = Prefab::Options.new(options_hash)
+
+    client = Prefab::Client.new(options)
+
+    assert_equal client.namespace, 'test-namespace'
+  end
+
+  def test_initialization_with_a_hash
+    options_hash = {
+      namespace: 'test-namespace',
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    }
+
+    client = Prefab::Client.new(options_hash)
+
+    assert_equal client.namespace, 'test-namespace'
+  end
+
   private
 
   def new_client(overrides = {})
     options = Prefab::Options.new(**{
-      prefab_config_override_dir: "none",
-      prefab_config_classpath_dir: "test",
-      prefab_envs: ["unit_tests"],
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: ['unit_tests'],
       prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
     }.merge(overrides))
 

data/test/test_config_client.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 
 class TestConfigClient < Minitest::Test
   def setup
     options = Prefab::Options.new(
-      prefab_config_override_dir: "none",
-      prefab_config_classpath_dir: "test",
-      prefab_envs: "unit_tests",
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: 'unit_tests',
       prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
     )
 
@@ -14,59 +15,59 @@ class TestConfigClient < Minitest::Test
   end
 
   def test_load
-    assert_equal "test sample value", @config_client.get("sample")
-    assert_equal 123, @config_client.get("sample_int")
-    assert_equal 12.12, @config_client.get("sample_double")
-    assert_equal true, @config_client.get("sample_bool")
-    assert_equal :ERROR, @config_client.get("log-level.app")
+    assert_equal 'test sample value', @config_client.get('sample')
+    assert_equal 123, @config_client.get('sample_int')
+    assert_equal 12.12, @config_client.get('sample_double')
+    assert_equal true, @config_client.get('sample_bool')
+    assert_equal :ERROR, @config_client.get('log-level.app')
   end
 
   def test_initialization_timeout_error
     options = Prefab::Options.new(
-      api_key: "123-ENV-KEY-SDK",
+      api_key: '123-ENV-KEY-SDK',
       initialization_timeout_sec: 0.01,
       logdev: StringIO.new
     )
 
     err = assert_raises(Prefab::Errors::InitializationTimeoutError) do
-      Prefab::Client.new(options).config_client.get("anything")
+      Prefab::Client.new(options).config_client.get('anything')
     end
 
     assert_match(/couldn't initialize in 0.01 second timeout/, err.message)
   end
 
   def test_prefab_envs_is_forgiving
-    assert_equal ["my_env"], Prefab::Options.new(
-      prefab_envs: "my_env",
+    assert_equal ['my_env'], Prefab::Options.new(
+      prefab_envs: 'my_env'
     ).prefab_envs
 
-    assert_equal ["my_env", "a_second_env"], Prefab::Options.new(
-      prefab_envs: ["my_env", "a_second_env"],
+    assert_equal %w[my_env a_second_env], Prefab::Options.new(
+      prefab_envs: %w[my_env a_second_env]
     ).prefab_envs
   end
 
   def test_prefab_envs_env_var
-    ENV["PREFAB_ENVS"] = "one,two"
-    assert_equal ["one", "two"], Prefab::Options.new().prefab_envs
+    ENV['PREFAB_ENVS'] = 'one,two'
+    assert_equal %w[one two], Prefab::Options.new.prefab_envs
   end
 
   def test_invalid_api_key_error
     options = Prefab::Options.new(
-      api_key: "",
+      api_key: ''
     )
 
     err = assert_raises(Prefab::Errors::InvalidApiKeyError) do
-      Prefab::Client.new(options).config_client.get("anything")
+      Prefab::Client.new(options).config_client.get('anything')
     end
 
     assert_match(/No API key/, err.message)
 
     options = Prefab::Options.new(
-      api_key: "invalid",
+      api_key: 'invalid'
     )
 
     err = assert_raises(Prefab::Errors::InvalidApiKeyError) do
-      Prefab::Client.new(options).config_client.get("anything")
+      Prefab::Client.new(options).config_client.get('anything')
     end
 
     assert_match(/format is invalid/, err.message)

data/test/test_config_loader.rb

@@ -1,83 +1,90 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 
 class TestConfigLoader < Minitest::Test
   def setup
     options = Prefab::Options.new(
-      prefab_config_override_dir: "none",
-      prefab_config_classpath_dir: "test",
-      prefab_envs: "unit_tests"
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: 'unit_tests'
     )
     @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
   end
 
   def test_load
-    should_be :int, 123, "sample_int"
-    should_be :string, "test sample value", "sample"
-    should_be :bool, true, "sample_bool"
-    should_be :double, 12.12, "sample_double"
+    should_be :int, 123, 'sample_int'
+    should_be :string, 'test sample value', 'sample'
+    should_be :bool, true, 'sample_bool'
+    should_be :double, 12.12, 'sample_double'
   end
 
   def test_nested
-    should_be :string, "nested value", "nested.values.string"
-    should_be :string, "top level", "nested.values"
-    should_be :log_level, :ERROR, "log-level.app"
-    should_be :log_level, :WARN, "log-level.app.controller.hello"
-    should_be :log_level, :INFO, "log-level.app.controller.hello.index"
+    should_be :string, 'nested value', 'nested.values.string'
+    should_be :string, 'top level', 'nested.values'
+    should_be :log_level, :ERROR, 'log-level.app'
+    should_be :log_level, :WARN, 'log-level.app.controller.hello'
+    should_be :log_level, :INFO, 'log-level.app.controller.hello.index'
   end
 
   def test_invalid_log_level
-    should_be :log_level, :NOT_SET_LOG_LEVEL, "log-level.invalid"
+    should_be :log_level, :NOT_SET_LOG_LEVEL, 'log-level.invalid'
   end
 
   def test_load_without_unit_test_env
     options = Prefab::Options.new(
-      prefab_config_override_dir: "none",
-      prefab_config_classpath_dir: "test",
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test'
       # no prefab_envs
     )
     @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
-    should_be :string, "default sample value", "sample"
-    should_be :bool, true, "sample_bool"
+    should_be :string, 'default sample value', 'sample'
+    should_be :bool, true, 'sample_bool'
   end
 
   def test_highwater
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
+    @loader.set(Prefab::Config.new(id: 1, key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 456))]),
+                'test')
     assert_equal 1, @loader.highwater_mark
 
-    @loader.set(Prefab::Config.new(id: 5, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
+    @loader.set(Prefab::Config.new(id: 5, key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 456))]),
+                'test')
     assert_equal 5, @loader.highwater_mark
-    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
+    @loader.set(Prefab::Config.new(id: 2, key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 456))]),
+                'test')
     assert_equal 5, @loader.highwater_mark
   end
 
   def test_keeps_most_recent
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 1))]),"test")
+    @loader.set(Prefab::Config.new(id: 1, key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 1))]),
+                'test')
     assert_equal 1, @loader.highwater_mark
-    should_be :int, 1, "sample_int"
+    should_be :int, 1, 'sample_int'
 
-    @loader.set(Prefab::Config.new(id: 4, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 4))]),"test")
+    @loader.set(Prefab::Config.new(id: 4, key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 4))]),
+                'test')
     assert_equal 4, @loader.highwater_mark
-    should_be :int, 4, "sample_int"
+    should_be :int, 4, 'sample_int'
 
-    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 2))]),"test")
+    @loader.set(Prefab::Config.new(id: 2, key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 2))]),
+                'test')
     assert_equal 4, @loader.highwater_mark
-    should_be :int, 4, "sample_int"
+    should_be :int, 4, 'sample_int'
   end
 
   def test_api_precedence
-    should_be :int, 123, "sample_int"
+    should_be :int, 123, 'sample_int'
 
-    @loader.set(Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]), "test")
-    should_be :int, 456, "sample_int"
+    @loader.set(Prefab::Config.new(key: 'sample_int', rows: [config_row(Prefab::ConfigValue.new(int: 456))]), 'test')
+    should_be :int, 456, 'sample_int'
   end
 
   def test_api_deltas
     val = Prefab::ConfigValue.new(int: 456)
-    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
-    @loader.set(config, "test")
+    config = Prefab::Config.new(key: 'sample_int', rows: [config_row(val)])
+    @loader.set(config, 'test')
 
     configs = Prefab::Configs.new
     configs.configs << config
@@ -86,11 +93,11 @@ class TestConfigLoader < Minitest::Test
 
   def test_loading_tombstones_removes_entries
     val = Prefab::ConfigValue.new(int: 456)
-    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)], id: 2)
-    @loader.set(config, "test")
+    config = Prefab::Config.new(key: 'sample_int', rows: [config_row(val)], id: 2)
+    @loader.set(config, 'test')
 
-    config = Prefab::Config.new(key: "sample_int", rows: [], id: 3)
-    @loader.set(config, "test")
+    config = Prefab::Config.new(key: 'sample_int', rows: [], id: 3)
+    @loader.set(config, 'test')
 
     configs = Prefab::Configs.new
     assert_equal configs, @loader.get_api_deltas
@@ -99,7 +106,11 @@ class TestConfigLoader < Minitest::Test
   private
 
   def should_be(type, value, key)
-    assert_equal type, @loader.calc_config[key][:config].rows[0].value.type
-    assert_equal value, @loader.calc_config[key][:config].rows[0].value.send(type)
+    assert_equal type, @loader.calc_config[key][:config].rows[0].values[0].value.type
+    assert_equal value, @loader.calc_config[key][:config].rows[0].values[0].value.send(type)
+  end
+
+  def config_row(value)
+    Prefab::ConfigRow.new(values: [Prefab::ConditionalValue.new(value: value)])
   end
 end