prefab-cloud-ruby 0

data/test/test_encryption.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestEncryption < Minitest::Test
+  def test_encryption
+    secret = Prefab::Encryption.generate_new_hex_key
+
+    enc = Prefab::Encryption.new(secret)
+
+    clear_text = "hello world"
+    encrypted = enc.encrypt(clear_text)
+    decrypted = enc.decrypt(encrypted)
+    assert_equal clear_text, decrypted
+  end
+end

data/test/test_evaluation_summary_aggregator.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestEvaluationSummaryAggregator < Minitest::Test
+  EFFECTIVELY_NEVER = 99_999 # we sync manually
+
+  EXAMPLE_VALUE_1 = PrefabProto::ConfigValue.new(bool: true)
+  EXAMPLE_VALUE_2 = PrefabProto::ConfigValue.new(bool: false)
+
+  EXAMPLE_COUNTER = {
+    config_id: 1,
+    selected_index: 2,
+    config_row_index: 3,
+    conditional_value_index: 4,
+    weighted_value_index: 5,
+    seleced_value: EXAMPLE_VALUE_1
+  }.freeze
+
+  def test_increments_counts
+    aggregator = Prefab::EvaluationSummaryAggregator.new(client: MockBaseClient.new, max_keys: 10,
+                                                         sync_interval: EFFECTIVELY_NEVER)
+
+    aggregator.record(config_key: 'foo', config_type: 'bar', counter: EXAMPLE_COUNTER)
+
+    assert_equal 1, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+
+    2.times { aggregator.record(config_key: 'foo', config_type: 'bar', counter: EXAMPLE_COUNTER) }
+    assert_equal 3, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+
+    another_counter = EXAMPLE_COUNTER.merge(selected_index: EXAMPLE_COUNTER[:selected_index] + 1)
+
+    aggregator.record(config_key: 'foo', config_type: 'bar', counter: another_counter)
+    assert_equal 3, aggregator.data[%w[foo bar]][EXAMPLE_COUNTER]
+    assert_equal 1, aggregator.data[%w[foo bar]][another_counter]
+  end
+
+  def test_prepare_data
+    aggregator = Prefab::EvaluationSummaryAggregator.new(client: MockBaseClient.new, max_keys: 10,
+                                                         sync_interval: EFFECTIVELY_NEVER)
+
+    expected = {
+      ['config-1', :CONFIG] => {
+        { config_id: 1, selected_index: 2, config_row_index: 3, conditional_value_index: 4,
+          weighted_value_index: 5, selected_value: EXAMPLE_VALUE_1 } => 3,
+        { config_id: 1, selected_index: 3, config_row_index: 7, conditional_value_index: 8,
+          weighted_value_index: 10, selected_value: EXAMPLE_VALUE_2 } => 1
+      },
+      ['config-2', :FEATURE_FLAG] => {
+        { config_id: 2, selected_index: 3, config_row_index: 5, conditional_value_index: 7,
+          weighted_value_index: 6, selected_value: EXAMPLE_VALUE_1 } => 9
+      }
+    }
+
+    add_example_data(aggregator)
+    assert_equal expected, aggregator.prepare_data
+    assert aggregator.data.empty?
+  end
+
+  def test_sync
+    awhile_ago = Time.now - 60
+    now = Time.now
+
+    client = MockBaseClient.new
+
+    aggregator = nil
+
+    Timecop.freeze(awhile_ago) do
+      # start the aggregator in the past
+      aggregator = Prefab::EvaluationSummaryAggregator.new(client: client, max_keys: 10,
+                                                           sync_interval: EFFECTIVELY_NEVER)
+    end
+
+    add_example_data(aggregator)
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          summaries:
+
+      PrefabProto::ConfigEvaluationSummaries.new(
+        start: awhile_ago.to_i * 1000,
+        end: now.to_i * 1000,
+        summaries: [
+          PrefabProto::ConfigEvaluationSummary.new(
+            key: 'config-1',
+            type: :CONFIG,
+            counters: [
+              PrefabProto::ConfigEvaluationCounter.new(
+                config_id: 1,
+                selected_index: 2,
+                config_row_index: 3,
+                conditional_value_index: 4,
+                weighted_value_index: 5,
+                selected_value: EXAMPLE_VALUE_1,
+                count: 3
+              ),
+              PrefabProto::ConfigEvaluationCounter.new(
+                config_id: 1,
+                selected_index: 3,
+                config_row_index: 7,
+                conditional_value_index: 8,
+                weighted_value_index: 10,
+                selected_value: EXAMPLE_VALUE_2,
+                count: 1
+              )
+            ]
+          ),
+          PrefabProto::ConfigEvaluationSummary.new(
+            key: 'config-2',
+            type: :FEATURE_FLAG,
+            counters: [
+              PrefabProto::ConfigEvaluationCounter.new(
+                config_id: 2,
+                selected_index: 3,
+                config_row_index: 5,
+                conditional_value_index: 7,
+                weighted_value_index: 6,
+                selected_value: EXAMPLE_VALUE_1,
+                count: 9
+              )
+            ]
+          )
+        ]
+      )
+        )
+      ]
+    )
+
+    requests = wait_for_post_requests(client) do
+      Timecop.freeze(now) do
+        aggregator.sync
+      end
+    end
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+  end
+
+  private
+
+  def add_example_data(aggregator)
+    data = {
+      ['config-1', :CONFIG] => {
+        { config_id: 1, selected_index: 2, config_row_index: 3, conditional_value_index: 4,
+          weighted_value_index: 5, selected_value: EXAMPLE_VALUE_1 } => 3,
+        { config_id: 1, selected_index: 3, config_row_index: 7, conditional_value_index: 8,
+          weighted_value_index: 10, selected_value: EXAMPLE_VALUE_2 } => 1
+      },
+      ['config-2', :FEATURE_FLAG] => {
+        { config_id: 2, selected_index: 3, config_row_index: 5, conditional_value_index: 7,
+          weighted_value_index: 6, selected_value: EXAMPLE_VALUE_1 } => 9
+      }
+    }
+
+    aggregator.instance_variable_set('@data', data)
+  end
+end

data/test/test_example_contexts_aggregator.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestExampleContextsAggregator < Minitest::Test
+  EFFECTIVELY_NEVER = 99_999 # we sync manually
+
+  def test_record
+    aggregator = Prefab::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 2,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+    assert_equal [context], aggregator.data
+
+    # This doesn't get updated because we already have a context for this user/device
+    aggregator.record(context)
+    assert_equal [context], aggregator.data
+
+    new_context = Prefab::Context.new(
+      user: { key: 'ghi', admin: true },
+      team: { key: '999' }
+    )
+
+    aggregator.record(new_context)
+    assert_equal [context, new_context], aggregator.data
+
+    # this doesn't get recorded because we're at max_contexts
+    aggregator.record(Prefab::Context.new(user: { key: 'new' }))
+    assert_equal [context, new_context], aggregator.data
+  end
+
+  def test_prepare_data
+    aggregator = Prefab::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+
+    assert_equal [context], aggregator.prepare_data
+    assert aggregator.data.empty?
+  end
+
+  def test_record_with_expiry
+    aggregator = Prefab::ExampleContextsAggregator.new(client: MockBaseClient.new, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+
+    aggregator.record(context)
+
+    assert_equal [context], aggregator.data
+
+    Timecop.travel(Time.now + (60 * 60) - 1) do
+      aggregator.record(context)
+
+      # This doesn't get updated because we already have a context for this user/device in the timeframe
+      assert_equal [context], aggregator.data
+    end
+
+    Timecop.travel(Time.now + ((60 * 60) + 1)) do
+      # this is new because we've passed the expiry
+      aggregator.record(context)
+
+      assert_equal [context, context], aggregator.data
+    end
+  end
+
+  def test_sync
+    now = Time.now
+
+    client = MockBaseClient.new
+
+    aggregator = Prefab::ExampleContextsAggregator.new(client: client, max_contexts: 10,
+                                                       sync_interval: EFFECTIVELY_NEVER)
+
+    context = Prefab::Context.new(
+      user: { key: 'abc' },
+      device: { key: 'def', mobile: true }
+    )
+    aggregator.record(context)
+
+    # This is the same as above so we shouldn't get anything new
+    aggregator.record(context)
+
+    aggregator.record(
+      Prefab::Context.new(
+        user: { key: 'ghi' },
+        device: { key: 'jkl', mobile: false }
+      )
+    )
+
+    aggregator.record(Prefab::Context.new(user: { key: 'kev', name: 'kevin', age: 48.5 }))
+
+    assert_equal 3, aggregator.cache.data.size
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          example_contexts: PrefabProto::ExampleContexts.new(
+            examples: [
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'abc')
+                      }
+                    ),
+                    PrefabProto::Context.new(
+                      type: 'device',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'def'),
+                        'mobile' => PrefabProto::ConfigValue.new(bool: true)
+                      }
+                    )
+                  ]
+                )
+              ),
+
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'ghi')
+                      }
+                    ),
+                    PrefabProto::Context.new(
+                      type: 'device',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'jkl'),
+                        'mobile' => PrefabProto::ConfigValue.new(bool: false)
+                      }
+                    )
+                  ]
+                )
+              ),
+
+              PrefabProto::ExampleContext.new(
+                timestamp: now.utc.to_i * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'kev'),
+                        'name' => PrefabProto::ConfigValue.new(string: 'kevin'),
+                        'age' => PrefabProto::ConfigValue.new(double: 48.5)
+                      }
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      ]
+    )
+
+    requests = wait_for_post_requests(client) do
+      Timecop.freeze(now + (60 * 60) - 1) do
+        aggregator.sync
+      end
+    end
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+
+    # this hasn't changed because not enough time has passed
+    assert_equal 3, aggregator.cache.data.size
+
+    # a sync past the expiry should clear the cache
+    Timecop.freeze(now + (60 * 60) + 1) do
+      # we need a new piece of data for the sync to happen
+      aggregator.record(Prefab::Context.new(user: { key: 'bozo', name: 'Bozo', age: 99 }))
+
+      requests = wait_for_post_requests(client) do
+        aggregator.sync
+      end
+    end
+
+    expected_post = PrefabProto::TelemetryEvents.new(
+      instance_hash: client.instance_hash,
+      events: [
+        PrefabProto::TelemetryEvent.new(
+          example_contexts: PrefabProto::ExampleContexts.new(
+            examples: [
+              PrefabProto::ExampleContext.new(
+                timestamp: (now.utc.to_i + (60 * 60) + 1) * 1000,
+                contextSet: PrefabProto::ContextSet.new(
+                  contexts: [
+                    PrefabProto::Context.new(
+                      type: 'user',
+                      values: {
+                        'key' => PrefabProto::ConfigValue.new(string: 'bozo'),
+                        'name' => PrefabProto::ConfigValue.new(string: 'Bozo'),
+                        'age' => PrefabProto::ConfigValue.new(int: 99)
+                      }
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      ]
+    )
+
+    assert_equal [[
+      '/api/v1/telemetry',
+      expected_post
+    ]], requests
+
+    # The last sync should have cleared the cache of everything except the latest context
+    assert_equal 1, aggregator.cache.data.size
+    assert_equal ['user:bozo'], aggregator.cache.data.keys
+  end
+end

data/test/test_exponential_backoff.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestExponentialBackoff < Minitest::Test
+  def test_backoff
+    backoff = Prefab::ExponentialBackoff.new(max_delay: 120)
+
+    assert_equal 2, backoff.call
+    assert_equal 4, backoff.call
+    assert_equal 8, backoff.call
+    assert_equal 16, backoff.call
+    assert_equal 32, backoff.call
+    assert_equal 64, backoff.call
+    assert_equal 120, backoff.call
+    assert_equal 120, backoff.call
+  end
+end

data/test/test_feature_flag_client.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestFeatureFlagClient < Minitest::Test
+  DEFAULT = 'default'
+
+  def test_feature_is_on
+    ff_client = new_client
+
+    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_feature_is_on_for
+    ff_client = new_client
+
+    assert_equal false, ff_client.feature_is_on_for?('something-that-does-not-exist', {})
+    assert_equal false, ff_client.feature_is_on_for?('user_key_match', {})
+    assert_equal false, ff_client.feature_is_on_for?('user_key_match', { user: { key: 'not-included' } })
+    assert_equal true, ff_client.feature_is_on_for?('user_key_match', { user: { key:  'abc123' } })
+    assert_equal true, ff_client.feature_is_on_for?('user_key_match', { user: { key: 'xyz987' } })
+  end
+
+  def test_get
+    ff_client = new_client
+
+    # 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', {})
+
+    # 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
+
+  private
+
+  def new_client(overrides = {})
+    super(overrides).feature_flag_client
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/focus'
+require 'minitest/reporters'
+Minitest::Reporters.use! unless ENV['RM_INFO']
+
+require 'prefab-cloud-ruby'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'support', '**', '*.rb')).each do |file|
+  require file
+end
+
+MiniTest::Test.class_eval do
+  include CommonHelpers
+  extend CommonHelpers
+end

data/test/test_integration.rb

@@ -0,0 +1,58 @@
+# 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|
+      parent_context = test['context']
+
+      test['cases'].each do |test_case|
+        define_method(:"test_#{test['name']}_#{test_case['name']}") do
+          it = IntegrationTest.new(test_case)
+
+          IntegrationTestHelpers.with_parent_context_maybe(parent_context) do
+            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 :simple_equality
+              if it.func == :enabled?
+                flag, _default, context = *it.input
+                assert_equal it.expected[:value], it.test_client.send(it.func, flag, context)
+              else
+                assert_equal it.expected[:value], it.test_client.send(it.func, *it.input)
+              end
+            when :log_level
+              assert_equal it.expected[:value].to_sym, it.test_client.send(it.func, *it.input)
+            when :telemetry
+              aggregator, get_actual_data, expected = IntegrationTestHelpers.prepare_post_data(it)
+              aggregator.sync
+
+              wait_for -> { it.last_post_result&.status == 200 }
+
+              assert it.endpoint == it.last_post_endpoint
+
+              actual = get_actual_data[it.last_data_sent]
+
+              expected.all? do |expected|
+                assert actual.include?(expected)
+              end
+            else
+              raise "Unknown test type: #{it.test_type}"
+            end
+          end
+        end
+      end
+    end
+  end
+end