prefab-cloud-ruby 0.24.5 → 0.24.6

data/test/test_client.rb

@@ -3,6 +3,27 @@
 require 'test_helper'
 
 class TestClient < Minitest::Test
+  LOCAL_ONLY = Prefab::Options::DATASOURCES::LOCAL_ONLY
+
+  PROJECT_ENV_ID = 1
+  KEY = 'the-key'
+  DEFAULT_VALUE = 'default_value'
+  DESIRED_VALUE = 'desired_value'
+
+  IRRELEVANT = 'this should never show up'
+
+  DEFAULT_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+  DESIRED_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DESIRED_VALUE)
+
+  TRUE_CONFIG = PrefabProto::ConfigValue.new(bool: true)
+  FALSE_CONFIG = PrefabProto::ConfigValue.new(bool: false)
+
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
+    values: [
+      PrefabProto::ConditionalValue.new(value: DEFAULT_VALUE_CONFIG)
+    ]
+  )
+
   def setup
     @client = new_client
   end
@@ -88,7 +109,7 @@ class TestClient < Minitest::Test
   def test_initialization_with_an_options_object
     options_hash = {
       namespace: 'test-namespace',
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+      prefab_datasources: LOCAL_ONLY
     }
 
     options = Prefab::Options.new(options_hash)
@@ -101,7 +122,7 @@ class TestClient < Minitest::Test
   def test_initialization_with_a_hash
     options_hash = {
       namespace: 'test-namespace',
-      prefab_datasources: Prefab::Options::DATASOURCES::LOCAL_ONLY
+      prefab_datasources: LOCAL_ONLY
     }
 
     client = Prefab::Client.new(options_hash)
@@ -109,6 +130,240 @@ class TestClient < Minitest::Test
     assert_equal client.namespace, 'test-namespace'
   end
 
+  def test_evaluation_summary_aggregator
+    fake_api_key = '123-development-yourapikey-SDK'
+
+    # it is nil by default
+    assert_nil Prefab::Client.new(api_key: fake_api_key).evaluation_summary_aggregator
+
+    # it is nil when local_only even if collect_max_evaluation_summaries is true
+    assert_nil Prefab::Client.new(prefab_datasources: LOCAL_ONLY,
+                                  collect_evaluation_summaries: true).evaluation_summary_aggregator
+
+    # it is nil when collect_max_evaluation_summaries is false
+    assert_nil Prefab::Client.new(api_key: fake_api_key,
+                                  collect_evaluation_summaries: false).evaluation_summary_aggregator
+
+    # it is not nil when collect_max_evaluation_summaries is true and the datasource is not local_only
+    assert_equal Prefab::EvaluationSummaryAggregator,
+                 Prefab::Client.new(api_key: fake_api_key,
+                                    collect_evaluation_summaries: true).evaluation_summary_aggregator.class
+  end
+
+  def test_get_with_basic_value
+    config = PrefabProto::Config.new(
+      id: 123,
+      key: KEY,
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: :force,
+                        collect_example_contexts: :force)
+
+    assert_equal DESIRED_VALUE, client.get(config.key, IRRELEVANT, 'user' => { 'key' => 99 })
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: DESIRED_VALUE_CONFIG,
+          conditional_value_index: 0,
+          weighted_value_index: nil,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [Prefab::Context.new({ user: { 'key' => 99 } })]
+  end
+
+  def test_get_with_weighted_values
+    config = PrefabProto::Config.new(
+      id: 123,
+      key: KEY,
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [
+        DEFAULT_ROW,
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 98], ['def', 1],
+                                                                                    ['ghi', 1]]))
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID, collect_evaluation_summaries: :force,
+                        collect_example_contexts: :force)
+
+    2.times do
+      assert_equal 'abc', client.get(config.key, IRRELEVANT, 'user' => { 'key' => '1' })
+    end
+
+    3.times do
+      assert_equal 'def', client.get(config.key, IRRELEVANT, 'user' => { 'key' => '12' })
+    end
+
+    assert_equal 'ghi',
+                 client.get(config.key, IRRELEVANT, 'user' => { 'key' => '4', admin: true })
+
+    assert_summary client, {
+      [KEY, :CONFIG] => {
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'abc'),
+          conditional_value_index: 0,
+          weighted_value_index: 0,
+          selected_index: nil
+        } => 2,
+
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'def'),
+          conditional_value_index: 0,
+          weighted_value_index: 1,
+          selected_index: nil
+        } => 3,
+
+        {
+          config_id: config.id,
+          config_row_index: 1,
+          selected_value: PrefabProto::ConfigValue.new(string: 'ghi'),
+          conditional_value_index: 0,
+          weighted_value_index: 2,
+          selected_index: nil
+        } => 1
+      }
+    }
+
+    assert_example_contexts client, [
+      Prefab::Context.new(user: { 'key' => '1' }),
+      Prefab::Context.new(user: { 'key' => '12' }),
+      Prefab::Context.new(user: { 'key' => '4', admin: true })
+    ]
+  end
+
+  def test_in_seg
+    segment_key = 'segment_key'
+
+    segment_config = PrefabProto::Config.new(
+      config_type: PrefabProto::ConfigType::SEGMENT,
+      key: segment_key,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: TRUE_CONFIG,
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(['hotmail.com', 'gmail.com']),
+                  property_name: 'user.email'
+                )
+              ]
+            ),
+            PrefabProto::ConditionalValue.new(value: FALSE_CONFIG)
+          ]
+        )
+      ]
+    )
+
+    config = PrefabProto::Config.new(
+      key: KEY,
+      rows: [
+        DEFAULT_ROW,
+
+        PrefabProto::ConfigRow.new(
+          project_env_id: PROJECT_ENV_ID,
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::IN_SEG,
+                  value_to_match: PrefabProto::ConfigValue.new(string: segment_key)
+                )
+              ],
+              value: DESIRED_VALUE_CONFIG
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: [config, segment_config], project_env_id: PROJECT_ENV_ID,
+                        collect_evaluation_summaries: :force, collect_example_contexts: :force)
+
+    assert_equal DEFAULT_VALUE, client.get(config.key)
+    assert_equal DEFAULT_VALUE,
+                 client.get(config.key, IRRELEVANT, user: { key: 'abc', email: 'example@prefab.cloud' })
+    assert_equal DESIRED_VALUE, client.get(config.key, IRRELEVANT, user: { key: 'def', email: 'example@hotmail.com' })
+
+    assert_summary client, {
+      [segment_key, :SEGMENT] => {
+        { config_id: 0, config_row_index: 0, conditional_value_index: 1, selected_value: FALSE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 2,
+        { config_id: 0, config_row_index: 0, conditional_value_index: 0, selected_value: TRUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 1
+      },
+      [KEY, :NOT_SET_CONFIG_TYPE] => {
+        { config_id: 0, config_row_index: 0, conditional_value_index: 0, selected_value: DEFAULT_VALUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 2,
+        { config_id: 0, config_row_index: 1, conditional_value_index: 0, selected_value: DESIRED_VALUE_CONFIG,
+          weighted_value_index: nil, selected_index: nil } => 1
+      }
+    }
+
+    assert_example_contexts client, [
+      Prefab::Context.new(user: { key: 'abc', email: 'example@prefab.cloud' }),
+      Prefab::Context.new(user: { key: 'def', email: 'example@hotmail.com' })
+    ]
+  end
+
+  def test_get_log_level
+    config = PrefabProto::Config.new(
+      id: 999,
+      key: 'log-level',
+      config_type: PrefabProto::ConfigType::LOG_LEVEL,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [PrefabProto::Criterion.new(operator: PrefabProto::Criterion::CriterionOperator::ALWAYS_TRUE)],
+              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::DEBUG)
+            )
+          ]
+        )
+      ]
+    )
+
+    client = new_client(config: config, project_env_id: PROJECT_ENV_ID,
+                        collect_evaluation_summaries: :force)
+
+    assert_equal :DEBUG, client.get(config.key, IRRELEVANT)
+
+    # nothing is summarized for log levels
+    assert_summary client, {}
+  end
+
   private
 
   def assert_equal_context_and_jit(expected, method, key, context)

data/test/test_config_resolver.rb

@@ -22,6 +22,10 @@ class TestConfigResolver < Minitest::Test
     ]
   )
 
+  class MockConfigLoader
+    def calc_config; end
+  end
+
   def test_resolution
     @loader = MockConfigLoader.new
 
@@ -117,31 +121,30 @@ class TestConfigResolver < Minitest::Test
 
     @loader.stub :calc_config, loaded_values do
       @resolverA = resolver_for_namespace('', @loader, project_env_id: PRODUCTION_ENV_ID)
-      assert_equal_context_and_jit DEFAULT_VALUE, @resolverA, 'key', {}, :string
+      assert_equal_context_and_jit DEFAULT_VALUE, @resolverA, 'key', {}
 
       ## below here in the test env
       @resolverA = resolver_for_namespace('', @loader)
-      assert_equal_context_and_jit 'value_none', @resolverA, 'key', {}, :string
+      assert_equal_context_and_jit 'value_none', @resolverA, 'key', {}
 
       @resolverA = resolver_for_namespace('projectA', @loader)
-      assert_equal_context_and_jit 'valueA', @resolverA, 'key', {}, :string
+      assert_equal_context_and_jit 'valueA', @resolverA, 'key', {}
 
       @resolverB = resolver_for_namespace('projectB', @loader)
-      assert_equal_context_and_jit 'valueB', @resolverB, 'key', {}, :string
+      assert_equal_context_and_jit 'valueB', @resolverB, 'key', {}
 
       @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
-      assert_equal_context_and_jit 'projectB.subprojectX', @resolverBX, 'key', {}, :string
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverBX, 'key', {}
 
       @resolverBX = resolver_for_namespace('projectB.subprojectX', @loader)
-      assert_equal_context_and_jit 'valueB2', @resolverBX, 'key2', {}, :string
+      assert_equal_context_and_jit 'valueB2', @resolverBX, 'key2', {}
 
       @resolverUndefinedSubProject = resolver_for_namespace('projectB.subprojectX.subsubQ',
                                                             @loader)
-      assert_equal_context_and_jit 'projectB.subprojectX', @resolverUndefinedSubProject, 'key',
-                                   {}, :string
+      assert_equal_context_and_jit 'projectB.subprojectX', @resolverUndefinedSubProject, 'key', {}
 
       @resolverBX = resolver_for_namespace('projectC', @loader)
-      assert_equal_context_and_jit 'value_none', @resolverBX, 'key', {}, :string
+      assert_equal_context_and_jit 'value_none', @resolverBX, 'key', {}
 
       assert_nil @resolverBX.get('key_that_doesnt_exist', nil)
 
@@ -244,9 +247,9 @@ class TestConfigResolver < Minitest::Test
       resolver.project_env_id = PRODUCTION_ENV_ID
 
       assert_equal_context_and_jit DEFAULT_VALUE, resolver, CONFIG_KEY,
-                                   { user: { email: 'test@something-else.com' } }, :string
+                                   { user: { email: 'test@something-else.com' } }
       assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY,
-                                   { user: { email: 'test@hotmail.com' } }, :string
+                                   { user: { email: 'test@hotmail.com' } }
     end
   end
 
@@ -312,10 +315,8 @@ class TestConfigResolver < Minitest::Test
       options = Prefab::Options.new
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new(options), loader)
 
-      assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@hotmail.com' } },
-                                   :string
-      assert_equal_context_and_jit NOT_IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@something-else.com' } },
-                                   :string
+      assert_equal_context_and_jit IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@hotmail.com' } }
+      assert_equal_context_and_jit NOT_IN_SEGMENT_VALUE, resolver, CONFIG_KEY, { user: { email: 'test@something-else.com' } }
     end
   end
 
@@ -356,9 +357,9 @@ class TestConfigResolver < Minitest::Test
       resolver.project_env_id = TEST_ENV_ID
 
       Prefab::Context.with_context({ user: { email: 'test@example.com' } }) do
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).string
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).string
-        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'pro' } }).string
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).unwrapped_value
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).unwrapped_value
+        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'pro' } }).unwrapped_value
       end
     end
   end
@@ -400,9 +401,9 @@ class TestConfigResolver < Minitest::Test
       resolver.project_env_id = TEST_ENV_ID
 
       Prefab::Context.with_context({ user: { email: 'test@hotmail.com' }, team: { plan: 'pro' } }) do
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).string
-        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { user: { email: 'test@example.com' } }).string
-        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).string
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY).unwrapped_value
+        assert_equal DESIRED_VALUE, resolver.get(CONFIG_KEY, { user: { email: 'test@example.com' } }).unwrapped_value
+        assert_equal DEFAULT_VALUE, resolver.get(CONFIG_KEY, { team: { plan: 'freebie' } }).unwrapped_value
       end
     end
   end
@@ -419,11 +420,11 @@ class TestConfigResolver < Minitest::Test
     resolver
   end
 
-  def assert_equal_context_and_jit(expected_value, resolver, key, properties, type)
-    assert_equal expected_value, resolver.get(key, properties).send(type)
+  def assert_equal_context_and_jit(expected_value, resolver, key, properties)
+    assert_equal expected_value, resolver.get(key, properties).unwrapped_value
 
     Prefab::Context.with_context(properties) do
-      assert_equal expected_value, resolver.get(key).send(type)
+      assert_equal expected_value, resolver.get(key).unwrapped_value
     end
   end
 end

data/test/test_config_value_unwrapper.rb

@@ -8,77 +8,67 @@ class TestConfigValueUnwrapper < Minitest::Test
 
   def test_unwrapping_int
     config_value = PrefabProto::ConfigValue.new(int: 123)
-    assert_equal 123, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 123, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string
     config_value = PrefabProto::ConfigValue.new(string: 'abc')
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_double
     config_value = PrefabProto::ConfigValue.new(double: 1.23)
-    assert_equal 1.23, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 1.23, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_bool
     config_value = PrefabProto::ConfigValue.new(bool: true)
-    assert_equal true, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal true, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
 
     config_value = PrefabProto::ConfigValue.new(bool: false)
-    assert_equal false, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal false, unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_log_level
     config_value = PrefabProto::ConfigValue.new(log_level: :INFO)
-    assert_equal :INFO, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal :INFO, unwrap(config_value, CONFIG_KEY, 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], Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal %w[a b c], unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_weighted_values
     # single value
     config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
 
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
+    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
 
     # multiple values, evenly distributed
     config_value = PrefabProto::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:000'))
-    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
-    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:888'))
+    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:000'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
+    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG_KEY, 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', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:123'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
-    assert_equal 'def', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:012'))
-    assert_equal 'ghi', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:428'))
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, context_with_key('user:548'))
+    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:123'))
+    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:456'))
+    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:789'))
+    assert_equal 'def', unwrap(config_value, CONFIG_KEY, context_with_key('user:012'))
+    assert_equal 'ghi', unwrap(config_value, CONFIG_KEY, context_with_key('user:428'))
+    assert_equal 'abc', unwrap(config_value, CONFIG_KEY, context_with_key('user:548'))
   end
 
   private
 
-  def weighted_values(values_and_weights, hash_by_property_name: 'user.key')
-    values = values_and_weights.map do |value, weight|
-      weighted_value(value, weight)
-    end
-
-    PrefabProto::WeightedValues.new(weighted_values: values, hash_by_property_name: hash_by_property_name)
-  end
-
-  def weighted_value(string, weight)
-    PrefabProto::WeightedValue.new(
-      value: PrefabProto::ConfigValue.new(string: string), weight: weight
-    )
-  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).unwrap
+  end
 end

data/test/test_context_shape_aggregator.rb

@@ -127,7 +127,6 @@ class TestContextShapeAggregator < Minitest::Test
       initialization_timeout_sec: 0,
       on_init_failure: Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN,
       api_key: '123-development-yourapikey-SDK',
-      shape_sync_interval: 1000 # we'll trigger sync manually in our test
     }.merge(overrides))
   end