prefab-cloud-ruby 0

data/test/test_context.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestContext < Minitest::Test
+  EXAMPLE_PROPERTIES = { user: { key: 'some-user-key', name: 'Ted' }, team: { key: 'abc', plan: 'pro' } }.freeze
+
+  def setup
+    super
+    Prefab::Context.current = nil
+  end
+
+  def test_initialize_with_empty_context
+    context = Prefab::Context.new({})
+    assert_empty context.contexts
+  end
+
+  def test_initialize_with_named_context
+    named_context = Prefab::Context::NamedContext.new('test', foo: 'bar')
+    context = Prefab::Context.new(named_context)
+    assert_equal 1, context.contexts.size
+    assert_equal named_context, context.contexts['test']
+  end
+
+  def test_initialize_with_hash
+    context = Prefab::Context.new(test: { foo: 'bar' })
+    assert_equal 1, context.contexts.size
+    assert_equal 'bar', context.contexts['test'].get('foo')
+  end
+
+  def test_initialize_with_multiple_hashes
+    context = Prefab::Context.new(test: { foo: 'bar' }, other: { foo: 'baz' })
+    assert_equal 2, context.contexts.size
+    assert_equal 'bar', context.contexts['test'].get('foo')
+    assert_equal 'baz', context.contexts['other'].get('foo')
+  end
+
+  def test_initialize_with_invalid_hash
+    _, err = capture_io do
+      Prefab::Context.new({ foo: 'bar', baz: 'qux' })
+    end
+
+    assert_match '[DEPRECATION] Prefab contexts should be a hash with a key of the context name and a value of a hash',
+                 err
+  end
+
+  def test_initialize_with_invalid_argument
+    assert_raises(ArgumentError) { Prefab::Context.new([]) }
+  end
+
+  def test_current
+    context = Prefab::Context.current
+    assert_instance_of Prefab::Context, context
+    assert_empty context.to_h
+  end
+
+  def test_current_set
+    context = Prefab::Context.new(EXAMPLE_PROPERTIES)
+    Prefab::Context.current = context
+    assert_instance_of Prefab::Context, context
+    assert_equal stringify(EXAMPLE_PROPERTIES), context.to_h
+  end
+
+  def test_merge_with_current
+    context = Prefab::Context.new(EXAMPLE_PROPERTIES)
+    Prefab::Context.current = context
+    assert_equal stringify(EXAMPLE_PROPERTIES), context.to_h
+
+    new_context = Prefab::Context.merge_with_current({ user: { key: 'brand-new', other: 'different' },
+                                                       address: { city: 'New York' } })
+    assert_equal stringify({
+                             # Note that the user's `name` from the original
+                             # context is not included. This is because we don't _merge_ the new
+                             # properties if they collide with an existing context name. We _replace_
+                             # them.
+                             user: { key: 'brand-new', other: 'different' },
+                             team: EXAMPLE_PROPERTIES[:team],
+                             address: { city: 'New York' }
+                           }),
+                 new_context.to_h
+
+    # the original/current context is unchanged
+    assert_equal stringify(EXAMPLE_PROPERTIES), Prefab::Context.current.to_h
+  end
+
+  def test_with_context
+    Prefab::Context.with_context(EXAMPLE_PROPERTIES) do
+      context = Prefab::Context.current
+      assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
+      assert_equal('some-user-key', context.get('user.key'))
+    end
+  end
+
+  def test_with_context_nesting
+    Prefab::Context.with_context(EXAMPLE_PROPERTIES) do
+      Prefab::Context.with_context({ user: { key: 'abc', other: 'different' } }) do
+        context = Prefab::Context.current
+        assert_equal({ 'user' => { 'key' => 'abc', 'other' => 'different' } }, context.to_h)
+      end
+
+      context = Prefab::Context.current
+      assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
+    end
+  end
+
+  def test_with_context_merge_nesting
+    Prefab::Context.with_context(EXAMPLE_PROPERTIES) do
+      Prefab::Context.with_merged_context({ user: { key: 'abc', other: 'different' } }) do
+        context = Prefab::Context.current
+        assert_equal({ 'user' => { 'key' => 'abc', 'other' => 'different' }, "team"=>{"key"=>"abc", "plan"=>"pro"} }, context.to_h)
+      end
+
+      context = Prefab::Context.current
+      assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
+    end
+  end
+
+  def test_setting
+    context = Prefab::Context.new({})
+    context.set('user', { key: 'value' })
+    context.set(:other, { key: 'different', something: 'other' })
+    assert_equal(stringify({ user: { key: 'value' }, other: { key: 'different', something: 'other' } }), context.to_h)
+  end
+
+  def test_getting
+    context = Prefab::Context.new(EXAMPLE_PROPERTIES)
+    assert_equal('some-user-key', context.get('user.key'))
+    assert_equal('pro', context.get('team.plan'))
+  end
+
+  def test_dot_notation_getting
+    context = Prefab::Context.new({ 'user' => { 'key' => 'value' } })
+    assert_equal('value', context.get('user.key'))
+  end
+
+  def test_dot_notation_getting_with_symbols
+    context = Prefab::Context.new({ user: { key: 'value' } })
+    assert_equal('value', context.get('user.key'))
+  end
+
+  def test_clear
+    context = Prefab::Context.new(EXAMPLE_PROPERTIES)
+    context.clear
+
+    assert_empty context.to_h
+  end
+
+  def test_to_proto
+    namespace = "my.namespace"
+
+    contexts = Prefab::Context.new({
+                                     user: {
+                                       id: 1,
+                                       email: 'user-email'
+                                     },
+                                     team: {
+                                       id: 2,
+                                       name: 'team-name'
+                                     }
+                                   })
+
+    assert_equal PrefabProto::ContextSet.new(
+      contexts: [
+        PrefabProto::Context.new(
+          type: "user",
+          values: {
+            "id" => PrefabProto::ConfigValue.new(int: 1),
+            "email" => PrefabProto::ConfigValue.new(string: "user-email")
+          }
+        ),
+        PrefabProto::Context.new(
+          type: "team",
+          values: {
+            "id" => PrefabProto::ConfigValue.new(int: 2),
+            "name" => PrefabProto::ConfigValue.new(string: "team-name")
+          }
+        ),
+
+        PrefabProto::Context.new(
+          type: "prefab",
+          values: {
+            'current-time' => PrefabProto::ConfigValue.new(int: Prefab::TimeHelpers.now_in_ms),
+            'namespace' => PrefabProto::ConfigValue.new(string: namespace)
+          }
+        )
+      ]
+    ), contexts.to_proto(namespace)
+  end
+
+  private
+
+  def stringify(hash)
+    hash.map { |k, v| [k.to_s, stringify_keys(v)] }.to_h
+  end
+
+  def stringify_keys(value)
+    if value.is_a?(Hash)
+      value.transform_keys(&:to_s)
+    else
+      value
+    end
+  end
+end

data/test/test_context_shape.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestContextShape < Minitest::Test
+  class Email; end
+
+  def test_field_type_number
+    [
+      [1, 1],
+      [99999999999999999999999999999999999999999999, 1],
+      [-99999999999999999999999999999999999999999999, 1],
+
+      ['a', 2],
+      ['99999999999999999999999999999999999999999999', 2],
+
+      [1.0, 4],
+      [99999999999999999999999999999999999999999999.0, 4],
+      [-99999999999999999999999999999999999999999999.0, 4],
+
+      [true, 5],
+      [false, 5],
+
+      [[], 10],
+      [[1, 2, 3], 10],
+      [['a', 'b', 'c'], 10],
+
+      [Email.new, 2],
+    ].each do |value, expected|
+      actual = Prefab::ContextShape.field_type_number(value)
+
+      refute_nil actual, "Expected a value for input: #{value}"
+      assert_equal expected, actual, "Expected #{expected} for #{value}"
+    end
+  end
+
+  # If this test fails, it means that we've added a new type to the ConfigValue
+  def test_mapping_is_exhaustive
+    unsupported = [:bytes, :limit_definition, :log_level, :weighted_values, :int_range, :provided]
+    type_fields = PrefabProto::ConfigValue.descriptor.lookup_oneof("type").entries
+    supported = type_fields.entries.reject do |entry|
+      unsupported.include?(entry.name.to_sym)
+    end.map(&:number)
+    mapped = Prefab::ContextShape::MAPPING.values.uniq
+
+    unless mapped == supported
+      raise "ContextShape MAPPING needs update: #{mapped} != #{supported}"
+    end
+  end
+end

data/test/test_context_shape_aggregator.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class TestContextShapeAggregator < Minitest::Test
+  DOB = Date.new
+
+  CONTEXT_1 = Prefab::Context.new({
+                                    'user' => {
+                                      'name' => 'user-name',
+                                      'email' => 'user.email',
+                                      'age' => 42.5
+                                    },
+                                    'subscription' => {
+                                      'plan' => 'advanced',
+                                      'free' => false
+                                    }
+                                  }).freeze
+
+  CONTEXT_2 = Prefab::Context.new({
+                                    'user' => {
+                                      'name' => 'other-user-name',
+                                      'dob' => DOB
+                                    },
+                                    'device' => {
+                                      'name' => 'device-name',
+                                      'os' => 'os-name',
+                                      'version' => 3
+                                    }
+                                  }).freeze
+
+  CONTEXT_3 = Prefab::Context.new({
+                                    'subscription' => {
+                                      'plan' => 'pro',
+                                      'trial' => true
+                                    }
+                                  }).freeze
+
+  def test_push
+    aggregator = new_aggregator(max_shapes: 9)
+
+    aggregator.push(CONTEXT_1)
+    aggregator.push(CONTEXT_2)
+    assert_equal 9, aggregator.data.size
+
+    # we've reached the limit so no more
+    aggregator.push(CONTEXT_3)
+    assert_equal 9, aggregator.data.size
+
+    assert_equal [['user', 'name', 2], ['user', 'email', 2], ['user', 'age', 4], ['subscription', 'plan', 2], ['subscription', 'free', 5], ['user', 'dob', 2], ['device', 'name', 2], ['device', 'os', 2], ['device', 'version', 1]],
+                 aggregator.data.to_a
+
+    assert_only_expected_logs
+  end
+
+  def test_prepare_data
+    aggregator = new_aggregator
+
+    aggregator.push(CONTEXT_1)
+    aggregator.push(CONTEXT_2)
+    aggregator.push(CONTEXT_3)
+
+    data = aggregator.prepare_data
+
+    assert_equal %w[user subscription device], data.keys
+
+    assert_equal data['user'], {
+      'name' => 2,
+      'email' => 2,
+      'dob' => 2,
+      'age' => 4
+    }
+
+    assert_equal data['subscription'], {
+      'plan' => 2,
+      'trial' => 5,
+      'free' => 5
+    }
+
+    assert_equal data['device'], {
+      'name' => 2,
+      'os' => 2,
+      'version' => 1
+    }
+
+    assert_equal [], aggregator.data.to_a
+    assert_only_expected_logs
+  end
+
+  def test_sync
+    client = new_client
+
+    client.get 'some.key', 'default', CONTEXT_1
+    client.get 'some.key', 'default', CONTEXT_2
+    client.get 'some.key', 'default', CONTEXT_3
+
+    requests = wait_for_post_requests(client) do
+      client.context_shape_aggregator.send(:sync)
+    end
+
+    assert_equal [
+      [
+        '/api/v1/context-shapes',
+        PrefabProto::ContextShapes.new(shapes: [
+                                         PrefabProto::ContextShape.new(
+                                           name: 'user', field_types: {
+                                             'age' => 4, 'dob' => 2, 'email' => 2, 'name' => 2
+                                           }
+                                         ),
+                                         PrefabProto::ContextShape.new(
+                                           name: 'subscription', field_types: {
+                                             'plan' => 2, 'free' => 5, 'trial' => 5
+                                           }
+                                         ),
+                                         PrefabProto::ContextShape.new(
+                                           name: 'device', field_types: {
+                                             'version' => 1, 'os' => 2, 'name' => 2
+                                           }
+                                         )
+                                       ])
+      ]
+    ], requests
+
+
+    assert_logged [
+      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient No success loading checkpoints",
+      "WARN  2023-08-09 15:18:12 -0400: cloud.prefab.client.configclient Couldn't Initialize In 0. Key some.key. Returning what we have"
+    ]
+  end
+
+  private
+
+  def new_client(overrides = {})
+    super(**{
+      prefab_datasources: Prefab::Options::DATASOURCES::ALL,
+      initialization_timeout_sec: 0,
+      on_init_failure: Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN,
+      api_key: '123-development-yourapikey-SDK',
+      context_upload_mode: :shape_only
+    }.merge(overrides))
+  end
+
+  def new_aggregator(max_shapes: 1000)
+    Prefab::ContextShapeAggregator.new(client: new_client, sync_interval: 1000, max_shapes: max_shapes)
+  end
+end