prefab-cloud-ruby 0.20.0 → 0.22.0

data/test/test_feature_flag_client.rb

@@ -1,366 +1,54 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 
 class TestFeatureFlagClient < Minitest::Test
+  DEFAULT = 'default'
 
-  def setup
-    super
-    @mock_base_client = MockBaseClient.new
-    @client = Prefab::FeatureFlagClient.new(@mock_base_client)
-    Prefab::FeatureFlagClient.send(:public, :is_on?) #publicize for testing
-    Prefab::FeatureFlagClient.send(:public, :segment_match?) #publicize for testing
-    Prefab::FeatureFlagClient.send(:public, :get_variant) #publicize for testing
-  end
-
-  def test_pct
-    feature = "FlagName"
-
-    variants = [
-      Prefab::FeatureFlagVariant.new(bool: false),
-      Prefab::FeatureFlagVariant.new(bool: true)
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: true,
-      inactive_variant_idx: 1,
-      rules: [
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 86,
-                                      variant_idx: 2), #true
-            Prefab::VariantWeight.new(weight: 14,
-                                      variant_idx: 1), #false
-          ]
-        )
-      ]
-    )
-    # weights above chosen to be 86% in variant_idx 2. and 14% in variant_idx 1.
-    # since hashes high is 86.32 > 86 it just falls outside the 86% range and gets false
-
-    # "FlagNamevery high hash" hashes to 88.8602812% through dist
-    assert_equal false,
-                 evaluate(feature, "very high hash", [], flag, variants)
-    # "FlagNamehashes low" hashes to 42.7934% through dist
-    assert_equal true,
-                 evaluate(feature, "hashes low", [], flag, variants)
-
-  end
-
-  def test_basic_active_inactive
-    feature = "FlagName"
-    variants = [
-      Prefab::FeatureFlagVariant.new(bool: false),
-      Prefab::FeatureFlagVariant.new(bool: true)
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: true,
-      inactive_variant_idx: 1,
-      rules: default_ff_rule(2)
-    )
-    assert_equal true,
-                 evaluate(feature, "hashes high", [], flag, variants)
-    assert_equal true,
-                 evaluate(feature, "hashes low", [], flag, variants)
+  def test_feature_is_on
+    ff_client = new_client
 
-    variants = [
-      Prefab::FeatureFlagVariant.new(bool: false),
-      Prefab::FeatureFlagVariant.new(bool: true)
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: false,
-      inactive_variant_idx: 1,
-      rules: default_ff_rule(2)
-    )
-    assert_equal false,
-                 evaluate(feature, "hashes high", [], flag, variants)
-    assert_equal false,
-                 evaluate(feature, "hashes low", [], flag, variants)
+    assert_equal false, ff_client.feature_is_on?('something-that-does-not-exist')
+    assert_equal false, ff_client.feature_is_on?('disabled_flag')
+    assert_equal true, ff_client.feature_is_on?('enabled_flag')
+    assert_equal false, ff_client.feature_is_on?('flag_with_a_value')
   end
 
-  def test_inclusion_rule
-    feature = "FlagName"
-    variants = [
-      Prefab::FeatureFlagVariant.new(string: "inactive"),
-      Prefab::FeatureFlagVariant.new(string: "rule target"),
-      Prefab::FeatureFlagVariant.new(string: "default"),
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: true,
-      inactive_variant_idx: 1,
-      rules: [
-        Prefab::Rule.new(
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 1000,
-                                      variant_idx: 2)
-          ],
-          criteria: Prefab::Criteria.new(
-            operator: "LOOKUP_KEY_IN",
-            values: ["user:1"]
-          )
-        ),
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 1000,
-                                      variant_idx: 3)
-          ]
-        )
-
-      ],
-    )
-
-    assert_equal "rule target",
-                 evaluate(feature, "user:1", [], flag, variants)
-    assert_equal "default",
-                 evaluate(feature, "user:2", [], flag, variants)
+  def test_feature_is_on_for
+    ff_client = new_client
 
+    assert_equal false, ff_client.feature_is_on_for?('something-that-does-not-exist', 'irrelevant')
+    assert_equal false, ff_client.feature_is_on_for?('in_lookup_key', 'not-included')
+    assert_equal true, ff_client.feature_is_on_for?('in_lookup_key', 'abc123')
+    assert_equal true, ff_client.feature_is_on_for?('in_lookup_key', 'xyz987')
   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",
-                 evaluate(feature, "user:1", { email: "not@example.com" }, flag, variants)
-    assert_equal "default",
-                 evaluate(feature, "user:2", {}, flag, variants)
-    assert_equal "rule target",
-                 evaluate(feature, "user:2", { email: "b@example.com" }, flag, variants)
-    assert_equal "rule target",
-                 evaluate(feature, "user:2", { "email" => "b@example.com" }, flag, variants)
+  def test_get
+    ff_client = new_client
 
-  end
+    # No default
+    assert_equal false, ff_client.get('something-that-does-not-exist')
+    assert_equal false, ff_client.get('disabled_flag')
+    assert_equal true, ff_client.get('enabled_flag')
+    assert_equal 'all-features', ff_client.get('flag_with_a_value')
 
-  def test_segment_match?
-    segment = Prefab::Segment.new(
-      criterion: [
-        Prefab::Criteria.new(
-          operator: "PROP_IS_ONE_OF",
-          values: ["a@example.com", "b@example.com"],
-          property: "email"
-        ),
-        Prefab::Criteria.new(
-          operator: "LOOKUP_KEY_IN",
-          values: ["user:2"]
-        )
-      ]
-    )
-    assert_equal false, @client.segment_match?(segment, "user:0", {})
-    assert_equal true, @client.segment_match?(segment, "user:2", {})
-    assert_equal false, @client.segment_match?(segment, "user:1", { email: "no@example.com" })
-    assert_equal true, @client.segment_match?(segment, "user:1", { email: "a@example.com" })
+    # with defaults
+    assert_equal DEFAULT, ff_client.get('something-that-does-not-exist', default: DEFAULT)
+    assert_equal false, ff_client.get('disabled_flag', default: DEFAULT)
+    assert_equal true, ff_client.get('enabled_flag', default: DEFAULT)
+    assert_equal 'all-features', ff_client.get('flag_with_a_value', default: DEFAULT)
   end
 
-  def test_segments
-    segment_key = "prefab-segment-beta-group"
-    @mock_base_client.config_client.mock_this_config(segment_key,
-                                                     Prefab::Segment.new(
-                                                       criterion: [
-                                                         Prefab::Criteria.new(
-                                                           operator: Prefab::Criteria::CriteriaOperator::LOOKUP_KEY_IN,
-                                                           values: ["user:1"]
-                                                         )
-                                                       ]
-                                                     )
-    )
-
-    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: "IN_SEG",
-            values: [segment_key]
-          )
-        ),
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 1000,
-                                      variant_idx: 3)
-          ]
-        )
-
-      ],
-    )
-
-    assert_equal "rule target",
-                 evaluate(feature, "user:1", [], flag, variants)
-    assert_equal "default",
-                 evaluate(feature, "user:2", [], flag, variants)
+  private
 
-  end
-
-  def test_in_multiple_segments_has_or_behavior
-    segment_key_one = "prefab-segment-segment-1"
-    @mock_base_client.config_client.mock_this_config(segment_key_one,
-                                                     Prefab::Segment.new(
-                                                       criterion: [
-                                                         Prefab::Criteria.new(
-                                                           operator: Prefab::Criteria::CriteriaOperator::LOOKUP_KEY_IN,
-                                                           values: ["user:1", "user:2"]
-                                                         )
-                                                       ]
-                                                     )
-    )
-    segment_key_two = "prefab-segment-segment-2"
-    @mock_base_client.config_client.mock_this_config(segment_key_two,
-                                                     Prefab::Segment.new(
-                                                       criterion: [
-                                                         Prefab::Criteria.new(
-                                                           operator: Prefab::Criteria::CriteriaOperator::LOOKUP_KEY_IN,
-                                                           values: ["user:3", "user:4"]
-                                                         )
-                                                       ]
-                                                     )
-    )
-
-    feature = "FlagName"
-    variants = [
-      Prefab::FeatureFlagVariant.new(string: "inactive"),
-      Prefab::FeatureFlagVariant.new(string: "rule target"),
-      Prefab::FeatureFlagVariant.new(string: "default"),
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: true,
-      inactive_variant_idx: 1,
-      rules: [
-        Prefab::Rule.new(
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 1000,
-                                      variant_idx: 2)
-          ],
-          criteria: Prefab::Criteria.new(
-            operator: "IN_SEG",
-            values: [segment_key_one, segment_key_two]
-          )
-        ),
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 1000,
-                                      variant_idx: 3)
-          ]
-        )
-
-      ],
-    )
-
-    assert_equal "rule target",
-                 evaluate(feature, "user:1", [], flag, variants)
-    assert_equal "rule target",
-                 evaluate(feature, "user:2", [], flag, variants), "matches segment 1"
-    assert_equal "rule target",
-                 evaluate(feature, "user:3", [], flag, variants)
-    assert_equal "rule target",
-                 evaluate(feature, "user:4", [], flag, variants)
-    assert_equal "default",
-                 evaluate(feature, "user:5", [], flag, variants)
-
-  end
-
-  def test_prop_ends_with_one_of
-    feature = "FlagName"
-
-    variants = [
-      Prefab::FeatureFlagVariant.new(bool: false),
-      Prefab::FeatureFlagVariant.new(bool: true)
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: true,
-      inactive_variant_idx: 1,
-      rules: [
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::PROP_ENDS_WITH_ONE_OF,
-                                         property: "email",
-                                         values: ["@example.com"]),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 100, variant_idx: 2)
-          ]
-        )
-      ]
-    )
-
-    assert_equal false, evaluate(feature, "user:0", {}, flag, variants)
-    assert_equal true, evaluate(feature, "user:0", {email: "test@example.com"}, flag, variants)
-    assert_equal true, evaluate(feature, "user:0", {"email" => "test@example.com"}, flag, variants)
-  end
-
-  def test_prop_does_not_end_with_one_of
-    feature = "FlagName"
-
-    variants = [
-      Prefab::FeatureFlagVariant.new(bool: false),
-      Prefab::FeatureFlagVariant.new(bool: true)
-    ]
-    flag = Prefab::FeatureFlag.new(
-      active: true,
-      inactive_variant_idx: 1,
-      rules: [
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::PROP_DOES_NOT_END_WITH_ONE_OF,
-                                         property: "email",
-                                         values: ["@example.com"]),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 100, variant_idx: 2)
-          ]
-        ),
-        Prefab::Rule.new(
-          criteria: Prefab::Criteria.new(operator: Prefab::Criteria::CriteriaOperator::ALWAYS_TRUE),
-          variant_weights: [
-            Prefab::VariantWeight.new(weight: 100, variant_idx: 1)
-          ]
-        )
-      ],
-    )
-
-    assert_equal true, evaluate(feature, "user:0", {}, flag, variants)
-    assert_equal false, evaluate(feature, "user:0", {email: "test@example.com"}, flag, variants)
-    assert_equal false, evaluate(feature, "user:0", {"email" => "test@example.com"}, flag, variants)
-  end
+  def new_client(overrides = {})
+    options = Prefab::Options.new(**{
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: ['unit_tests'],
+      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+    }.merge(overrides))
 
-  def evaluate(feature_name, lookup_key, attributes, flag, variants)
-    variant = @client.get_variant(feature_name, lookup_key, attributes, flag, variants)
-    @client.value_of_variant(variant)
+    Prefab::Client.new(options).feature_flag_client
   end
 end

data/test/test_helper.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
+
 require 'minitest/autorun'
-require "minitest/focus"
+require 'minitest/focus'
+require 'minitest/reporters'
+Minitest::Reporters.use!
+
 require 'prefab-cloud-ruby'
 
 class MockBaseClient
   STAGING_ENV_ID = 1
   PRODUCTION_ENV_ID = 2
   TEST_ENV_ID = 3
-  attr_reader :namespace, :logger, :config_client, :options
+  attr_reader :namespace
+  attr_reader :logger
+  attr_reader :config_client
+  attr_reader :options
 
   def initialize(options = Prefab::Options.new)
     @options = options
@@ -24,20 +31,19 @@ class MockBaseClient
     @logger
   end
 
-  def log_internal level, message
-  end
+  def log_internal(level, message); end
 
-  def config_value key
+  def config_value(key)
     @config_values[key]
   end
-
 end
 
 class MockConfigClient
   def initialize(config_values = {})
     @config_values = config_values
   end
-  def get(key, default=nil)
+
+  def get(key, default = nil)
     @config_values.fetch(key, default)
   end
 
@@ -45,17 +51,15 @@ class MockConfigClient
     Prefab::Config.new(value: @config_values[key], key: key)
   end
 
-  def mock_this_config key, config_value
+  def mock_this_config(key, config_value)
     @config_values[key] = config_value
   end
 end
 
 class MockConfigLoader
-  def calc_config
-  end
+  def calc_config; end
 end
 
-
 private
 
 def default_ff_rule(variant_idx)
@@ -81,9 +85,9 @@ end
 
 def new_client(overrides = {})
   options = Prefab::Options.new(**{
-    prefab_config_override_dir: "none",
-    prefab_config_classpath_dir: "test",
-    prefab_envs: ["unit_tests"],
+    prefab_config_override_dir: 'none',
+    prefab_config_classpath_dir: 'test',
+    prefab_envs: ['unit_tests'],
     prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
   }.merge(overrides))
 

data/test/test_integration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'integration_test_helpers'
+require 'integration_test'
+require 'yaml'
+
+class TestIntegration < Minitest::Test
+  IntegrationTestHelpers.find_integration_tests.map do |test_file|
+    tests = YAML.load(File.read(test_file))['tests']
+
+    tests.each do |test|
+      define_method(:"test_#{test['name']}") do
+        it = IntegrationTest.new(test)
+
+        case it.test_type
+        when :raise
+          err = assert_raises(it.expected[:error]) do
+            it.test_client.send(it.func, *it.input)
+          end
+          assert_match(/#{it.expected[:message]}/, err.message)
+        when :nil
+          assert_nil it.test_client.send(it.func, *it.input)
+        when :feature_flag
+          flag, lookup_key, attributes = *it.input
+          assert_equal it.expected[:value], it.test_client.send(it.func, flag, lookup_key, attributes: attributes)
+        when :simple_equality
+          assert_equal it.expected[:value], it.test_client.send(it.func, *it.input)
+        end
+      end
+    end
+  end
+end

data/test/test_local_config_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestLocalConfigParser < Minitest::Test
+  FILE_NAME = 'example-config.yaml'
+  DEFAULT_MATCH = 'default'
+
+  def test_parse_int_config
+    key = :sample_int
+    parsed = Prefab::LocalConfigParser.parse(key, 123, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal DEFAULT_MATCH, parsed[:match]
+    assert_equal :CONFIG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+    assert_equal 123, config.rows[0].values[0].value.int
+  end
+
+  def test_flag_with_a_value
+    key = :flag_with_a_value
+    value = stringify_keys({ feature_flag: true, value: 'all-features' })
+    parsed = Prefab::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal key, parsed[:match]
+    assert_equal :FEATURE_FLAG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+
+    value_row = config.rows[0].values[0]
+    assert_equal Prefab::WeightedValues, value_row.value.weighted_values.class
+    assert_equal 'all-features', Prefab::ConfigValueUnwrapper.unwrap(value_row.value, key, {})
+  end
+
+  def test_flag_in_lookup_key
+    key = :flag_in_lookup_key
+    value = stringify_keys({ "feature_flag": 'true', value: true,
+                             criterion: { operator: 'LOOKUP_KEY_IN', values: %w[abc123 xyz987] } })
+    parsed = Prefab::LocalConfigParser.parse(key, value, {}, FILE_NAME)[key]
+    config = parsed[:config]
+
+    assert_equal FILE_NAME, parsed[:source]
+    assert_equal key, parsed[:match]
+    assert_equal :FEATURE_FLAG, config.config_type
+    assert_equal key.to_s, config.key
+    assert_equal 1, config.rows.size
+    assert_equal 1, config.rows[0].values.size
+    assert_equal 1, config.rows[0].values[0].criteria.size
+
+    value_row = config.rows[0].values[0]
+    assert_equal Prefab::WeightedValues, value_row.value.weighted_values.class
+    assert_equal true, Prefab::ConfigValueUnwrapper.unwrap(value_row.value, key, {})
+
+    assert_equal Prefab::CriteriaEvaluator::LOOKUP_KEY, value_row.criteria[0].property_name
+    assert_equal :LOOKUP_KEY_IN, value_row.criteria[0].operator
+    assert_equal %w[abc123 xyz987], value_row.criteria[0].value_to_match.string_list.values
+  end
+
+  private
+
+  def stringify_keys(hash)
+    deep_transform_keys(hash, &:to_s)
+  end
+
+  def deep_transform_keys(hash, &block)
+    result = {}
+    hash.each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? deep_transform_keys(value, &block) : value
+    end
+    result
+  end
+end

data/test/test_log_path_collector.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestLogPathCollector < Minitest::Test
+  def test_sync
+    Timecop.freeze do
+      client = new_client(namespace: 'this.is.a.namespace')
+
+      2.times { client.log.info('here is a message') }
+      3.times { client.log.error('here is a message') }
+
+      requests = []
+
+      client.define_singleton_method(:request) do |*params|
+        requests.push(params)
+      end
+
+      client.log_path_collector.send(:sync)
+
+      # let the flush thread run
+      sleep 0.01 while requests.length == 0
+
+      assert_equal requests, [[
+        Prefab::LoggerReportingService,
+        :send,
+        {
+          req_options: {},
+          params: Prefab::Loggers.new(
+            loggers: [Prefab::Logger.new(logger_name: 'test.test_log_path_collector.test_sync',
+                                         infos: 2, errors: 3)],
+            start_at: (Time.now.utc.to_f * 1000).to_i,
+            end_at: (Time.now.utc.to_f * 1000).to_i,
+            instance_hash: client.instance_hash,
+            namespace: 'this.is.a.namespace'
+          )
+        }
+      ]]
+    end
+  end
+
+  private
+
+  def new_client(overrides = {})
+    options = Prefab::Options.new(**{
+      prefab_config_override_dir: 'none',
+      prefab_config_classpath_dir: 'test',
+      prefab_envs: ['unit_tests'],
+      api_key: '123-development-yourapikey-SDK',
+      collect_sync_interval: 1000 # we'll trigger sync manually in our test
+    }.merge(overrides))
+
+    Prefab::Client.new(options)
+  end
+end