prefab-cloud-ruby 1.2.1 → 1.3.0

data/lib/prefab/log_subscribers/action_controller_subscriber.rb

@@ -0,0 +1,54 @@
+# Modified from https://github.com/reidmorrison/rails_semantic_logger/blob/master/lib/rails_semantic_logger/action_controller/log_subscriber.rb
+#
+# Copyright 2012, 2013, 2014, 2015 Reid Morrison
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+module Prefab
+  module LogSubscribers
+    class ActionControllerSubscriber < ActiveSupport::LogSubscriber
+
+      INTERNAL_PARAMS = %w[controller action format _method only_path].freeze
+
+      LOG = Prefab::StaticLogger.new("rails.controller.request")
+
+      # With great debt to https://github.com/reidmorrison/rails_semantic_logger/blob/master/lib/rails_semantic_logger/action_controller/log_subscriber.rb
+      def process_action(event)
+        payload = event.payload.dup
+        payload.delete(:headers)
+        payload.delete(:request)
+        payload.delete(:response)
+        params = payload[:params]
+
+        if params.kind_of?(Hash) || params.kind_of?(::ActionController::Parameters)
+          payload[:params] = params.to_unsafe_h unless params.is_a?(Hash)
+          payload[:params] = params.except(*INTERNAL_PARAMS)
+
+          if payload[:params].empty?
+            payload.delete(:params)
+          elsif params["file"]
+            # When logging to JSON the entire tempfile is logged, so convert it to a string.
+            payload[:params]["file"] = params["file"].inspect
+          end
+        end
+
+        # Rounds off the runtimes. For example, :view_runtime, :mongo_runtime, etc.
+        payload.keys.each do |key|
+          payload[key] = payload[key].to_f.round(2) if key.to_s =~ /(.*)_runtime/
+        end
+
+        LOG.info "#{payload[:status]} #{payload[:controller]}##{payload[:action]}", **payload
+      end
+    end
+  end
+end

data/lib/prefab/logger_client.rb

@@ -5,7 +5,6 @@ module Prefab
     SEP = '.'
     BASE_KEY = 'log-level'
     UNKNOWN_PATH = 'unknown.'
-    INTERNAL_PREFIX = 'cloud.prefab.client'
 
     LOG_LEVEL_LOOKUPS = {
       PrefabProto::LogLevel::NOT_SET_LOG_LEVEL => ::Logger::DEBUG,
@@ -65,12 +64,6 @@ module Prefab
     def log_internal(severity, message, path, log_context={}, &block)
       return if @recurse_check[local_log_id]
       @recurse_check[local_log_id] = true
-
-      path = if path
-               "#{INTERNAL_PREFIX}.#{path}"
-             else
-               INTERNAL_PREFIX
-             end
       begin
         log(message, path, nil, severity, log_context, &block)
       ensure

data/lib/prefab/options.rb

@@ -17,6 +17,8 @@ module Prefab
     attr_reader :prefab_envs
     attr_reader :collect_sync_interval
     attr_reader :use_local_cache
+    attr_reader :datafile
+    attr_reader :disable_action_controller_logging
     attr_accessor :is_fork
 
     DEFAULT_LOG_FORMATTER = proc { |data|
@@ -82,7 +84,9 @@ module Prefab
       collect_evaluation_summaries: true,
       collect_max_evaluation_summaries: DEFAULT_MAX_EVAL_SUMMARIES,
       allow_telemetry_in_local_mode: false,
-      x_use_local_cache: false
+      x_datafile: ENV['PREFAB_DATAFILE'],
+      x_use_local_cache: false,
+      disable_action_controller_logging: false
     )
       @api_key = api_key
       @logdev = logdev
@@ -94,6 +98,7 @@ module Prefab
       @initialization_timeout_sec = initialization_timeout_sec
       @on_init_failure = on_init_failure
       @prefab_datasources = prefab_datasources
+      @datafile = x_datafile
       @prefab_config_classpath_dir = prefab_config_classpath_dir
       @prefab_config_override_dir = prefab_config_override_dir
       @prefab_envs = Array(prefab_envs)
@@ -104,6 +109,7 @@ module Prefab
       @collect_max_evaluation_summaries = collect_max_evaluation_summaries
       @allow_telemetry_in_local_mode = allow_telemetry_in_local_mode
       @use_local_cache = x_use_local_cache
+      @disable_action_controller_logging = disable_action_controller_logging
       @is_fork = false
 
       # defaults that may be overridden by context_upload_mode
@@ -134,6 +140,10 @@ module Prefab
       @prefab_datasources == DATASOURCES::LOCAL_ONLY
     end
 
+    def datafile?
+      !@datafile.nil?
+    end
+
     def collect_max_paths
       return 0 unless telemetry_allowed?(@collect_logger_counts)
 

data/lib/prefab/resolved_config_presenter.rb

@@ -44,7 +44,7 @@ module Prefab
             if v.nil?
               hash[k] = ConfigRow.new(k, nil, nil, nil)
             else
-              value = @resolver.evaluate(v[:config])&.unwrapped_value
+              value = @resolver.evaluate(v[:config])&.reportable_value
               hash[k] = ConfigRow.new(k, value, v[:match], v[:source])
             end
           end
@@ -65,7 +65,7 @@ module Prefab
             if v.nil?
               elements << 'tombstone'
             else
-              value = @resolver.evaluate(v[:config])&.unwrapped_value
+              value = @resolver.evaluate(v[:config])&.reportable_value
               elements << value.to_s.slice(0..34).ljust(35)
               elements << value.class.to_s.slice(0..6).ljust(7)
               elements << "Match: #{v[:match]}".slice(0..29).ljust(30)

data/lib/prefab/sse_logger.rb

@@ -1,30 +1,14 @@
 # frozen_string_literal: true
 
 module Prefab
-  class SseLogger < ::Logger
+  class SseLogger < InternalLogger
     def initialize()
-      @path = "sse"
-    end
-
-    def debug(progname = nil, &block)
-      Prefab::LoggerClient.instance.log_internal ::Logger::DEBUG, progname, @path, &block
-    end
-
-    def info(progname = nil, &block)
-      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, progname, @path, &block
+      super("sse")
     end
 
     # The SSE::Client warns on a perfectly normal stream disconnect, recast to info
-    def warn(progname = nil, &block)
-      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, progname, @path, &block
-    end
-
-    def error(progname = nil, &block)
-      Prefab::LoggerClient.instance.log_internal ::Logger::ERROR, progname, @path, &block
-    end
-
-    def fatal(progname = nil, &block)
-      Prefab::LoggerClient.instance.log_internal ::Logger::FATAL, progname, @path, &block
+    def warn(msg = nil,**log_context,  &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, msg, @path, log_context, &block
     end
   end
 end

data/lib/prefab/static_logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Prefab
+  class StaticLogger < ::Logger
+    def initialize(path)
+      @path = path
+    end
+
+    def debug(msg = nil, **log_context, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::DEBUG, msg, @path, log_context, &block
+    end
+
+    def info(msg = nil, **log_context, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::INFO, msg, @path, log_context, &block
+    end
+
+    def warn(msg = nil, **log_context, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::WARN, msg, @path, log_context, &block
+    end
+
+    def error(msg = nil, **log_context, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::ERROR, msg, @path, log_context, &block
+    end
+
+    def fatal(msg = nil, **log_context, &block)
+      Prefab::LoggerClient.instance.log_internal ::Logger::FATAL, msg, @path, log_context, &block
+    end
+  end
+end

data/lib/prefab-cloud-ruby.rb

@@ -14,11 +14,14 @@ require 'prefab_pb'
 require 'prefab/time_helpers'
 require 'prefab/error'
 require 'prefab/evaluation'
+require 'prefab/encryption'
 require 'prefab/exponential_backoff'
 require 'prefab/errors/initialization_timeout_error'
 require 'prefab/errors/invalid_api_key_error'
 require 'prefab/errors/missing_default_error'
+require 'prefab/errors/env_var_parse_error'
 require 'prefab/options'
+require 'prefab/static_logger'
 require 'prefab/internal_logger'
 require 'prefab/rate_limit_cache'
 require 'prefab/context_shape_aggregator'
@@ -39,6 +42,9 @@ require 'prefab/config_resolver'
 require 'prefab/http_connection'
 require 'prefab/context'
 require 'prefab/logger_client'
+require 'active_support/deprecation'
+require 'active_support'
+require 'prefab/log_subscribers/action_controller_subscriber'
 require 'prefab/client'
 require 'prefab/config_client_presenter'
 require 'prefab/config_client'

data/prefab-cloud-ruby.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: prefab-cloud-ruby 1.2.1 ruby lib
+# stub: prefab-cloud-ruby 1.3.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "1.2.1"
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2023-11-01"
+  s.date = "2023-11-13"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.executables = ["console".freeze]
@@ -48,7 +48,9 @@ Gem::Specification.new do |s|
     "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",
@@ -61,6 +63,7 @@ Gem::Specification.new do |s|
     "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",
@@ -69,6 +72,7 @@ Gem::Specification.new do |s|
     "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",
@@ -82,6 +86,7 @@ Gem::Specification.new do |s|
     "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",
@@ -92,6 +97,7 @@ Gem::Specification.new do |s|
     "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",
@@ -123,6 +129,7 @@ Gem::Specification.new do |s|
     s.add_runtime_dependency(%q<google-protobuf>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<ld-eventsource>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<uuid>.freeze, [">= 0"])
+    s.add_runtime_dependency(%q<activesupport>.freeze, [">= 4"])
     s.add_development_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])
@@ -135,6 +142,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<google-protobuf>.freeze, [">= 0"])
     s.add_dependency(%q<ld-eventsource>.freeze, [">= 0"])
     s.add_dependency(%q<uuid>.freeze, [">= 0"])
+    s.add_dependency(%q<activesupport>.freeze, [">= 4"])
     s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])

data/test/test_action_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestActionController < Minitest::Test
+  def setup
+    super
+    new_client(config: log_level_config("log-level.rails.controller", "INFO"))
+    @subscriber = Prefab::LogSubscribers::ActionControllerSubscriber.new
+  end
+
+  def test_load
+    @subscriber.process_action(event)
+    assert_logged ['INFO  2023-08-09 15:18:12 -0400: rails.controller.request 200 MyController#index action=index controller=MyController db_runtime=0.05 format=application/html method=GET params={"p1"=>"v1"} path=/my?p1=v1 status=200 view_runtime=0.02']
+  end
+
+
+  def event
+    ActiveSupport::Notifications::Event.new(
+      'process_action.action_controller',
+      Time.now,
+      Time.now,
+      99,
+      status: 200,
+      controller: 'MyController',
+      action: 'index',
+      format: 'application/html',
+      method: 'GET',
+      path: '/my?p1=v1',
+      params: { 'p1' => 'v1' },
+      db_runtime: 0.051123,
+      view_runtime: 0.024555
+    )
+  end
+
+  def log_level_config(path, level)
+      PrefabProto::Config.new(
+        id: 123,
+        key: path,
+        config_type: PrefabProto::ConfigType::LOG_LEVEL,
+        rows: [
+          PrefabProto::ConfigRow.new(
+            values: [
+              PrefabProto::ConditionalValue.new(
+                value: PrefabProto::ConfigValue.new(log_level: level)
+              )
+            ]
+          )
+        ]
+      )
+  end
+end

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,7 +36,6 @@ 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
-    #this removes provided for now
     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|

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