prefab-cloud-ruby 0.13.0 → 0.13.1

data/lib/prefab_services_pb.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # Source: prefab.proto for package 'prefab'
 
@@ -9,13 +8,13 @@ module Prefab
   module RateLimitService
     class Service
 
-      include ::GRPC::GenericService
+      include GRPC::GenericService
 
       self.marshal_class_method = :encode
       self.unmarshal_class_method = :decode
       self.service_name = 'prefab.RateLimitService'
 
-      rpc :LimitCheck, ::Prefab::LimitRequest, ::Prefab::LimitResponse
+      rpc :LimitCheck, LimitRequest, LimitResponse
     end
 
     Stub = Service.rpc_stub_class
@@ -23,43 +22,15 @@ module Prefab
   module ConfigService
     class Service
 
-      include ::GRPC::GenericService
+      include GRPC::GenericService
 
       self.marshal_class_method = :encode
       self.unmarshal_class_method = :decode
       self.service_name = 'prefab.ConfigService'
 
-      rpc :GetConfig, ::Prefab::ConfigServicePointer, stream(::Prefab::Configs)
-      rpc :GetAllConfig, ::Prefab::ConfigServicePointer, ::Prefab::Configs
-      rpc :Upsert, ::Prefab::Config, ::Prefab::CreationResponse
-    end
-
-    Stub = Service.rpc_stub_class
-  end
-  module IdService
-    class Service
-
-      include ::GRPC::GenericService
-
-      self.marshal_class_method = :encode
-      self.unmarshal_class_method = :decode
-      self.service_name = 'prefab.IdService'
-
-      rpc :GetBlock, ::Prefab::IdBlockRequest, ::Prefab::IdBlock
-    end
-
-    Stub = Service.rpc_stub_class
-  end
-  module ClientService
-    class Service
-
-      include ::GRPC::GenericService
-
-      self.marshal_class_method = :encode
-      self.unmarshal_class_method = :decode
-      self.service_name = 'prefab.ClientService'
-
-      rpc :GetAll, ::Prefab::Identity, ::Prefab::ConfigEvaluations
+      rpc :GetConfig, ConfigServicePointer, stream(ConfigDeltas)
+      rpc :GetAllConfig, ConfigServicePointer, ConfigDeltas
+      rpc :Upsert, UpsertRequest, ConfigServicePointer
     end
 
     Stub = Service.rpc_stub_class

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 0.13.0 ruby lib
+# stub: prefab-cloud-ruby 0.13.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.13.0"
+  s.version = "0.13.1"
 
   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 = "2022-08-10"
+  s.date = "2022-08-12"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -20,9 +20,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".envrc",
-    ".github/workflows/ruby.yml",
-    ".tool-versions",
-    "CODEOWNERS",
+    ".ruby-version",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
@@ -35,29 +33,18 @@ Gem::Specification.new do |s|
     "lib/prefab/cancellable_interceptor.rb",
     "lib/prefab/client.rb",
     "lib/prefab/config_client.rb",
-    "lib/prefab/config_helper.rb",
     "lib/prefab/config_loader.rb",
     "lib/prefab/config_resolver.rb",
-    "lib/prefab/error.rb",
-    "lib/prefab/errors/initialization_timeout_error.rb",
-    "lib/prefab/errors/invalid_api_key_error.rb",
-    "lib/prefab/errors/missing_default_error.rb",
     "lib/prefab/feature_flag_client.rb",
-    "lib/prefab/internal_logger.rb",
     "lib/prefab/logger_client.rb",
     "lib/prefab/murmer3.rb",
     "lib/prefab/noop_cache.rb",
     "lib/prefab/noop_stats.rb",
-    "lib/prefab/options.rb",
     "lib/prefab/ratelimit_client.rb",
     "lib/prefab_pb.rb",
     "lib/prefab_services_pb.rb",
     "prefab-cloud-ruby.gemspec",
-    "run_test_harness_server.sh",
     "test/.prefab.test.config.yaml",
-    "test/harness_server.rb",
-    "test/test_client.rb",
-    "test/test_config_client.rb",
     "test/test_config_loader.rb",
     "test/test_config_resolver.rb",
     "test/test_feature_flag_client.rb",
@@ -66,7 +53,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/prefab-cloud/prefab-cloud-ruby".freeze
   s.licenses = ["MIT".freeze]
-  s.rubygems_version = "3.2.32".freeze
+  s.rubygems_version = "3.1.6".freeze
   s.summary = "Prefab Ruby Infrastructure".freeze
 
   if s.respond_to? :specification_version then
@@ -76,29 +63,23 @@ Gem::Specification.new do |s|
   if s.respond_to? :add_runtime_dependency then
     s.add_runtime_dependency(%q<concurrent-ruby>.freeze, ["~> 1.0", ">= 1.0.5"])
     s.add_runtime_dependency(%q<faraday>.freeze, [">= 0"])
-    s.add_runtime_dependency(%q<ld-eventsource>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<grpc>.freeze, [">= 0"])
-    s.add_runtime_dependency(%q<google-protobuf>.freeze, [">= 0"])
-    s.add_runtime_dependency(%q<googleapis-common-protos-types>.freeze, [">= 0"])
-    s.add_development_dependency(%q<grpc-tools>.freeze, [">= 0"])
+    s.add_development_dependency(%q<grpc-tools>.freeze, ["~> 1.17.1"])
+    s.add_development_dependency(%q<shoulda>.freeze, [">= 0"])
     s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
-    s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
+    s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
     s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])
     s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
-    s.add_development_dependency(%q<thin>.freeze, [">= 0"])
   else
     s.add_dependency(%q<concurrent-ruby>.freeze, ["~> 1.0", ">= 1.0.5"])
     s.add_dependency(%q<faraday>.freeze, [">= 0"])
-    s.add_dependency(%q<ld-eventsource>.freeze, [">= 0"])
     s.add_dependency(%q<grpc>.freeze, [">= 0"])
-    s.add_dependency(%q<google-protobuf>.freeze, [">= 0"])
-    s.add_dependency(%q<googleapis-common-protos-types>.freeze, [">= 0"])
-    s.add_dependency(%q<grpc-tools>.freeze, [">= 0"])
+    s.add_dependency(%q<grpc-tools>.freeze, ["~> 1.17.1"])
+    s.add_dependency(%q<shoulda>.freeze, [">= 0"])
     s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
-    s.add_dependency(%q<bundler>.freeze, [">= 0"])
+    s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])
     s.add_dependency(%q<simplecov>.freeze, [">= 0"])
-    s.add_dependency(%q<thin>.freeze, [">= 0"])
   end
 end
 

data/test/.prefab.test.config.yaml

@@ -1,32 +1,6 @@
-sample: default sample value
+sample: OneTwoThree
 sample_int: 123
 sample_double: 12.12
 sample_bool: true
-false_value: false
-zero_value: 0
 sample_to_override: Foo
 prefab.log_level: debug
-unit_tests:
-  sample: test sample value
-  enabled_flag: true
-  disabled_flag: false
-  flag_with_a_value:
-    feature_flag: true
-    value: "all-features"
-  in_lookup_key:
-    feature_flag: true
-    value: true
-    criteria:
-      operator: LOOKUP_KEY_IN
-      values:
-        - abc123
-        - xyz987
-  just_my_domain:
-    feature_flag: true
-    value: new-version
-    criteria:
-      operator: PROP_IS_ONE_OF
-      property: domain
-      values: ["prefab.cloud", "example.com"]
-ignored_env:
-  sample: ignored value

data/test/test_config_loader.rb

@@ -1,56 +1,41 @@
-# 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",
-      defaults_env: "unit_tests"
-    )
-    @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
+    ENV['PREFAB_CONFIG_OVERRIDE_DIR'] = "none"
+    ENV['PREFAB_CONFIG_CLASSPATH_DIR'] = "test"
+    @loader = Prefab::ConfigLoader.new(MockBaseClient.new)
   end
 
   def test_load
     should_be :int, 123, "sample_int"
-    should_be :string, "test sample value", "sample"
+    should_be :string, "OneTwoThree", "sample"
     should_be :bool, true, "sample_bool"
     should_be :double, 12.12, "sample_double"
   end
 
-  def test_load_in_no_default_env
-    options = Prefab::Options.new(
-      prefab_config_override_dir: "none",
-      prefab_config_classpath_dir: "test",
-    # no defaults_env
-    )
-    @loader = Prefab::ConfigLoader.new(MockBaseClient.new(options))
-    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::ConfigDelta.new(id: 1, key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
     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::ConfigDelta.new(id: 5, key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
     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::ConfigDelta.new(id: 2, key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
     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::ConfigDelta.new(id: 1, key: "sample_int", value: Prefab::ConfigValue.new(int: 1)))
     assert_equal 1, @loader.highwater_mark
     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::ConfigDelta.new(id: 4, key: "sample_int", value: Prefab::ConfigValue.new(int: 4)))
     assert_equal 4, @loader.highwater_mark
     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::ConfigDelta.new(id: 2, key: "sample_int", value: Prefab::ConfigValue.new(int: 2)))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -58,36 +43,37 @@ class TestConfigLoader < Minitest::Test
   def test_api_precedence
     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")
+    @loader.set(Prefab::ConfigDelta.new(key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
     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")
+    delta = Prefab::ConfigDelta.new(key: "sample_int", value: val)
+    @loader.set(delta)
 
-    configs = Prefab::Configs.new
-    configs.configs << config
-    assert_equal configs, @loader.get_api_deltas
+    deltas = Prefab::ConfigDeltas.new
+    deltas.deltas << delta
+    assert_equal deltas, @loader.get_api_deltas
   end
 
   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")
+    delta = Prefab::ConfigDelta.new(key: "sample_int", value: val)
+    @loader.set(delta)
 
-    config = Prefab::Config.new(key: "sample_int", rows: [], id: 3)
-    @loader.set(config, "test")
+    delta = Prefab::ConfigDelta.new(key: "sample_int", value: nil)
+    @loader.set(delta)
 
-    configs = Prefab::Configs.new
-    assert_equal configs, @loader.get_api_deltas
+    deltas = Prefab::ConfigDeltas.new
+    assert_equal deltas, @loader.get_api_deltas
   end
 
   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].type
+    assert_equal value, @loader.calc_config[key].send(type)
   end
+
 end

data/test/test_config_resolver.rb

@@ -1,66 +1,22 @@
-# frozen_string_literal: true
 require 'test_helper'
 
 class TestConfigResolver < Minitest::Test
 
-  STAGING_ENV_ID = 1
-  PRODUCTION_ENV_ID = 2
-  TEST_ENV_ID = 3
-
   def test_resolution
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "key" => { config: Prefab::Config.new(
-        key: "key",
-        rows: [
-          Prefab::ConfigRow.new(
-            value: Prefab::ConfigValue.new(string: "value_no_env_default"),
-          ),
-          Prefab::ConfigRow.new(
-            project_env_id: TEST_ENV_ID,
-            value: Prefab::ConfigValue.new(string: "value_none"),
-          ),
-          Prefab::ConfigRow.new(
-            project_env_id: TEST_ENV_ID,
-            namespace: "projectA",
-            value: Prefab::ConfigValue.new(string: "valueA"),
-          ),
-          Prefab::ConfigRow.new(
-            project_env_id: TEST_ENV_ID,
-            namespace: "projectB",
-            value: Prefab::ConfigValue.new(string: "valueB"),
-          ),
-          Prefab::ConfigRow.new(
-            project_env_id: TEST_ENV_ID,
-            namespace: "projectB.subprojectX",
-            value: Prefab::ConfigValue.new(string: "projectB.subprojectX"),
-          ),
-          Prefab::ConfigRow.new(
-            project_env_id: TEST_ENV_ID,
-            namespace: "projectB.subprojectY",
-            value: Prefab::ConfigValue.new(string: "projectB.subprojectY"),
-          ),
-
-        ]
-      ) },
-      "key2" => { config: Prefab::Config.new(
-        key: "key2",
-        rows: [
-          value: Prefab::ConfigValue.new(string: "valueB2"),
-        ]
-      ) }
-
+      "projectA:key" => Prefab::ConfigValue.new(string: "valueA"),
+      "key" => Prefab::ConfigValue.new(string: "value_none"),
+      "projectB:key" => Prefab::ConfigValue.new(string: "valueB"),
+      "projectB.subprojectX:key" => Prefab::ConfigValue.new(string: "projectB.subprojectX"),
+      "projectB.subprojectY:key" => Prefab::ConfigValue.new(string: "projectB.subprojectY"),
+      "projectB:key2" => Prefab::ConfigValue.new(string: "valueB2")
     }
 
     @loader.stub :calc_config, loaded_values do
-
-      @resolverA = resolver_for_namespace("", @loader, project_env_id: PRODUCTION_ENV_ID)
-      assert_equal "value_no_env_default", @resolverA.get("key")
-
-      ## below here in the test env
-      @resolverA = resolver_for_namespace("", @loader)
-      assert_equal "value_none", @resolverA.get("key")
+      @resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
+      assert_equal "value_none", @resolver.get("key")
 
       @resolverA = resolver_for_namespace("projectA", @loader)
       assert_equal "valueA", @resolverA.get("key")
@@ -71,10 +27,7 @@ class TestConfigResolver < Minitest::Test
       @resolverBX = resolver_for_namespace("projectB.subprojectX", @loader)
       assert_equal "projectB.subprojectX", @resolverBX.get("key")
 
-      @resolverBX = resolver_for_namespace("projectB.subprojectX", @loader)
-      assert_equal "valueB2", @resolverBX.get("key2")
-
-      @resolverUndefinedSubProject = resolver_for_namespace("projectB.subprojectX.subsubQ", @loader)
+      @resolverUndefinedSubProject = resolver_for_namespace("projectB.subprojectX:subsubQ", @loader)
       assert_equal "projectB.subprojectX", @resolverBX.get("key")
 
       @resolverBX = resolver_for_namespace("projectC", @loader)
@@ -87,75 +40,30 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
     @loader.stub :calc_config, {} do
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
-      assert_equal [true, 0], resolver.send(:starts_with_ns?, "", "a")
-      assert_equal [true, 1], resolver.send(:starts_with_ns?, "a", "a")
-      assert_equal [true, 1], resolver.send(:starts_with_ns?, "a", "a.b")
-      assert_equal [false, 2], resolver.send(:starts_with_ns?, "a.b", "a")
-
-      assert_equal [true, 1], resolver.send(:starts_with_ns?, "corp", "corp.proj.proja")
-      assert_equal [true, 2], resolver.send(:starts_with_ns?, "corp.proj", "corp.proj.proja")
-      assert_equal [true, 3], resolver.send(:starts_with_ns?, "corp.proj.proja", "corp.proj.proja")
-      assert_equal [false, 3], resolver.send(:starts_with_ns?, "corp.proj.projb", "corp.proj.proja")
-
-      # corp_equal [true, 1:,a:b is not a real delimited namespace[0
-      assert_equal [false, 1], resolver.send(:starts_with_ns?, "corp", "corp:a:b")
-      assert_equal [true, 1], resolver.send(:starts_with_ns?, "foo", "foo.baz")
-      assert_equal [true, 2], resolver.send(:starts_with_ns?, "foo.baz", "foo.baz")
-      assert_equal [false, 2], resolver.send(:starts_with_ns?, "foo.baz", "foo.bazz")
-    end
-  end
-
-  def test_special_ff_variant_copying
-
-    @loader = MockConfigLoader.new
-    loaded_values = {
-      "ff" => { source: 'test',
-                config: Prefab::Config.new(
-                  key: "ff",
-                  variants: [
-                    Prefab::FeatureFlagVariant.new(string: "inactive"),
-                    Prefab::FeatureFlagVariant.new(string: "default"),
-                    Prefab::FeatureFlagVariant.new(string: "env"),
-                  ],
-                  rows: [
-                    { value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
-                      inactive_variant_idx: 0,
-                      rules: default_ff_rule(1),
-                    )) },
-                    { project_env_id: TEST_ENV_ID,
-                      value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
-                        inactive_variant_idx: 0,
-                        rules: default_ff_rule(2),
-                      )) }
-                  ]
-                )
-      }
-    }
-    @loader.stub :calc_config, loaded_values do
-      resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
-      config = resolver.get_config("ff")
-      assert_equal 3, config.variants.size
-      assert_equal %w(inactive default env), config.variants.map(&:string)
+      assert resolver.send(:starts_with_ns?, "", "a")
+      assert resolver.send(:starts_with_ns?, "a", "a")
+      assert resolver.send(:starts_with_ns?, "a", "a.b")
+      assert !resolver.send(:starts_with_ns?, "a.b", "a")
+
+      assert resolver.send(:starts_with_ns?, "corp", "corp.proj.proja")
+      assert resolver.send(:starts_with_ns?, "corp.proj", "corp.proj.proja")
+      assert resolver.send(:starts_with_ns?, "corp.proj.proja", "corp.proj.proja")
+      assert !resolver.send(:starts_with_ns?, "corp.proj.projb", "corp.proj.proja")
+
+      # corp:a:b is not a real delimited namespace
+      assert !resolver.send(:starts_with_ns?, "corp", "corp:a:b")
+      assert resolver.send(:starts_with_ns?, "foo", "foo.baz")
+      assert resolver.send(:starts_with_ns?, "foo.baz", "foo.baz")
+      assert !resolver.send(:starts_with_ns?, "foo.baz", "foo.bazz")
     end
   end
 
   # colons are not allowed in keys, but verify behavior anyway
-  def test_key_and_namespaces_with_colons
+  def test_keys_with_colons
     @loader = MockConfigLoader.new
-
     loaded_values = {
-      "Key:With:Colons" => { config: Prefab::Config.new(
-        key: "Key:With:Colons",
-        rows: [Prefab::ConfigRow.new(
-          value: Prefab::ConfigValue.new(string: "value")
-        )]
-      ) },
-      "proj:apikey" => { config: Prefab::Config.new(
-        key: "proj:apikey",
-        rows: [Prefab::ConfigRow.new(
-          value: Prefab::ConfigValue.new(string: "v2")
-        )]
-      ) }
+      "Key:With:Colons" => Prefab::ConfigValue.new(string: "value"),
+      "proj:apikey" => Prefab::ConfigValue.new(string: "v2")
     }
 
     @loader.stub :calc_config, loaded_values do
@@ -164,41 +72,37 @@ class TestConfigResolver < Minitest::Test
       assert_nil r.get("apikey")
 
       r = resolver_for_namespace("proj", @loader)
-      assert_nil r.get("apikey")
+      assert_equal "v2", r.get("apikey")
 
       r = resolver_for_namespace("", @loader)
       assert_nil r.get("apikey")
 
+
       @resolverKeyWith = resolver_for_namespace("Ket:With", @loader)
       assert_nil @resolverKeyWith.get("Colons")
       assert_nil @resolverKeyWith.get("With:Colons")
-      assert_equal "value", @resolverKeyWith.get("Key:With:Colons")
+      assert_nil @resolverKeyWith.get("Key:With:Colons")
 
       @resolverKeyWithExtra = resolver_for_namespace("Key:With:Extra", @loader)
+      puts @resolverKeyWithExtra.to_s
       assert_nil @resolverKeyWithExtra.get("Colons")
       assert_nil @resolverKeyWithExtra.get("With:Colons")
-      assert_equal "value", @resolverKeyWithExtra.get("Key:With:Colons")
+      assert_nil @resolverKeyWithExtra.get("Key:With:Colons")
 
       @resolverKey = resolver_for_namespace("Key", @loader)
-      assert_nil @resolverKey.get("With:Colons")
+      assert_equal "value", @resolverKey.get("With:Colons")
       assert_nil @resolverKey.get("Colons")
-      assert_equal "value", @resolverKey.get("Key:With:Colons")
+      assert_nil @resolverKey.get("Key:With:Colons")
 
       @resolverWithProperlySegmentedNamespace = resolver_for_namespace("Key.With.Extra", @loader)
       assert_nil @resolverWithProperlySegmentedNamespace.get("Colons")
-      assert_nil @resolverWithProperlySegmentedNamespace.get("With:Colons")
-      assert_equal "value", @resolverWithProperlySegmentedNamespace.get("Key:With:Colons")
+      assert_equal "value", @resolverWithProperlySegmentedNamespace.get("With:Colons")
+      assert_nil @resolverWithProperlySegmentedNamespace.get("Key:With:Colons")
     end
   end
 
-  def resolver_for_namespace(namespace, loader, project_env_id: TEST_ENV_ID)
-    options = Prefab::Options.new(
-      namespace: namespace
-    )
-    resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
-    resolver.project_env_id = project_env_id
-    resolver.update
-    resolver
+  def resolver_for_namespace(namespace, loader)
+    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace), loader)
   end
 
 end