prefab-cloud-ruby 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c18d5a31a2f535269b3faf262b82a57e67b75ceee5581c5ef6f8cea7bbdb416b
-  data.tar.gz: d7125da40abab76dc25e37459cdde3a891801dc4f630c3f3f2f22f7f65ef2f5d
+  metadata.gz: 22d564bcc76424b3308623b4d2e27a4acaf4217c285bcca02542291d8cc15827
+  data.tar.gz: c097169d379d9f477a66d20fc378f693173de044baecad08059263fd239257e5
 SHA512:
-  metadata.gz: 38e1ad427078327f05b01b869d5f0879819271b372d8373996d5d592e3d4efa92bed6b59d061d92dc2a21eb49c6c529140ae9f9b5d8825fc2b828840d1b23a7f
-  data.tar.gz: 88cf63bf9dfdc9c103660240a5d2b35f27103eda55c28a96cb16943da41adf4ffa85928533fd739a868b3b5f5bb5ef565b80073f75712f3bb62305921694d1b2
+  metadata.gz: cdf6ca3b1b28bf83caa629193b21e2d26e4d22d64ee4cd30b7a88fdce623adc7f3feb3605df7107cdca00e7823709f9eeac2a68176db1d10b6616196d2bcb580
+  data.tar.gz: c61b171a2be217c016fad1cc0a1ce9faed159c6f894065db4202ec200ec1f8ac22caabb880fae0f358fcced0930ce49d4e273f800a0fb72c39c6d6f19cc59d07

data/VERSION

@@ -1 +1 @@
-0.10.0
+0.11.0

data/lib/prefab/client.rb

@@ -8,7 +8,7 @@ module Prefab
     }
 
 
-    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :project_env_id, :prefab_api_url
+    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :prefab_api_url
 
     def initialize(api_key: ENV['PREFAB_API_KEY'],
                    logdev: nil,
@@ -26,14 +26,12 @@ module Prefab
       @stats = (stats || NoopStats.new)
       @shared_cache = (shared_cache || NoopCache.new)
       @api_key = api_key
-      @project_id = api_key.split("-")[0].to_i
-      @project_env_id = api_key.split("-")[1].to_i
+      @project_id = api_key.split("-")[0].to_i # unvalidated, but that's ok. APIs only listen to the actual passwd
       @namespace = namespace
       @interceptor = Prefab::AuthInterceptor.new(api_key)
       @stubs = {}
       @prefab_api_url = ENV["PREFAB_API_URL"] || 'https://api.prefab.cloud'
       @prefab_grpc_url = ENV["PREFAB_GRPC_URL"] || 'grpc.prefab.cloud:443'
-      log_internal Logger::INFO, "Prefab Initializing in environment: '#{@project_env_id}' and namespace: '#{@namespace}'"
       log_internal Logger::INFO, "Prefab Connecting to: #{@prefab_api_url} and #{@prefab_grpc_url} Secure: #{http_secure?}"
       at_exit do
         channel.destroy

data/lib/prefab/config_client.rb

@@ -104,9 +104,6 @@ module Prefab
       resp = stub.get_all_config(config_req)
       @base_client.log_internal Logger::DEBUG, "Got Response #{resp}"
       load_configs(resp, :api)
-      resp.configs.each do |delta|
-        @config_loader.set(delta)
-      end
       @config_resolver.update
       finish_init!(:api)
       true
@@ -127,6 +124,10 @@ module Prefab
     end
 
     def load_configs(configs, source)
+      project_env_id = configs.config_service_pointer.project_env_id
+      @config_resolver.project_env_id = project_env_id
+
+      @base_client.log_internal Logger::INFO, "Prefab Initializing in project: #{@base_client.project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
       configs.configs.each do |config|
         @config_loader.set(config)
       end

data/lib/prefab/config_resolver.rb

@@ -3,12 +3,14 @@ module Prefab
     include Prefab::ConfigHelper
     NAMESPACE_DELIMITER = ".".freeze
 
+    attr_accessor :project_env_id # this will be set by the config_client when it gets an API response
+
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @project_env_id = base_client.project_env_id
       @namespace = base_client.namespace
       @config_loader = config_loader
+      @project_env_id = 0
       make_local
     end
 

data/lib/prefab/feature_flag_client.rb

@@ -2,7 +2,6 @@ module Prefab
   class FeatureFlagClient
     include Prefab::ConfigHelper
     MAX_32_FLOAT = 4294967294.0
-    DISTRIBUTION_SPACE = 1000
 
     def initialize(base_client)
       @base_client = base_client
@@ -22,9 +21,11 @@ module Prefab
       return is_on?(get(feature_name, lookup_key, attributes))
     end
 
-    def get(feature_name, lookup_key, attributes)
+    def get(feature_name, lookup_key=nil, attributes={})
       feature_obj = @base_client.config_client.get(feature_name)
-      variants = @base_client.config_client.get_config_obj(feature_name).variants
+      config_obj = @base_client.config_client.get_config_obj(feature_name)
+      return nil if feature_obj.nil? || config_obj.nil?
+      variants = config_obj.variants
       evaluate(feature_name, lookup_key, attributes, feature_obj, variants)
     end
 
@@ -39,6 +40,9 @@ module Prefab
         return false
       end
       variant.bool
+    rescue
+      @base_client.log.info("is_on? methods only work for boolean feature flags variants. This feature flags variant is '#{variant}'. Returning false")
+      false
     end
 
     def get_variant(feature_name, lookup_key, attributes, feature_obj, variants)
@@ -46,8 +50,6 @@ module Prefab
         return get_variant_obj(variants, feature_obj.inactive_variant_idx)
       end
 
-      variant_distribution = feature_obj.default
-
       # if user_targets.match
       feature_obj.user_targets.each do |target|
         if (target.identifiers.include? lookup_key)
@@ -55,34 +57,37 @@ module Prefab
         end
       end
 
+      #default to inactive
+      variant_weights = [Prefab::VariantWeight.new(variant_idx: feature_obj.inactive_variant_idx, weight: 1)]
+
       # if rules.match
       feature_obj.rules.each do |rule|
         if criteria_match?(rule, lookup_key, attributes)
-          variant_distribution = rule.distribution
+          variant_weights = rule.variant_weights
+          break
         end
       end
 
-      if variant_distribution.type == :variant_idx
-        variant_idx = variant_distribution.variant_idx
-      else
-        percent_through_distribution = rand()
-        if lookup_key
-          percent_through_distribution = get_user_pct(feature_name, lookup_key)
-        end
-        distribution_bucket = DISTRIBUTION_SPACE * percent_through_distribution
 
-        variant_idx = get_variant_idx_from_weights(variant_distribution.variant_weights.weights, distribution_bucket, feature_name)
+      percent_through_distribution = rand()
+      if lookup_key
+        percent_through_distribution = get_user_pct(feature_name, lookup_key)
       end
 
+      variant_idx = get_variant_idx_from_weights(variant_weights, percent_through_distribution, feature_name)
+
       return get_variant_obj(variants, variant_idx)
     end
 
     def get_variant_obj(variants, idx)
-      return variants[idx] if variants.length >= idx
+      # our array is 0 based, but the idx are 1 based so the protos are clearly set
+      return variants[idx - 1] if variants.length >= idx
       nil
     end
 
-    def get_variant_idx_from_weights(variant_weights, bucket, feature_name)
+    def get_variant_idx_from_weights(variant_weights, percent_through_distribution, feature_name)
+      distrubution_space = variant_weights.inject(0) { |sum, v| sum + v.weight }
+      bucket = distrubution_space * percent_through_distribution
       sum = 0
       variant_weights.each do |variant_weight|
         if bucket < sum + variant_weight.weight
@@ -93,7 +98,7 @@ module Prefab
       end
       # variants didn't add up to 100%
       @base_client.log.info("Variants of #{feature_name} did not add to 100%")
-      return variant_weights.last.variant
+      return variant_weights.last.variant_idx
     end
 
     def get_user_pct(feature, lookup_key)
@@ -103,14 +108,21 @@ module Prefab
     end
 
     def criteria_match?(rule, lookup_key, attributes)
-      if rule.criteria.operator == :IN
+
+      if rule.criteria.operator == :ALWAYS_TRUE
+        return true
+      elsif rule.criteria.operator == :LOOKUP_KEY_IN
         return rule.criteria.values.include?(lookup_key)
-      elsif rule.criteria.operator == :NOT_IN
+      elsif rule.criteria.operator == :LOOKUP_KEY_NOT_IN
         return !rule.criteria.values.include?(lookup_key)
       elsif rule.criteria.operator == :IN_SEG
         return segment_matches(rule.criteria.values, lookup_key, attributes).any?
       elsif rule.criteria.operator == :NOT_IN_SEG
         return segment_matches(rule.criteria.values, lookup_key, attributes).none?
+      elsif rule.criteria.operator == :PROP_IS_ONE_OF
+        return rule.criteria.values.include?(attributes[rule.criteria.property]) || rule.criteria.values.include?(attributes[rule.criteria.property.to_sym])
+      elsif rule.criteria.operator == :PROP_IS_NOT_ONE_OF
+        return !(rule.criteria.values.include?(attributes[rule.criteria.property]) || rule.criteria.values.include?(attributes[rule.criteria.property.to_sym]))
       end
       @base_client.log.info("Unknown Operator")
       false

data/lib/prefab_pb.rb

@@ -24,6 +24,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     end
     add_message "prefab.Configs" do
       repeated :configs, :message, 1, "prefab.Config"
+      optional :config_service_pointer, :message, 2, "prefab.ConfigServicePointer"
     end
     add_message "prefab.Config" do
       optional :id, :int64, 1
@@ -90,15 +91,19 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     end
     add_enum "prefab.Criteria.CriteriaOperator" do
       value :NOT_SET, 0
-      value :IN, 1
-      value :NOT_IN, 2
-      value :EQ, 3
-      value :IN_SEG, 4
-      value :NOT_IN_SEG, 5
+      value :LOOKUP_KEY_IN, 1
+      value :LOOKUP_KEY_NOT_IN, 2
+      value :IN_SEG, 3
+      value :NOT_IN_SEG, 4
+      value :ALWAYS_TRUE, 5
+      value :PROP_IS_ONE_OF, 6
+      value :PROP_IS_NOT_ONE_OF, 7
+      value :PROP_ENDS_WITH_ONE_OF, 8
+      value :PROP_DOES_NOT_END_WITH_ONE_OF, 9
     end
     add_message "prefab.Rule" do
       optional :criteria, :message, 1, "prefab.Criteria"
-      optional :distribution, :message, 2, "prefab.VariantDistribution"
+      repeated :variant_weights, :message, 2, "prefab.VariantWeight"
     end
     add_message "prefab.Segment" do
       optional :name, :string, 1
@@ -115,19 +120,9 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :weight, :int32, 1
       optional :variant_idx, :int32, 2
     end
-    add_message "prefab.VariantWeights" do
-      repeated :weights, :message, 1, "prefab.VariantWeight"
-    end
-    add_message "prefab.VariantDistribution" do
-      oneof :type do
-        optional :variant_idx, :int32, 1
-        optional :variant_weights, :message, 2, "prefab.VariantWeights"
-      end
-    end
     add_message "prefab.FeatureFlag" do
       optional :active, :bool, 1
       optional :inactive_variant_idx, :int32, 2
-      optional :default, :message, 3, "prefab.VariantDistribution"
       repeated :user_targets, :message, 4, "prefab.UserTarget"
       repeated :rules, :message, 5, "prefab.Rule"
     end
@@ -212,8 +207,6 @@ module Prefab
   Segment = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Segment").msgclass
   UserTarget = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.UserTarget").msgclass
   VariantWeight = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.VariantWeight").msgclass
-  VariantWeights = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.VariantWeights").msgclass
-  VariantDistribution = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.VariantDistribution").msgclass
   FeatureFlag = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.FeatureFlag").msgclass
   LimitDefinition = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitDefinition").msgclass
   LimitDefinition::SafetyLevel = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitDefinition.SafetyLevel").enummodule

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.10.0 ruby lib
+# stub: prefab-cloud-ruby 0.11.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.10.0"
+  s.version = "0.11.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 = "2022-03-23"
+  s.date = "2022-05-05"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [

data/test/harness_server.rb

@@ -15,18 +15,18 @@ class RackApp
 
     key = props["key"]
     namespace = props["namespace"]
-    project_env_id = props["project_env_id"]
+    api_key = props["api_key"]
     user_key = props["user_key"]
     is_feature_flag = !props["feature_flag"].nil?
-
+    puts props
     client = Prefab::Client.new(
-      api_key: "1-#{project_env_id}-local_development_api_key-SDK", #sets environment
+      api_key: api_key,
       namespace: namespace,
     )
 
     puts "Key #{key}"
     puts "User #{user_key}"
-    puts "project_env_id #{project_env_id}"
+    puts "api_key #{api_key}"
     puts "Namespace #{namespace}"
     puts "Props! #{props}"
     puts "is_feature_flag! #{is_feature_flag}"

data/test/test_config_resolver.rb

@@ -117,12 +117,12 @@ class TestConfigResolver < Minitest::Test
         rows: [
           { value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
             inactive_variant_idx: 0,
-            default: Prefab::VariantDistribution.new(variant_idx: 1)
+            rules: default_ff_rule(1),
           )) },
           { project_env_id: TEST_ENV_ID,
             value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
               inactive_variant_idx: 0,
-              default: Prefab::VariantDistribution.new(variant_idx: 2)
+              rules: default_ff_rule(2),
             )) }
         ]
       )
@@ -189,7 +189,10 @@ class TestConfigResolver < Minitest::Test
   end
 
   def resolver_for_namespace(namespace, loader, project_env_id: TEST_ENV_ID)
-    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace, project_env_id: project_env_id), loader)
+    resolver = Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace), loader)
+    resolver.project_env_id = project_env_id
+    resolver.update
+    resolver
   end
 
 end

data/test/test_feature_flag_client.rb

@@ -19,22 +19,29 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: 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, variants)
+    # "1FlagNamehashes low" hashes to 44.547% through dist
     assert_equal true,
                  @client.evaluate(feature, "hashes low", [], flag, variants)
+
   end
 
   def test_basic_active_inactive
@@ -45,8 +52,8 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: 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, variants)
@@ -59,8 +66,8 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: false,
-      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, variants)
@@ -78,12 +85,12 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      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",
@@ -103,15 +110,27 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      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",
@@ -121,6 +140,50 @@ class TestFeatureFlagClient < Minitest::Test
 
   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
+
   def test_segment_match?
     segment = Prefab::Segment.new(
       name: "Beta Group",
@@ -136,10 +199,10 @@ class TestFeatureFlagClient < Minitest::Test
   def test_segments
     segment_key = "prefab-segment-beta-group"
     @mock_base_client.config_client.mock_this_config(segment_key,
-                                       Prefab::Segment.new(
-                                         name: "Beta Group",
-                                         includes: ["user:1"]
-                                       )
+                                                     Prefab::Segment.new(
+                                                       name: "Beta Group",
+                                                       includes: ["user:1"]
+                                                     )
     )
 
     feature = "FlagName"
@@ -150,15 +213,27 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      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",
@@ -171,19 +246,19 @@ class TestFeatureFlagClient < Minitest::Test
   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(
-                                         name: "Segment-1",
-                                         includes: ["user:1", "user:2"],
-                                         excludes: ["user:3"]
-                                       )
+                                                     Prefab::Segment.new(
+                                                       name: "Segment-1",
+                                                       includes: ["user:1", "user:2"],
+                                                       excludes: ["user:3"]
+                                                     )
     )
     segment_key_two = "prefab-segment-segment-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"]
-                                       )
+                                                     Prefab::Segment.new(
+                                                       name: "Segment-2",
+                                                       includes: ["user:3", "user:4"],
+                                                       excludes: ["user:2"]
+                                                     )
     )
 
     feature = "FlagName"
@@ -194,15 +269,26 @@ class TestFeatureFlagClient < Minitest::Test
     ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      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",
@@ -217,4 +303,5 @@ class TestFeatureFlagClient < Minitest::Test
                  @client.evaluate(feature, "user:5", [], flag, variants)
 
   end
+
 end

data/test/test_helper.rb

@@ -5,10 +5,10 @@ class MockBaseClient
   STAGING_ENV_ID = 1
   PRODUCTION_ENV_ID = 2
   TEST_ENV_ID = 3
-  attr_reader :namespace, :logger, :project_env_id, :config_client
+  attr_reader :namespace, :logger, :config_client
+
+  def initialize(namespace: "")
 
-  def initialize(project_env_id: TEST_ENV_ID, namespace: "")
-    @project_env_id = project_env_id
     @namespace = namespace
     @logger = Logger.new($stdout)
     @config_client = MockConfigClient.new
@@ -18,8 +18,8 @@ class MockBaseClient
     1
   end
 
-  def project_env_id
-    @project_env_id
+  def log
+    @logger
   end
 
   def log_internal level, message
@@ -52,3 +52,18 @@ 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby