prefab-cloud-ruby 0.5.0 → 0.7.0

data/test/harness_server.rb

@@ -0,0 +1,46 @@
+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", #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]
+  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::ConfigDelta.new(id: 1, key: "sample_int", default: 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::ConfigDelta.new(id: 5, key: "sample_int", default: 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::ConfigDelta.new(id: 2, key: "sample_int", default: 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::ConfigDelta.new(id: 1, key: "sample_int", default: 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::ConfigDelta.new(id: 4, key: "sample_int", default: 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::ConfigDelta.new(id: 2, key: "sample_int", default: Prefab::ConfigValue.new(int: 2)))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -43,13 +43,13 @@ 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::ConfigDelta.new(key: "sample_int", default: 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)
+    delta = Prefab::ConfigDelta.new(key: "sample_int", default: val)
     @loader.set(delta)
 
     deltas = Prefab::ConfigDeltas.new
@@ -59,10 +59,10 @@ class TestConfigLoader < Minitest::Test
 
   def test_loading_tombstones_removes_entries
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", value: val)
+    delta = Prefab::ConfigDelta.new(key: "sample_int", default: val)
     @loader.set(delta)
 
-    delta = Prefab::ConfigDelta.new(key: "sample_int", value: nil)
+    delta = Prefab::ConfigDelta.new(key: "sample_int", default: nil)
     @loader.set(delta)
 
     deltas = Prefab::ConfigDeltas.new
@@ -72,8 +72,8 @@ class TestConfigLoader < Minitest::Test
   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].default.type
+    assert_equal value, @loader.calc_config[key].default.send(type)
   end
 
 end

data/test/test_config_resolver.rb

@@ -6,17 +6,46 @@ 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::ConfigDelta.new(
+        key: "key",
+        default: Prefab::ConfigValue.new(string: "value_no_env_default"),
+        envs: [{
+                 environment: "test",
+                 default: Prefab::ConfigValue.new(string: "value_none"),
+                 namespace_values: [
+                   {
+                     namespace: "projectA",
+                     config_value: Prefab::ConfigValue.new(string: "valueA")
+                   },
+                   {
+                     namespace: "projectB",
+                     config_value: Prefab::ConfigValue.new(string: "valueB")
+                   },
+                   {
+                     namespace: "projectB.subprojectX",
+                     config_value: Prefab::ConfigValue.new(string: "projectB.subprojectX")
+                   },
+                   {
+                     namespace: "projectB.subprojectY",
+                     config_value: Prefab::ConfigValue.new(string: "projectB.subprojectY")
+                   },
+                 ]
+               }]
+      ),
+      "key2" => Prefab::ConfigDelta.new(
+        key: "key2",
+        default: 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 +56,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 +72,69 @@ 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::ConfigDelta.new(
+        key: "ff",
+        default: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+          variants: [
+            Prefab::FeatureFlagVariant.new(string: "inactive"),
+            Prefab::FeatureFlagVariant.new(string: "default"),
+            Prefab::FeatureFlagVariant.new(string: "env"),
+          ],
+          inactive_variant_idx: 0,
+          default: Prefab::VariantDistribution.new(variant_idx: 1)
+        )),
+        envs: [
+          Prefab::EnvironmentValues.new(
+            environment: "test",
+            default: 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)
+      ff = resolver.get("ff")
+      assert_equal 3, ff.variants.size
+      assert_equal %w(inactive default env), ff.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::ConfigDelta.new(
+        key: "Key:With:Colons",
+        default: Prefab::ConfigValue.new(string: "value"),
+      ),
+      "proj:apikey" => Prefab::ConfigDelta.new(
+        key: "proj:apikey",
+        default: Prefab::ConfigValue.new(string: "v2"),
+      )
     }
 
     @loader.stub :calc_config, loaded_values do
@@ -72,37 +143,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)
+
+    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),
+                                                 ]
+                                                 )
+      )
+    )
 
     assert_equal false,
-                 client.is_on?(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag)
+    assert_equal true,
+                 @client.evaluate(feature, "hashes low", [], flag)
+  end
 
+  def test_basic_active_inactive
+    feature = "FlagName"
+    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)
+    )
+    assert_equal true,
+                 @client.evaluate(feature, "hashes high", [], flag)
     assert_equal true,
-                 client.is_on?(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag)
+
+    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)
+    )
+    assert_equal false,
+                 @client.evaluate(feature, "hashes high", [], flag)
+    assert_equal false,
+                 @client.evaluate(feature, "hashes low", [], flag)
   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)
+    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,
+      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)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:2", [], flag)
+    assert_equal "user target",
+                 @client.evaluate(feature, "user:3", [], flag)
+  end
+
+  def test_inclusion_rule
+    feature = "FlagName"
+    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"]
+        )
+      )],
+      default: Prefab::VariantDistribution.new(variant_idx: 2)
+    )
+
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:1", [], flag)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:2", [], flag)
 
-    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)
+    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]
+        )
+      )],
+      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)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:2", [], flag)
 
-    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"])
+    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]
+        )
+      )],
+      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)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:2", [], flag), "matches segment 1"
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:3", [], flag)
+    assert_equal "rule target",
+                 @client.evaluate(feature, "user:4", [], flag)
+    assert_equal "default",
+                 @client.evaluate(feature, "user:5", [], flag)
 
   end
 end

data/test/test_helper.rb

@@ -2,19 +2,29 @@ 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
 end
 
 class MockConfigLoader