prefab-cloud-ruby 0.6.0 → 0.9.0

data/test/harness_server.rb

@@ -0,0 +1,51 @@
+require 'prefab-cloud-ruby'
+require 'rack'
+require 'base64'
+require 'json'
+
+handler = Rack::Handler::Thin
+
+#
+# This is a very lightweight server that allows the compliance harness to excercise the prefab client
+#
+class RackApp
+  def call(env)
+    props = CGI::parse(env["QUERY_STRING"])
+    props = JSON.parse(Base64.decode64(props["props"][0]))
+
+    key = props["key"]
+    namespace = props["namespace"]
+    environment = props["environment"]
+    user_key = props["user_key"]
+    is_feature_flag = !props["feature_flag"].nil?
+
+    client = Prefab::Client.new(
+      api_key: "1-#{environment}-local_development_api_key-SDK", #sets environment
+      namespace: namespace,
+    )
+
+    puts "Key #{key}"
+    puts "User #{user_key}"
+    puts "Environment #{environment}"
+    puts "Namespace #{namespace}"
+    puts "Props! #{props}"
+    puts "is_feature_flag! #{is_feature_flag}"
+
+    if is_feature_flag
+      puts "EVALFF #{key} #{user_key}"
+      rtn = client.feature_flag_client.get(key, user_key, []).to_s
+    else
+      rtn = client.config_client.get(key).to_s
+    end
+    puts "return #{rtn}"
+
+    [200, { "Content-Type" => "text/plain" }, rtn]
+
+    rescue Exception => e
+      puts "ERROR #{e.message}"
+      puts e.backtrace
+      [500, { "Content-Type" => "text/plain" }, e.message]
+  end
+end
+
+handler.run RackApp.new

data/test/test_config_loader.rb

@@ -16,26 +16,26 @@ class TestConfigLoader < Minitest::Test
 
   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))]))
     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))]))
     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))]))
     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))]))
     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))]))
     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))]))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -43,37 +43,37 @@ 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))]))
     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)
 
-    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)])
+    @loader.set(config)
 
-    delta = Prefab::ConfigDelta.new(key: "sample_int", value: nil)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [])
+    @loader.set(config)
 
-    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].rows[0].value.type
+    assert_equal value, @loader.calc_config[key].rows[0].value.send(type)
   end
 
 end

data/test/test_config_resolver.rb

@@ -6,17 +6,55 @@ class TestConfigResolver < Minitest::Test
     @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" => Prefab::Config.new(
+        key: "key",
+        rows: [
+          Prefab::ConfigRow.new(
+            value: Prefab::ConfigValue.new(string: "value_no_env_default"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            value: Prefab::ConfigValue.new(string: "value_none"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectA",
+            value: Prefab::ConfigValue.new(string: "valueA"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectB",
+            value: Prefab::ConfigValue.new(string: "valueB"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectB.subprojectX",
+            value: Prefab::ConfigValue.new(string: "projectB.subprojectX"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectB.subprojectY",
+            value: Prefab::ConfigValue.new(string: "projectB.subprojectY"),
+          ),
+
+        ]
+      ),
+      "key2" => 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, environment: "some_other_env")
+      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 +65,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 +81,72 @@ 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" => 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,
+            default: Prefab::VariantDistribution.new(variant_idx: 1)
+          )) },
+          { env_key: "test",
+            value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+              inactive_variant_idx: 0,
+              default: Prefab::VariantDistribution.new(variant_idx: 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" => Prefab::Config.new(
+        key: "Key:With:Colons",
+        rows: [Prefab::ConfigRow.new(
+          value: Prefab::ConfigValue.new(string: "value")
+        )]
+      ),
+      "proj:apikey" => 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 +155,36 @@ 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, environment: "test")
+    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace, environment: environment), loader)
   end
 
 end

data/test/test_feature_flag_client.rb

@@ -2,63 +2,219 @@ 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
+  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: 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),
+                                                 ]
+                                                 )
+      )
+    )
 
     assert_equal false,
-                 client.is_on?(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
+    assert_equal true,
+                 @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,
+      inactive_variant_idx: 0,
+      default: Prefab::VariantDistribution.new(variant_idx: 1)
+    )
+    assert_equal true,
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal true,
-                 client.is_on?(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,
+      inactive_variant_idx: 0,
+      default: Prefab::VariantDistribution.new(variant_idx: 1)
+    )
+    assert_equal false,
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
+    assert_equal false,
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
   end
 
+  def test_user_targets
 
-  def test_off
-    client = Prefab::FeatureFlagClient.new(MockBaseClient.new)
-    Prefab::FeatureFlagClient.send(:public, :is_on?)
     feature = "FlagName"
-    flag = Prefab::FeatureFlag.new(pct: 0)
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "user target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
+    flag = Prefab::FeatureFlag.new(
+      active: true,
+      inactive_variant_idx: 0,
+      user_targets: [
+        variant_idx: 1,
+        identifiers: ["user:1", "user:3"]
+      ],
+      default: Prefab::VariantDistribution.new(variant_idx: 2)
+    )
 
-    assert_equal false,
-                 client.is_on?(feature, "hashes high", [], flag)
+    assert_equal "user target",
+                 @client.evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:2", [], flag, variants)
+    assert_equal "user target",
+                 @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,
+      inactive_variant_idx: 0,
+      rules: [Prefab::Rule.new(
+        distribution: Prefab::VariantDistribution.new(variant_idx: 1),
+        criteria: Prefab::Criteria.new(
+          operator: "IN",
+          values: ["user:1"]
+        )
+      )],
+      default: Prefab::VariantDistribution.new(variant_idx: 2)
+    )
+
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:2", [], flag, variants)
 
-    assert_equal false,
-                 client.is_on?(feature, "hashes low", [], flag)
   end
 
+  def test_segment_match?
+    segment = Prefab::Segment.new(
+      name: "Beta Group",
+      includes: ["user:1", "user:5"],
+      excludes: ["user:1", "user:2"]
+    )
+    assert_equal false, @client.segment_match?(segment, "user:0", {})
+    assert_equal false, @client.segment_match?(segment, "user:1", {})
+    assert_equal false, @client.segment_match?(segment, "user:2", {})
+    assert_equal true, @client.segment_match?(segment, "user:5", {})
+  end
+
+  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"]
+                                       )
+    )
 
-  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: 0,
+      rules: [Prefab::Rule.new(
+        distribution: Prefab::VariantDistribution.new(variant_idx: 1),
+        criteria: Prefab::Criteria.new(
+          operator: "IN_SEG",
+          values: [segment_key]
+        )
+      )],
+      default: Prefab::VariantDistribution.new(variant_idx: 2)
+    )
 
-    assert_equal true,
-                 client.is_on?(feature, "hashes high", [], flag)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "default",
+                 @client.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.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"]
+                                       )
+    )
+
     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: 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]
+        )
+      )],
+      default: Prefab::VariantDistribution.new(variant_idx: 2)
+    )
 
-    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",
+                 @client.evaluate(feature, "user:1", [], flag, variants)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:2", [], flag, variants), "matches segment 1"
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:3", [], flag, variants)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:4", [], flag, variants)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:5", [], flag, variants)
 
   end
 end

data/test/test_helper.rb

@@ -2,19 +2,34 @@ require 'minitest/autorun'
 require 'prefab-cloud-ruby'
 
 class MockBaseClient
-  attr_reader :namespace, :logger
+  attr_reader :namespace, :logger, :environment
 
-  def initialize(namespace: "")
+  def initialize(environment: "test", namespace: "")
+    @environment = environment
     @namespace = namespace
     @logger = Logger.new($stdout)
+    @config_values = {}
   end
 
-  def account_id
+  def project_id
     1
   end
 
   def log_internal level, message
   end
+
+  def mock_this_config key, config_value
+    @config_values[key] = config_value
+  end
+
+  def get(key)
+    @config_values[key]
+  end
+
+  def get_config(key)
+    puts "HELLOOOO"
+    @config_values[key]
+  end
 end
 
 class MockConfigLoader