prefab-cloud-ruby 0 → 0.0.1

data/test/test_config_value_unwrapper.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestConfigValueUnwrapper < Minitest::Test
-  CONFIG = PrefabProto::Config.new(
-    key: 'config_key'
-  )
-  EMPTY_CONTEXT = Prefab::Context.new()
-  DECRYPTION_KEY_NAME = "decryption.key"
-  DECRYPTION_KEY_VALUE = Prefab::Encryption.generate_new_hex_key
-
-  def setup
-    super
-    @mock_resolver = MockResolver.new
-  end
-
-  def test_unwrapping_int
-    config_value = PrefabProto::ConfigValue.new(int: 123)
-    assert_equal 123, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-  end
-
-  def test_unwrapping_string
-    config_value = PrefabProto::ConfigValue.new(string: 'abc')
-    assert_equal 'abc', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-    assert_equal 'abc', reportable_value(config_value, CONFIG, EMPTY_CONTEXT)
-  end
-
-  def test_unwrapping_double
-    config_value = PrefabProto::ConfigValue.new(double: 1.23)
-    assert_equal 1.23, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-  end
-
-  def test_unwrapping_bool
-    config_value = PrefabProto::ConfigValue.new(bool: true)
-    assert_equal true, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-
-    config_value = PrefabProto::ConfigValue.new(bool: false)
-    assert_equal false, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-  end
-
-  def test_unwrapping_log_level
-    config_value = PrefabProto::ConfigValue.new(log_level: :INFO)
-    assert_equal :INFO, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-  end
-
-  def test_unwrapping_string_list
-    config_value = PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: %w[a b c]))
-    assert_equal %w[a b c], unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-  end
-
-  def test_unwrapping_weighted_values
-    # single value
-    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
-
-    assert_equal 'abc', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-
-    # multiple values, evenly distributed
-    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
-    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:000'))
-    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:456'))
-    assert_equal 'abc', unwrap(config_value, CONFIG, context_with_key('user:789'))
-    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:888'))
-
-    # multiple values, unevenly distributed
-    config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 99], ['ghi', 1]]))
-    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:123'))
-    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:456'))
-    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:789'))
-    assert_equal 'def', unwrap(config_value, CONFIG, context_with_key('user:012'))
-    assert_equal 'ghi', unwrap(config_value, CONFIG, context_with_key('user:428'))
-    assert_equal 'abc', unwrap(config_value, CONFIG, context_with_key('user:548'))
-  end
-
-  def test_unwrapping_provided_values
-    with_env('ENV_VAR_NAME', 'unit test value')do
-      value = PrefabProto::Provided.new(
-        source: :ENV_VAR,
-        lookup: "ENV_VAR_NAME"
-      )
-      config_value = PrefabProto::ConfigValue.new(provided: value)
-      assert_equal 'unit test value', unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-    end
-  end
-
-  def test_unwrapping_provided_values_of_type_string_list
-    with_env('ENV_VAR_NAME', '["bob","cary"]')do
-      value = PrefabProto::Provided.new(
-        source: :ENV_VAR,
-        lookup: "ENV_VAR_NAME"
-      )
-      config_value = PrefabProto::ConfigValue.new(provided: value)
-      assert_equal ["bob", "cary"], unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-    end
-  end
-
-  def test_unwrapping_provided_values_coerces_to_int
-    with_env('ENV_VAR_NAME', '42')do
-      value = PrefabProto::Provided.new(
-        source: :ENV_VAR,
-        lookup: "ENV_VAR_NAME"
-      )
-      config_value = PrefabProto::ConfigValue.new(provided: value)
-      assert_equal 42,  unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
-    end
-  end
-
-  def test_unwrapping_provided_values_when_value_type_mismatch
-    with_env('ENV_VAR_NAME', 'not an int')do
-      value = PrefabProto::Provided.new(
-        source: :ENV_VAR,
-        lookup: "ENV_VAR_NAME"
-      )
-      config_value = PrefabProto::ConfigValue.new(provided: value)
-
-      assert_raises Prefab::Errors::EnvVarParseError do
-        unwrap(config_value, config_of(PrefabProto::Config::ValueType::INT), EMPTY_CONTEXT)
-      end
-    end
-  end
-
-  def test_coerce
-    assert_equal "string", Prefab::ConfigValueUnwrapper.coerce_into_type("string", CONFIG, "ENV")
-    assert_equal 42, Prefab::ConfigValueUnwrapper.coerce_into_type("42", CONFIG, "ENV")
-    assert_equal false, Prefab::ConfigValueUnwrapper.coerce_into_type("false", CONFIG, "ENV")
-    assert_equal 42.42, Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", CONFIG, "ENV")
-    assert_equal ["a","b"], Prefab::ConfigValueUnwrapper.coerce_into_type("['a','b']", CONFIG, "ENV")
-
-    assert_equal "string", Prefab::ConfigValueUnwrapper.coerce_into_type("string", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
-    assert_equal "42", Prefab::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
-    assert_equal "42.42", Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::STRING),"ENV")
-    assert_equal 42, Prefab::ConfigValueUnwrapper.coerce_into_type("42", config_of(PrefabProto::Config::ValueType::INT),"ENV")
-    assert_equal false, Prefab::ConfigValueUnwrapper.coerce_into_type("false", config_of(PrefabProto::Config::ValueType::BOOL),"ENV")
-    assert_equal 42.42, Prefab::ConfigValueUnwrapper.coerce_into_type("42.42", config_of(PrefabProto::Config::ValueType::DOUBLE),"ENV")
-    assert_equal ["a","b"], Prefab::ConfigValueUnwrapper.coerce_into_type("['a','b']", config_of(PrefabProto::Config::ValueType::STRING_LIST),"ENV")
-
-    assert_raises Prefab::Errors::EnvVarParseError do
-      Prefab::ConfigValueUnwrapper.coerce_into_type("not an int", config_of(PrefabProto::Config::ValueType::INT), "ENV")
-    end
-    assert_raises Prefab::Errors::EnvVarParseError do
-      Prefab::ConfigValueUnwrapper.coerce_into_type("not bool", config_of(PrefabProto::Config::ValueType::BOOL), "ENV")
-    end
-    assert_raises Prefab::Errors::EnvVarParseError do
-      Prefab::ConfigValueUnwrapper.coerce_into_type("not a double", config_of(PrefabProto::Config::ValueType::DOUBLE), "ENV")
-    end
-    assert_raises Prefab::Errors::EnvVarParseError do
-      Prefab::ConfigValueUnwrapper.coerce_into_type("not a list", config_of(PrefabProto::Config::ValueType::STRING_LIST), "ENV")
-    end
-  end
-
-  def test_unwrapping_provided_values_with_missing_env_var
-    value = PrefabProto::Provided.new(
-      source: :ENV_VAR,
-      lookup: "NON_EXISTENT_ENV_VAR_NAME"
-    )
-    config_value = PrefabProto::ConfigValue.new(provided: value)
-    assert_raises(Prefab::Errors::MissingEnvVarError) do
-      unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-    end
-  end
-
-  def test_unwrapping_encrypted_values_decrypts
-    clear_text = "very secret stuff"
-    encrypted = Prefab::Encryption.new(DECRYPTION_KEY_VALUE).encrypt(clear_text)
-    config_value = PrefabProto::ConfigValue.new(string: encrypted, decrypt_with: "decryption.key")
-    assert_equal clear_text, unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-    assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
-  end
-
-  def test_confidential
-    config_value = PrefabProto::ConfigValue.new(confidential: true, string: "something confidential")
-    assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
-  end
-
-  def test_unwrap_confiential_provided
-    with_env('PAAS_PASSWORD', "the password")do
-      value = PrefabProto::Provided.new(
-        source: :ENV_VAR,
-        lookup: "PAAS_PASSWORD"
-      )
-      config_value = PrefabProto::ConfigValue.new(provided: value, confidential: true)
-      assert_equal "the password", unwrap(config_value, CONFIG, EMPTY_CONTEXT)
-      assert reportable_value(config_value, CONFIG, EMPTY_CONTEXT).start_with? Prefab::ConfigValueUnwrapper::CONFIDENTIAL_PREFIX
-    end
-  end
-
-  private
-
-  def config_of(value_type)
-    PrefabProto::Config.new(
-      key: 'config-key',
-      value_type: value_type
-    )
-  end
-
-  def context_with_key(key)
-    Prefab::Context.new(user: { key: key })
-  end
-
-  def unwrap(config_value, config_key, context)
-    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).unwrap
-  end
-
-  def reportable_value(config_value, config_key, context)
-    Prefab::ConfigValueUnwrapper.deepest_value(config_value, config_key, context, @mock_resolver).reportable_value
-  end
-
-  class MockResolver
-    def get(key)
-      if DECRYPTION_KEY_NAME == key
-        Prefab::Evaluation.new(config: PrefabProto::Config.new(key: key),
-                               value: PrefabProto::ConfigValue.new(string: DECRYPTION_KEY_VALUE),
-                                value_index: 0,
-                                config_row_index: 0,
-                                context: Prefab::Context.new,
-                                resolver: self
-        )
-
-      else
-        raise "unexpected key"
-      end
-    end
-  end
-end

data/test/test_config_value_wrapper.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TestConfigValueWrapper < Minitest::Test
-  def test_wrap_integer
-    result = Prefab::ConfigValueWrapper.wrap(42)
-    assert_instance_of PrefabProto::ConfigValue, result
-    assert_equal 42, result.int
-  end
-
-  def test_wrap_float
-    result = Prefab::ConfigValueWrapper.wrap(3.14)
-    assert_instance_of PrefabProto::ConfigValue, result
-    assert_equal 3.14, result.double
-  end
-
-  def test_wrap_boolean_true
-    result = Prefab::ConfigValueWrapper.wrap(true)
-    assert_instance_of PrefabProto::ConfigValue, result
-    assert_equal true, result.bool
-  end
-
-  def test_wrap_boolean_false
-    result = Prefab::ConfigValueWrapper.wrap(false)
-    assert_instance_of PrefabProto::ConfigValue, result
-    assert_equal false, result.bool
-  end
-
-  def test_wrap_array
-    result = Prefab::ConfigValueWrapper.wrap(['one', 'two', 'three'])
-    assert_instance_of PrefabProto::ConfigValue, result
-    assert_instance_of PrefabProto::StringList, result.string_list
-    assert_equal ['one', 'two', 'three'], result.string_list.values
-  end
-
-  def test_wrap_string
-    result = Prefab::ConfigValueWrapper.wrap('hello')
-    assert_instance_of PrefabProto::ConfigValue, result
-    assert_equal 'hello', result.string
-  end
-end

data/test/test_context.rb

@@ -1,203 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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

@@ -1,147 +0,0 @@
-# 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