prefab-cloud-ruby 1.2.0 → 1.3.0

data/test/test_config_value_unwrapper.rb

@@ -3,72 +3,219 @@
 require 'test_helper'
 
 class TestConfigValueUnwrapper < Minitest::Test
-  CONFIG_KEY = 'config_key'
+  CONFIG = PrefabProto::Config.new(
+    key: 'config_key'
+  )
   EMPTY_CONTEXT = Prefab::Context.new()
+  DECRYPTION_KEY_NAME = "decryption.key"
+  DECRYPTION_KEY_VALUE = Prefab::Encryption.generate_new_hex_key
+
+  def setup
+    super
+    @mock_resolver = MockResolver.new
+  end
 
   def test_unwrapping_int
     config_value = PrefabProto::ConfigValue.new(int: 123)
-    assert_equal 123, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 123, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string
     config_value = PrefabProto::ConfigValue.new(string: 'abc')
-    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 'abc', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    assert_equal 'abc', reportable_value(config_value, CONFIG, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_double
     config_value = PrefabProto::ConfigValue.new(double: 1.23)
-    assert_equal 1.23, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 1.23, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_bool
     config_value = PrefabProto::ConfigValue.new(bool: true)
-    assert_equal true, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal true, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
 
     config_value = PrefabProto::ConfigValue.new(bool: false)
-    assert_equal false, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal false, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_log_level
     config_value = PrefabProto::ConfigValue.new(log_level: :INFO)
-    assert_equal :INFO, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal :INFO, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string_list
     config_value = PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: %w[a b c]))
-    assert_equal %w[a b c], unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal %w[a b c], unwrap(config_value, CONFIG, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_weighted_values
     # single value
     config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
 
-    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 'abc', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
 
     # multiple values, evenly distributed
     config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
-    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:000'))
-    assert_equal 'ghi', unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
-    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
-    assert_equal 'ghi', unwrap(config_value, CONFIG_KEY, context_with_key('user:888'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:000'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:456'))
+    assert_equal 'abc', unwrap(config_value, CONFIG, context_with_key('user:789'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:888'))
 
     # multiple values, unevenly distributed
     config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 99], ['ghi', 1]]))
-    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:123'))
-    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
-    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
-    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:012'))
-    assert_equal 'ghi', unwrap(config_value, CONFIG_KEY, context_with_key('user:428'))
-    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, context_with_key('user:548'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:123'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:456'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:789'))
+    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:012'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:428'))
+    assert_equal 'abc', unwrap(config_value, CONFIG, context_with_key('user:548'))
+  end
+
+  def test_unwrapping_provided_values
+    with_env('ENV_VAR_NAME', 'unit test value')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+      assert_equal 'unit test value', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_provided_values_of_type_string_list
+    with_env('ENV_VAR_NAME', '["bob","cary"]')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+      assert_equal ["bob", "cary"], unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_provided_values_coerces_to_int
+    with_env('ENV_VAR_NAME', '42')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+      assert_equal 42,  unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
+    end
+  end
+
+  def test_unwrapping_provided_values_when_value_type_mismatch
+    with_env('ENV_VAR_NAME', 'not an int')do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "ENV_VAR_NAME"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value)
+
+      assert_raises Prefab::Errors::EnvVarParseError do
+        unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
+      end
+    end
+  end
+
+  def test_coerce
+    assert_equal "string", Prefab::ConfigValueUnwrapper.coerce_into_type("string", CONFIG, "ENV")
+    assert_equal 42, Prefab::ConfigValueUnwrapper.coerce_into_type("42", CONFIG, "ENV")
+    assert_equal false, Prefab::ConfigValueUnwrapper.coerce_into_type("false", CONFIG, "ENV")
+    assert_equal 42.42, Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", CONFIG, "ENV")
+    assert_equal ["a","b"], Prefab::ConfigValueUnwrapper.coerce_into_type("['a','b']", CONFIG, "ENV")
+
+    assert_equal "string", Prefab::ConfigValueUnwrapper.coerce_into_type("string", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal "42", Prefab::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal "42.42", Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
+    assert_equal 42, Prefab::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::INT),"ENV")
+    assert_equal false, Prefab::ConfigValueUnwrapper.coerce_into_type("false", config_of(PrefabProto::Config::ValueType::BOOL),"ENV")
+    assert_equal 42.42, Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::DOUBLE),"ENV")
+    assert_equal ["a","b"], Prefab::ConfigValueUnwrapper.coerce_into_type("['a','b']", config_of(PrefabProto::Config::ValueType::STRING_LIST),"ENV")
+
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not an int", config_of(PrefabProto::Config::ValueType::INT), "ENV")
+    end
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not bool", config_of(PrefabProto::Config::ValueType::BOOL), "ENV")
+    end
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not a double", config_of(PrefabProto::Config::ValueType::DOUBLE), "ENV")
+    end
+    assert_raises Prefab::Errors::EnvVarParseError do
+      Prefab::ConfigValueUnwrapper.coerce_into_type("not a list", config_of(PrefabProto::Config::ValueType::STRING_LIST), "ENV")
+    end
+  end
+
+  def test_unwrapping_provided_values_with_missing_env_var
+    value = PrefabProto::Provided.new(
+      source: :ENV_VAR,
+      lookup: "NON_EXISTENT_ENV_VAR_NAME"
+    )
+    config_value = PrefabProto::ConfigValue.new(provided: value)
+    assert_equal '', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_unwrapping_encrypted_values_decrypts
+    clear_text = "very secret stuff"
+    encrypted = Prefab::Encryption.new(DECRYPTION_KEY_VALUE).encrypt(clear_text)
+    config_value = PrefabProto::ConfigValue.new(string: encrypted, decrypt_with: "decryption.key")
+    assert_equal clear_text, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+  end
+
+  def test_confidential
+    config_value = PrefabProto::ConfigValue.new(confidential: true, string: "something confidential")
+    assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+  end
+
+  def test_unwrap_confiential_provided
+    with_env('PAAS_PASSWORD', "the password")do
+      value = PrefabProto::Provided.new(
+        source: :ENV_VAR,
+        lookup: "PAAS_PASSWORD"
+      )
+      config_value = PrefabProto::ConfigValue.new(provided: value, confidential: true)
+      assert_equal "the password", unwrap(config_value, CONFIG, EMPTY_CONTEXT)
+      assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+    end
   end
 
   private
 
+  def config_of(value_type)
+    PrefabProto::Config.new(
+      key: 'config-key',
+      value_type: value_type
+    )
+  end
+
   def context_with_key(key)
     Prefab::Context.new(user: { key: key })
   end
 
   def unwrap(config_value, config_key, context)
-    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context).unwrap
+    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).unwrap
+  end
+
+  def reportable_value(config_value, config_key, context)
+    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).reportable_value
+  end
+
+  class MockResolver
+    def get(key)
+      if DECRYPTION_KEY_NAME == key
+        Prefab::Evaluation.new(config: PrefabProto::Config.new(key: key),
+                               value: PrefabProto::ConfigValue.new(string: DECRYPTION_KEY_VALUE),
+                                value_index: 0,
+                                config_row_index: 0,
+                                context: Prefab::Context.new,
+                                resolver: self
+        )
+
+      else
+        raise "unexpected key"
+      end
+    end
   end
 end

data/test/test_context_shape.rb

@@ -36,12 +36,11 @@ class TestContextShape < Minitest::Test
 
   # If this test fails, it means that we've added a new type to the ConfigValue
   def test_mapping_is_exhaustive
-    unsupported = [:bytes, :limit_definition, :log_level, :weighted_values, :int_range]
-
-    supported = PrefabProto::ConfigValue.descriptor.entries.reject do |entry|
+    unsupported = [:bytes, :limit_definition, :log_level, :weighted_values, :int_range, :provided]
+    type_fields = PrefabProto::ConfigValue.descriptor.lookup_oneof("type").entries
+    supported = type_fields.entries.reject do |entry|
       unsupported.include?(entry.name.to_sym)
     end.map(&:number)
-
     mapped = Prefab::ContextShape::MAPPING.values.uniq
 
     unless mapped == supported

data/test/test_encryption.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEncryption < Minitest::Test
+  def test_encryption
+    secret = Prefab::Encryption.generate_new_hex_key
+
+    enc = Prefab::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_local_config_parser.rb

@@ -6,6 +6,11 @@ class TestLocalConfigParser < Minitest::Test
   FILE_NAME = 'example-config.yaml'
   DEFAULT_MATCH = 'default'
 
+  def setup
+    super
+    @mock_resolver = MockResolver.new
+  end
+
   def test_parse_int_config
     key = :sample_int
     parsed = Prefab::LocalConfigParser.parse(key, 123, {}, FILE_NAME)[key]
@@ -34,7 +39,7 @@ class TestLocalConfigParser < Minitest::Test
     assert_equal 1, config.rows[0].values.size
 
     value_row = config.rows[0].values[0]
-    assert_equal 'all-features', Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}).unwrap
+    assert_equal 'all-features', Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}, @mock_resolver).unwrap
   end
 
   def test_flag_in_user_key
@@ -53,13 +58,73 @@ class TestLocalConfigParser < Minitest::Test
     assert_equal 1, config.rows[0].values[0].criteria.size
 
     value_row = config.rows[0].values[0]
-    assert_equal true, Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}).unwrap
+    assert_equal true, Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, key, {}, @mock_resolver).unwrap
 
     assert_equal 'user.key', value_row.criteria[0].property_name
     assert_equal :PROP_IS_ONE_OF, value_row.criteria[0].operator
     assert_equal %w[abc123 xyz987], value_row.criteria[0].value_to_match.string_list.values
   end
 
+  def test_provided_values
+    with_env('LOOKUP_ENV', 'from env') do 
+      key = :test_provided
+      value = stringify_keys({type: 'provided', source: 'ENV_VAR', lookup: 'LOOKUP_ENV'})
+      parsed = Prefab::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+      config = parsed[:config]
+
+      assert_equal FILE_NAME, parsed[:source]
+      assert_equal 'LOOKUP_ENV', parsed[:match]
+      assert_equal :CONFIG, config.config_type
+      assert_equal key.to_s, config.key
+      assert_equal 1, config.rows.size
+      assert_equal 1, config.rows[0].values.size
+      
+      value_row = config.rows[0].values[0]            
+      provided = value_row.value.provided
+      assert_equal :ENV_VAR, provided.source
+      assert_equal 'LOOKUP_ENV', provided.lookup
+      assert_equal 'from env', Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).unwrap
+      reportable_value = Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).reportable_value
+      assert_equal 'from env', reportable_value
+    end
+  end
+
+  def test_confidential_provided_values
+    with_env('LOOKUP_ENV', 'from env') do
+      key = :test_provided
+      value = stringify_keys({type: 'provided', source: 'ENV_VAR', lookup: 'LOOKUP_ENV', confidential: true})
+      parsed = Prefab::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+      config = parsed[:config]
+
+      value_row = config.rows[0].values[0]
+      provided = value_row.value.provided
+      assert_equal :ENV_VAR, provided.source
+      assert_equal 'LOOKUP_ENV', provided.lookup
+      assert_equal 'from env', Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).unwrap
+      reportable_value = Prefab::ConfigValueUnwrapper.deepest_value(value_row.value, config, {}, @mock_resolver).reportable_value
+      assert reportable_value.start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+    end
+  end
+
+  def test_confidential_values
+    key = :test_confidential
+    value = stringify_keys({value: 'a confidential string', confidential: true})
+    parsed = Prefab::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal :CONFIG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+
+    value_row = config.rows[0].values[0]
+    config_value = value_row.value
+    assert_equal 'a confidential string', Prefab::ConfigValueUnwrapper.deepest_value(config_value, key, {}, @mock_resolver).unwrap
+    reportable_value = Prefab::ConfigValueUnwrapper.deepest_value(config_value, key, {}, @mock_resolver).reportable_value
+    assert reportable_value.start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
+  end
+
   private
 
   def stringify_keys(hash)
@@ -73,4 +138,10 @@ class TestLocalConfigParser < Minitest::Test
     end
     result
   end
+
+  class MockResolver
+    def get(key)
+      raise "unexpected key"
+    end
+  end
 end

data/test/test_logger.rb

@@ -87,22 +87,22 @@ class TestLogger < Minitest::Test
 
   def test_log_internal
     prefab, io = captured_logger
-    prefab.log.log_internal(::Logger::WARN, 'test message', 'test.path')
+    prefab.log.log_internal(::Logger::WARN, 'test message', 'cloud.prefab.client.test.path')
     assert_logged io, 'WARN', "cloud.prefab.client.test.path", "test message"
   end
 
   def test_log_internal_unknown
     prefab, io = captured_logger
-    prefab.log.log_internal(::Logger::UNKNOWN, 'test message', 'test.path')
+    prefab.log.log_internal(::Logger::UNKNOWN, 'test message', 'cloud.prefab.client.test.path')
     assert_logged io, 'ANY', "cloud.prefab.client.test.path", "test message"
   end
 
   def test_log_internal_silencing
     prefab, io = captured_logger
     prefab.log.silence do
-      prefab.log.log_internal(::Logger::WARN, 'should not log', 'test.path')
+      prefab.log.log_internal(::Logger::WARN, 'should not log', 'cloud.prefab.client.test.path')
     end
-    prefab.log.log_internal(::Logger::WARN, 'should log', 'test.path')
+    prefab.log.log_internal(::Logger::WARN, 'should log', 'cloud.prefab.client.test.path')
     assert_logged io, 'WARN', "cloud.prefab.client.test.path", "should log"
     refute_logged io, 'should not log'
   end
@@ -457,7 +457,7 @@ class TestLogger < Minitest::Test
   def test_structured_internal_logging
     prefab, io = captured_logger
 
-    prefab.log.log_internal(::Logger::WARN, 'test', 'test.path', user: "michael")
+    prefab.log.log_internal(::Logger::WARN, 'test', 'cloud.prefab.client.test.path', user: "michael")
 
     assert_logged io, 'WARN', 'cloud.prefab.client.test.path', "test user=michael"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-30 00:00:00.000000000 Z
+date: 2023-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -100,6 +100,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -207,7 +221,9 @@ files:
 - lib/prefab/context_shape.rb
 - lib/prefab/context_shape_aggregator.rb
 - lib/prefab/criteria_evaluator.rb
+- lib/prefab/encryption.rb
 - lib/prefab/error.rb
+- lib/prefab/errors/env_var_parse_error.rb
 - lib/prefab/errors/initialization_timeout_error.rb
 - lib/prefab/errors/invalid_api_key_error.rb
 - lib/prefab/errors/missing_default_error.rb
@@ -220,6 +236,7 @@ files:
 - lib/prefab/internal_logger.rb
 - lib/prefab/local_config_parser.rb
 - lib/prefab/log_path_aggregator.rb
+- lib/prefab/log_subscribers/action_controller_subscriber.rb
 - lib/prefab/logger_client.rb
 - lib/prefab/murmer3.rb
 - lib/prefab/options.rb
@@ -228,6 +245,7 @@ files:
 - lib/prefab/rate_limit_cache.rb
 - lib/prefab/resolved_config_presenter.rb
 - lib/prefab/sse_logger.rb
+- lib/prefab/static_logger.rb
 - lib/prefab/time_helpers.rb
 - lib/prefab/weighted_value_resolver.rb
 - lib/prefab/yaml_config_parser.rb
@@ -241,6 +259,7 @@ files:
 - test/support/mock_base_client.rb
 - test/support/mock_config_client.rb
 - test/support/mock_config_loader.rb
+- test/test_action_controller.rb
 - test/test_client.rb
 - test/test_config_client.rb
 - test/test_config_loader.rb
@@ -251,6 +270,7 @@ files:
 - test/test_context_shape.rb
 - test/test_context_shape_aggregator.rb
 - test/test_criteria_evaluator.rb
+- test/test_encryption.rb
 - test/test_evaluation_summary_aggregator.rb
 - test/test_example_contexts_aggregator.rb
 - test/test_exponential_backoff.rb