prefab-cloud-ruby 0.13.1 → 0.13.2

data/test/test_client.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class TestClient < Minitest::Test
+  def setup
+    @client = new_client
+  end
+
+  def test_get
+    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")
+
+    # A falsy value is not replaced with the default
+    assert_equal 0, @client.get("zero_value", "red")
+
+    # A missing value returns the default
+    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")
+    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: Prefab::Options::ON_NO_DEFAULT::RETURN_NIL)
+    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")
+  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")
+  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_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" })
+  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_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")
+  end
+
+  def test_ssl_certs
+    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
+
+  private
+
+  def new_client(overrides = {})
+    options = Prefab::Options.new(**{
+      prefab_config_override_dir: "none",
+      prefab_config_classpath_dir: "test",
+      defaults_env: "unit_tests",
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    }.merge(overrides))
+
+    Prefab::Client.new(options)
+  end
+end

data/test/test_config_client.rb

@@ -0,0 +1,56 @@
+# 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",
+      defaults_env: "unit_tests",
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    )
+
+    @config_client = Prefab::ConfigClient.new(MockBaseClient.new(options), 10)
+  end
+
+  def test_load
+    assert_equal "test sample value", @config_client.get("sample")
+    assert_equal 123, @config_client.get("sample_int")
+  end
+
+  def test_initialization_timeout_error
+    options = Prefab::Options.new(
+      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")
+    end
+
+    assert_match(/couldn't initialize in 0.01 second timeout/, err.message)
+  end
+
+  def test_invalid_api_key_error
+    options = Prefab::Options.new(
+      api_key: "",
+    )
+
+    err = assert_raises(Prefab::Errors::InvalidApiKeyError) do
+      Prefab::Client.new(options).config_client.get("anything")
+    end
+
+    assert_match(/No API key/, err.message)
+
+    options = Prefab::Options.new(
+      api_key: "invalid",
+    )
+
+    err = assert_raises(Prefab::Errors::InvalidApiKeyError) do
+      Prefab::Client.new(options).config_client.get("anything")
+    end
+
+    assert_match(/format is invalid/, err.message)
+  end
+end

data/test/test_config_loader.rb

@@ -1,41 +1,56 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class TestConfigLoader < Minitest::Test
   def setup
-    ENV['PREFAB_CONFIG_OVERRIDE_DIR'] = "none"
-    ENV['PREFAB_CONFIG_CLASSPATH_DIR'] = "test"
-    @loader = Prefab::ConfigLoader.new(MockBaseClient.new)
+    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))
   end
 
   def test_load
     should_be :int, 123, "sample_int"
-    should_be :string, "OneTwoThree", "sample"
+    should_be :string, "test sample value", "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::ConfigDelta.new(id: 1, key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
     assert_equal 1, @loader.highwater_mark
 
-    @loader.set(Prefab::ConfigDelta.new(id: 5, key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 5, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]),"test")
     assert_equal 5, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 2, key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: 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::ConfigDelta.new(id: 1, key: "sample_int", value: Prefab::ConfigValue.new(int: 1)))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 1))]),"test")
     assert_equal 1, @loader.highwater_mark
     should_be :int, 1, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(id: 4, key: "sample_int", value: Prefab::ConfigValue.new(int: 4)))
+    @loader.set(Prefab::Config.new(id: 4, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 4))]),"test")
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(id: 2, key: "sample_int", value: Prefab::ConfigValue.new(int: 2)))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 2))]),"test")
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -43,37 +58,36 @@ class TestConfigLoader < Minitest::Test
   def test_api_precedence
     should_be :int, 123, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(key: "sample_int", value: Prefab::ConfigValue.new(int: 456)))
+    @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"
   end
 
   def test_api_deltas
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", value: val)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
+    @loader.set(config, "test")
 
-    deltas = Prefab::ConfigDeltas.new
-    deltas.deltas << delta
-    assert_equal deltas, @loader.get_api_deltas
+    configs = Prefab::Configs.new
+    configs.configs << config
+    assert_equal configs, @loader.get_api_deltas
   end
 
   def test_loading_tombstones_removes_entries
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", value: val)
-    @loader.set(delta)
+    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: nil)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [], id: 3)
+    @loader.set(config, "test")
 
-    deltas = Prefab::ConfigDeltas.new
-    assert_equal deltas, @loader.get_api_deltas
+    configs = Prefab::Configs.new
+    assert_equal configs, @loader.get_api_deltas
   end
 
   private
 
   def should_be(type, value, key)
-    assert_equal type, @loader.calc_config[key].type
-    assert_equal value, @loader.calc_config[key].send(type)
+    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)
   end
-
 end

data/test/test_config_resolver.rb

@@ -1,22 +1,66 @@
+# 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 = {
-      "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")
+      "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"),
+        ]
+      ) }
+
     }
 
     @loader.stub :calc_config, loaded_values do
-      @resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
-      assert_equal "value_none", @resolver.get("key")
+
+      @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")
 
       @resolverA = resolver_for_namespace("projectA", @loader)
       assert_equal "valueA", @resolverA.get("key")
@@ -27,7 +71,10 @@ class TestConfigResolver < Minitest::Test
       @resolverBX = resolver_for_namespace("projectB.subprojectX", @loader)
       assert_equal "projectB.subprojectX", @resolverBX.get("key")
 
-      @resolverUndefinedSubProject = resolver_for_namespace("projectB.subprojectX:subsubQ", @loader)
+      @resolverBX = resolver_for_namespace("projectB.subprojectX", @loader)
+      assert_equal "valueB2", @resolverBX.get("key2")
+
+      @resolverUndefinedSubProject = resolver_for_namespace("projectB.subprojectX.subsubQ", @loader)
       assert_equal "projectB.subprojectX", @resolverBX.get("key")
 
       @resolverBX = resolver_for_namespace("projectC", @loader)
@@ -40,30 +87,75 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
     @loader.stub :calc_config, {} do
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
-      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")
+      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)
     end
   end
 
   # colons are not allowed in keys, but verify behavior anyway
-  def test_keys_with_colons
+  def test_key_and_namespaces_with_colons
     @loader = MockConfigLoader.new
+
     loaded_values = {
-      "Key:With:Colons" => Prefab::ConfigValue.new(string: "value"),
-      "proj:apikey" => Prefab::ConfigValue.new(string: "v2")
+      "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")
+        )]
+      ) }
     }
 
     @loader.stub :calc_config, loaded_values do
@@ -72,37 +164,41 @@ class TestConfigResolver < Minitest::Test
       assert_nil r.get("apikey")
 
       r = resolver_for_namespace("proj", @loader)
-      assert_equal "v2", r.get("apikey")
+      assert_nil 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_nil @resolverKeyWith.get("Key:With:Colons")
+      assert_equal "value", @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_nil @resolverKeyWithExtra.get("Key:With:Colons")
+      assert_equal "value", @resolverKeyWithExtra.get("Key:With:Colons")
 
       @resolverKey = resolver_for_namespace("Key", @loader)
-      assert_equal "value", @resolverKey.get("With:Colons")
+      assert_nil @resolverKey.get("With:Colons")
       assert_nil @resolverKey.get("Colons")
-      assert_nil @resolverKey.get("Key:With:Colons")
+      assert_equal "value", @resolverKey.get("Key:With:Colons")
 
       @resolverWithProperlySegmentedNamespace = resolver_for_namespace("Key.With.Extra", @loader)
       assert_nil @resolverWithProperlySegmentedNamespace.get("Colons")
-      assert_equal "value", @resolverWithProperlySegmentedNamespace.get("With:Colons")
-      assert_nil @resolverWithProperlySegmentedNamespace.get("Key:With:Colons")
+      assert_nil @resolverWithProperlySegmentedNamespace.get("With:Colons")
+      assert_equal "value", @resolverWithProperlySegmentedNamespace.get("Key:With:Colons")
     end
   end
 
-  def resolver_for_namespace(namespace, loader)
-    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace), loader)
+  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
   end
 
 end