prefab-cloud-ruby 0.13.1 → 0.13.2

data/test/test_feature_flag_client.rb

@@ -1,64 +1,306 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class TestFeatureFlagClient < Minitest::Test
 
+  def setup
+    super
+    @mock_base_client = MockBaseClient.new
+    @client = Prefab::FeatureFlagClient.new(@mock_base_client)
+    Prefab::FeatureFlagClient.send(:public, :is_on?) #publicize for testing
+    Prefab::FeatureFlagClient.send(:public, :segment_match?) #publicize for testing
+    Prefab::FeatureFlagClient.send(:public, :get_variant) #publicize for testing
+  end
+
   def test_pct
-    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
-    Prefab::FeatureFlagClient.send(:public, :is_on?)
     feature = "FlagName"
-    flag = Prefab::FeatureFlag.new( pct: 0.5)
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 1,
+      rules: [
+        Prefab::Rule.new(
+          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 86,
+                                      variant_idx: 2), #true
+            Prefab::VariantWeight.new(weight: 14,
+                                      variant_idx: 1), #false
+          ]
+        )
+      ]
+    )
+    # weights above chosen to be 86% in variant_idx 2. and 14% in variant_idx 1.
+    # since hashes high is 86.32 > 86 it just falls outside the 86% range and gets false
+
+    # "1FlagNamehashes high" hashes to 86.322% through dist
     assert_equal false,
-                 client.is_on?(feature, "hashes high", [], flag)
+                 evaluate(feature, "hashes high", [], flag, variants)
+    # "1FlagNamehashes low" hashes to 44.547% through dist
+    assert_equal true,
+                 evaluate(feature, "hashes low", [], flag, variants)
 
+  end
+
+  def test_basic_active_inactive
+    feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 1,
+      rules: default_ff_rule(2)
+    )
     assert_equal true,
-                 client.is_on?(feature, "hashes low", [], flag)
+                 evaluate(feature, "hashes high", [], flag, variants)
+    assert_equal true,
+                 evaluate(feature, "hashes low", [], flag, variants)
+
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: false,
+      inactive_variant_idx: 1,
+      rules: default_ff_rule(2)
+    )
+    assert_equal false,
+                 evaluate(feature, "hashes high", [], flag, variants)
+    assert_equal false,
+                 evaluate(feature, "hashes low", [], flag, variants)
   end
 
+  def test_inclusion_rule
+    feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 1,
+      rules: [
+        Prefab::Rule.new(
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 2)
+          ],
+          criteria: Prefab::Criteria.new(
+            operator: "LOOKUP_KEY_IN",
+            values: ["user:1"]
+          )
+        ),
+        Prefab::Rule.new(
+          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 3)
+          ]
+        )
+
+      ],
+    )
 
-  def test_off
-    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
-    Prefab::FeatureFlagClient.send(:public, :is_on?)
+    assert_equal "rule target",
+                 evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "default",
+                 evaluate(feature, "user:2", [], flag, variants)
+
+  end
+
+  def test_property_is_one_of
     feature = "FlagName"
-    flag = Prefab::FeatureFlag.new(pct: 0)
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 1,
+      rules: [
+        Prefab::Rule.new(
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 2)
+          ],
+          criteria: Prefab::Criteria.new(
+            operator: "PROP_IS_ONE_OF",
+            values: ["a@example.com", "b@example.com"],
+            property: "email"
+          )
+        ),
+        Prefab::Rule.new(
+          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 3)
+          ]
+        )
 
-    assert_equal false,
-                 client.is_on?(feature, "hashes high", [], flag)
+      ],
+    )
 
-    assert_equal false,
-                 client.is_on?(feature, "hashes low", [], flag)
+    assert_equal "default",
+                 evaluate(feature, "user:1", { email: "not@example.com" }, flag, variants)
+    assert_equal "default",
+                 evaluate(feature, "user:2", {}, flag, variants)
+    assert_equal "rule target",
+                 evaluate(feature, "user:2", { email: "b@example.com" }, flag, variants)
+    assert_equal "rule target",
+                 evaluate(feature, "user:2", { "email" => "b@example.com" }, flag, variants)
+
+  end
+
+  def test_segment_match?
+    segment = Prefab::Segment.new(
+      criterion: [
+        Prefab::Criteria.new(
+          operator: "PROP_IS_ONE_OF",
+          values: ["a@example.com", "b@example.com"],
+          property: "email"
+        ),
+        Prefab::Criteria.new(
+          operator: "LOOKUP_KEY_IN",
+          values: ["user:2"]
+        )
+      ]
+    )
+    assert_equal false, @client.segment_match?(segment, "user:0", {})
+    assert_equal true, @client.segment_match?(segment, "user:2", {})
+    assert_equal false, @client.segment_match?(segment, "user:1", { email: "no@example.com" })
+    assert_equal true, @client.segment_match?(segment, "user:1", { email: "a@example.com" })
   end
 
+  def test_segments
+    segment_key = "prefab-segment-beta-group"
+    @mock_base_client.config_client.mock_this_config(segment_key,
+                                                     Prefab::Segment.new(
+                                                       criterion: [
+                                                         Prefab::Criteria.new(
+                                                           operator: Prefab::Criteria::CriteriaOperator::LOOKUP_KEY_IN,
+                                                           values: ["user:1"]
+                                                         )
+                                                       ]
+                                                     )
+    )
 
-  def test_on
-    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
-    Prefab::FeatureFlagClient.send(:public, :is_on?)
     feature = "FlagName"
-    flag = Prefab::FeatureFlag.new(pct: 1)
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 1,
+      rules: [
+        Prefab::Rule.new(
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 2)
+          ],
+          criteria: Prefab::Criteria.new(
+            operator: "IN_SEG",
+            values: [segment_key]
+          )
+        ),
+        Prefab::Rule.new(
+          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 3)
+          ]
+        )
 
-    assert_equal true,
-                 client.is_on?(feature, "hashes high", [], flag)
+      ],
+    )
+
+    assert_equal "rule target",
+                 evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "default",
+                 evaluate(feature, "user:2", [], flag, variants)
 
-    assert_equal true,
-                 client.is_on?(feature, "hashes low", [], flag)
   end
 
-  def test_whitelist
-    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
-    Prefab::FeatureFlagClient.send(:public, :is_on?)
+  def test_in_multiple_segments_has_or_behavior
+    segment_key_one = "prefab-segment-segment-1"
+    @mock_base_client.config_client.mock_this_config(segment_key_one,
+                                                     Prefab::Segment.new(
+                                                       criterion: [
+                                                         Prefab::Criteria.new(
+                                                           operator: Prefab::Criteria::CriteriaOperator::LOOKUP_KEY_IN,
+                                                           values: ["user:1", "user:2"]
+                                                         )
+                                                       ]
+                                                     )
+    )
+    segment_key_two = "prefab-segment-segment-2"
+    @mock_base_client.config_client.mock_this_config(segment_key_two,
+                                                     Prefab::Segment.new(
+                                                       criterion: [
+                                                         Prefab::Criteria.new(
+                                                           operator: Prefab::Criteria::CriteriaOperator::LOOKUP_KEY_IN,
+                                                           values: ["user:3", "user:4"]
+                                                         )
+                                                       ]
+                                                     )
+    )
+
     feature = "FlagName"
-    flag = Prefab::FeatureFlag.new(pct: 0, whitelisted: ["beta", "user:1", "user:3"])
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 1,
+      rules: [
+        Prefab::Rule.new(
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 2)
+          ],
+          criteria: Prefab::Criteria.new(
+            operator: "IN_SEG",
+            values: [segment_key_one, segment_key_two]
+          )
+        ),
+        Prefab::Rule.new(
+          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
+          variant_weights: [
+            Prefab::VariantWeight.new(weight: 1000,
+                                      variant_idx: 3)
+          ]
+        )
 
-    assert_equal false,
-                 client.is_on?(feature, "anything", [], flag)
-    assert_equal true,
-                 client.is_on?(feature, "anything", ["beta"], flag)
-    assert_equal true,
-                 client.is_on?(feature, "anything", ["alpha", "beta"], flag)
-    assert_equal true,
-                 client.is_on?(feature, "anything", ["alpha", "user:1"], flag)
-    assert_equal false,
-                 client.is_on?(feature, "anything", ["alpha", "user:2"], flag)
+      ],
+    )
+
+    assert_equal "rule target",
+                 evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "rule target",
+                 evaluate(feature, "user:2", [], flag, variants), "matches segment 1"
+    assert_equal "rule target",
+                 evaluate(feature, "user:3", [], flag, variants)
+    assert_equal "rule target",
+                 evaluate(feature, "user:4", [], flag, variants)
+    assert_equal "default",
+                 evaluate(feature, "user:5", [], flag, variants)
+
+  end
 
+  def evaluate(feature_name, lookup_key, attributes, flag, variants)
+    variant = @client.get_variant(feature_name, lookup_key, attributes, flag, variants)
+    @client.value_of_variant(variant)
   end
 end

data/test/test_helper.rb

@@ -1,23 +1,89 @@
+# frozen_string_literal: true
 require 'minitest/autorun'
 require 'prefab-cloud-ruby'
 
 class MockBaseClient
-  attr_reader :namespace, :logger
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+  attr_reader :namespace, :logger, :config_client, :options
 
-  def initialize(namespace: "")
+  def initialize(options = Prefab::Options.new)
+    @options = options
     @namespace = namespace
-    @logger = Logger.new($stdout)
+    @logger = Prefab::LoggerClient.new($stdout)
+    @config_client = MockConfigClient.new
   end
 
-  def account_id
+  def project_id
     1
   end
 
+  def log
+    @logger
+  end
+
   def log_internal level, message
   end
+
+  def config_value key
+    @config_values[key]
+  end
+
+end
+
+class MockConfigClient
+  def initialize(config_values = {})
+    @config_values = config_values
+  end
+  def get(key, default=nil)
+    @config_values.fetch(key, default)
+  end
+
+  def get_config(key)
+    Prefab::Config.new(value: @config_values[key], key: key)
+  end
+
+  def mock_this_config key, config_value
+    @config_values[key] = config_value
+  end
 end
 
 class MockConfigLoader
   def calc_config
   end
 end
+
+
+private
+
+def default_ff_rule(variant_idx)
+  [
+    Prefab::Rule.new(
+      criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
+      variant_weights: [
+        Prefab::VariantWeight.new(weight: 1000,
+                                  variant_idx: variant_idx)
+      ]
+    )
+  ]
+end
+
+def with_env(key, value)
+  old_value = ENV[key]
+
+  ENV[key] = value
+ensure
+  ENV[key] = old_value
+end
+
+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

data/test/test_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class TestCLogger < Minitest::Test
@@ -18,34 +19,27 @@ class TestCLogger < Minitest::Test
   end
 
   def test_level_of
-    assert_equal Logger::INFO,
-                 @logger.level_of("app.models.user"), "PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL is info"
-
-    @logger.set_config_client(MockConfigClient.new({}))
-    assert_equal Logger::WARN,
-                 @logger.level_of("app.models.user"), "default is warn"
-
-    @logger.set_config_client(MockConfigClient.new("log_level.app" => "info"))
-    assert_equal Logger::INFO,
-                 @logger.level_of("app.models.user")
-
-    @logger.set_config_client(MockConfigClient.new("log_level.app" => "debug"))
-    assert_equal Logger::DEBUG,
-                 @logger.level_of("app.models.user")
-
-    @logger.set_config_client(MockConfigClient.new("log_level.app" => "debug",
-                                                   "log_level.app.models" => "warn"))
-    assert_equal Logger::WARN,
-                 @logger.level_of("app.models.user")
-  end
-end
-
-class MockConfigClient
-  def initialize(hash)
-    @hash = hash
-  end
-
-  def get(key)
-    @hash[key]
+    with_env("PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL", "info") do
+      # env var overrides the default level
+      assert_equal Logger::INFO,
+        @logger.level_of("app.models.user"), "PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL is info"
+
+      @logger.set_config_client(MockConfigClient.new({}))
+      assert_equal Logger::WARN,
+                  @logger.level_of("app.models.user"), "default is warn"
+
+      @logger.set_config_client(MockConfigClient.new("log_level.app" => "info"))
+      assert_equal Logger::INFO,
+                  @logger.level_of("app.models.user")
+
+      @logger.set_config_client(MockConfigClient.new("log_level.app" => "debug"))
+      assert_equal Logger::DEBUG,
+                  @logger.level_of("app.models.user")
+
+      @logger.set_config_client(MockConfigClient.new("log_level.app" => "debug",
+                                                    "log_level.app.models" => "warn"))
+      assert_equal Logger::WARN,
+                  @logger.level_of("app.models.user")
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.2
 platform: ruby
 authors:
 - Jeff Dwyer
@@ -44,6 +44,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ld-eventsource
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: grpc
   requirement: !ruby/object:Gem::Requirement
@@ -59,21 +73,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: grpc-tools
+  name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.17.1
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.17.1
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda
+  name: googleapis-common-protos-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: grpc-tools
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -104,16 +132,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: juwelier
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +170,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: RateLimits & Config as a service
 email: jdwyer@prefab.cloud
 executables: []
@@ -151,7 +193,9 @@ extra_rdoc_files:
 - README.md
 files:
 - ".envrc"
-- ".ruby-version"
+- ".github/workflows/ruby.yml"
+- ".tool-versions"
+- CODEOWNERS
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -164,18 +208,29 @@ files:
 - 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
@@ -200,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Prefab Ruby Infrastructure

data/.ruby-version

@@ -1 +0,0 @@
-2.4.2