prefab-cloud-ruby 0.8.0 → 0.11.0

data/test/test_feature_flag_client.rb

@@ -13,111 +13,174 @@ class TestFeatureFlagClient < Minitest::Test
   def test_pct
     feature = "FlagName"
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
-      inactive_variant_idx: 0,
-      default: Prefab::VariantDistribution.new(variant_weights:
-                                                 Prefab::VariantWeights.new(weights: [
-                                                   Prefab::VariantWeight.new(weight: 500,
-                                                                             variant_idx: 1),
-                                                   Prefab::VariantWeight.new(weight: 500,
-                                                                             variant_idx: 0),
-                                                 ]
-                                                 )
-      )
+      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.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
+    # "1FlagNamehashes low" hashes to 44.547% through dist
     assert_equal true,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.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,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
-      inactive_variant_idx: 0,
-      default: Prefab::VariantDistribution.new(variant_idx: 1)
+      inactive_variant_idx: 1,
+      rules: default_ff_rule(2)
     )
     assert_equal true,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal true,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: false,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
-      inactive_variant_idx: 0,
-      default: Prefab::VariantDistribution.new(variant_idx: 1)
+      inactive_variant_idx: 1,
+      rules: default_ff_rule(2)
     )
     assert_equal false,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal false,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
   end
 
   def test_user_targets
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "user target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "user target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
-      inactive_variant_idx: 0,
+      inactive_variant_idx: 1,
       user_targets: [
-        variant_idx: 1,
+        variant_idx: 2,
         identifiers: ["user:1", "user:3"]
       ],
-      default: Prefab::VariantDistribution.new(variant_idx: 2)
+      rules: default_ff_rule(3)
     )
 
     assert_equal "user target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
     assert_equal "user target",
-                 @client.evaluate(feature, "user:3", [], flag)
+                 @client.evaluate(feature, "user:3", [], 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,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
-      inactive_variant_idx: 0,
-      rules: [Prefab::Rule.new(
-        distribution: Prefab::VariantDistribution.new(variant_idx: 1),
-        criteria: Prefab::Criteria.new(
-          operator: "IN",
-          values: ["user:1"]
+      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)
+          ]
         )
-      )],
-      default: Prefab::VariantDistribution.new(variant_idx: 2)
+
+      ],
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
+
+  end
+
+  def test_property_is_one_of
+    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: "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 "default",
+                 @client.evaluate(feature, "user:1", {email: "not@example.com"}, flag, variants)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:2", {}, flag, variants)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:2", {email: "b@example.com"}, flag, variants)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:2", {"email" => "b@example.com"}, flag, variants)
 
   end
 
@@ -135,86 +198,110 @@ class TestFeatureFlagClient < Minitest::Test
 
   def test_segments
     segment_key = "prefab-segment-beta-group"
-    @mock_base_client.mock_this_config(segment_key,
-                                       Prefab::Segment.new(
-                                         name: "Beta Group",
-                                         includes: ["user:1"]
-                                       )
+    @mock_base_client.config_client.mock_this_config(segment_key,
+                                                     Prefab::Segment.new(
+                                                       name: "Beta Group",
+                                                       includes: ["user:1"]
+                                                     )
     )
 
     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,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
-      inactive_variant_idx: 0,
-      rules: [Prefab::Rule.new(
-        distribution: Prefab::VariantDistribution.new(variant_idx: 1),
-        criteria: Prefab::Criteria.new(
-          operator: "IN_SEG",
-          values: [segment_key]
+      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)
+          ]
         )
-      )],
-      default: Prefab::VariantDistribution.new(variant_idx: 2)
+
+      ],
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
 
   end
 
   def test_in_multiple_segments_has_or_behavior
     segment_key_one = "prefab-segment-segment-1"
-    @mock_base_client.mock_this_config(segment_key_one,
-                                       Prefab::Segment.new(
-                                         name: "Segment-1",
-                                         includes: ["user:1", "user:2"],
-                                         excludes: ["user:3"]
-                                       )
+    @mock_base_client.config_client.mock_this_config(segment_key_one,
+                                                     Prefab::Segment.new(
+                                                       name: "Segment-1",
+                                                       includes: ["user:1", "user:2"],
+                                                       excludes: ["user:3"]
+                                                     )
     )
     segment_key_two = "prefab-segment-segment-2"
-    @mock_base_client.mock_this_config(segment_key_two,
-                                       Prefab::Segment.new(
-                                         name: "Segment-2",
-                                         includes: ["user:3", "user:4"],
-                                         excludes: ["user:2"]
-                                       )
+    @mock_base_client.config_client.mock_this_config(segment_key_two,
+                                                     Prefab::Segment.new(
+                                                       name: "Segment-2",
+                                                       includes: ["user:3", "user:4"],
+                                                       excludes: ["user:2"]
+                                                     )
     )
 
     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,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
-      inactive_variant_idx: 0,
-      rules: [Prefab::Rule.new(
-        distribution: Prefab::VariantDistribution.new(variant_idx: 1),
-        criteria: Prefab::Criteria.new(
-          operator: "IN_SEG",
-          values: [segment_key_one, segment_key_two]
+      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)
+          ]
         )
-      )],
-      default: Prefab::VariantDistribution.new(variant_idx: 2)
+      ]
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:2", [], flag), "matches segment 1"
+                 @client.evaluate(feature, "user:2", [], flag, variants), "matches segment 1"
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:3", [], flag)
+                 @client.evaluate(feature, "user:3", [], flag, variants)
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:4", [], flag)
+                 @client.evaluate(feature, "user:4", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:5", [], flag)
+                 @client.evaluate(feature, "user:5", [], flag, variants)
 
   end
+
 end

data/test/test_helper.rb

@@ -2,32 +2,68 @@ require 'minitest/autorun'
 require 'prefab-cloud-ruby'
 
 class MockBaseClient
-  attr_reader :namespace, :logger, :environment
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+  attr_reader :namespace, :logger, :config_client
+
+  def initialize(namespace: "")
 
-  def initialize(environment: "test", namespace: "")
-    @environment = environment
     @namespace = namespace
     @logger = Logger.new($stdout)
-    @config_values = {}
+    @config_client = MockConfigClient.new
   end
 
   def project_id
     1
   end
 
+  def log
+    @logger
+  end
+
   def log_internal level, message
   end
 
-  def mock_this_config key, config_value
-    @config_values[key] = config_value
+  def config_value key
+    @config_values[key]
   end
 
+end
+
+class MockConfigClient
+  def initialize(config_values = {})
+    @config_values = config_values
+  end
   def get(key)
     @config_values[key]
   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

data/test/test_logger.rb

@@ -39,13 +39,3 @@ class TestCLogger < Minitest::Test
                  @logger.level_of("app.models.user")
   end
 end
-
-class MockConfigClient
-  def initialize(hash)
-    @hash = hash
-  end
-
-  def get(key)
-    @hash[key]
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -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