quonfig 0.0.6 → 0.0.9

data/test/integration/test_helpers.rb

@@ -56,6 +56,7 @@ module IntegrationTestHelpers
         store.set(key, cfg)
       end
     end
+    self.last_store = store
     store
   end
 
@@ -66,13 +67,25 @@ module IntegrationTestHelpers
 
   # Resolve +key+ against +context+ and assert the unwrapped value (and,
   # when present, its reported value_type) match. Generated tests call
-  # this; keep the failure message specific so diffs are readable.
+  # this for the "no default, no enabled" path. With the generator now
+  # threading input.default through assert_get_with_default and routing
+  # function: enabled cases through assert_enabled, this helper can stay
+  # strict: missing keys still raise, non-bool actual stays non-bool.
+  # Nil-expected cases (e.g. "get returns nil if value not found" with
+  # on_no_default: 2) catch the resolver's MissingDefaultError and return nil.
   def self.assert_resolved(resolver, key, context, expected_value, expected_type = nil)
     ctx = context.is_a?(Quonfig::Context) ? context : Quonfig::Context.new(context || {})
-    result = resolver.get(key, ctx)
-    raise Minitest::Assertion, "No evaluation returned for key #{key.inspect}" if result.nil?
+    result =
+      begin
+        resolver.get(key, ctx)
+      rescue Quonfig::Errors::MissingDefaultError
+        nil
+      end
+    return expected_value if result.nil? && expected_value.nil?
 
-    actual = if result.respond_to?(:unwrapped_value)
+    actual = if result.nil?
+               nil
+             elsif result.respond_to?(:unwrapped_value)
                result.unwrapped_value
              elsif result.respond_to?(:value)
                v = result.value
@@ -95,6 +108,152 @@ module IntegrationTestHelpers
     actual
   end
 
+  # function: enabled semantics — Quonfig::Client#enabled? returns the
+  # bool value if the resolved value is a boolean, false otherwise.
+  # The generator routes function: enabled cases through this helper so
+  # the bool-coercion lives here, not inferred from the expected literal.
+  def self.assert_enabled(resolver, key, context, expected_bool)
+    ctx = context.is_a?(Quonfig::Context) ? context : Quonfig::Context.new(context || {})
+    actual =
+      begin
+        result = resolver.get(key, ctx)
+        if result.nil?
+          false
+        else
+          v = result.respond_to?(:unwrapped_value) ? result.unwrapped_value : result
+          (v == true || v == 'true') ? true : false
+        end
+      rescue Quonfig::Errors::MissingDefaultError
+        false
+      end
+    unless actual == expected_bool
+      raise Minitest::Assertion,
+            "enabled?(#{key}): expected #{expected_bool.inspect}, got #{actual.inspect}"
+    end
+    actual
+  end
+
+  # input.default — thread the YAML default through the SDK's public
+  # get(key, default) API. Build a Client over the same store the
+  # resolver uses; that way we observe what the SDK actually returns
+  # (default kicks in for missing keys, found-key wins over default).
+  def self.assert_get_with_default(store, key, context, default_value, expected_value)
+    # Build with environment: ENV_ID so config rules evaluate against the
+    # 'Production' environment (matching what build_resolver does). Without
+    # this the Client falls back to default rules.
+    client = Quonfig::Client.new(store: store, environment: ENV_ID)
+    ctx_arg =
+      if context.nil? || (context.respond_to?(:empty?) && context.empty?)
+        Quonfig::NO_DEFAULT_PROVIDED
+      elsif context.is_a?(Quonfig::Context)
+        context
+      else
+        Quonfig::Context.new(context)
+      end
+    actual = client.get(key, default_value, ctx_arg)
+    unless actual == expected_value
+      raise Minitest::Assertion,
+            "#{key}: expected #{expected_value.inspect} (default=#{default_value.inspect}), got #{actual.inspect}"
+    end
+    actual
+  end
+
+  # Build a real Quonfig::Client whose initial fetch is intentionally slow
+  # (an unreachable api_url + tiny init timeout) and assert that
+  # Client#get raises Quonfig::Errors::InitializationTimeoutError.
+  def self.assert_initialization_timeout_error(key, timeout_sec, api_url, on_init_failure)
+    on_init = on_init_failure.to_s.sub(/\A:/, '').to_sym
+    api_urls = api_url && !api_url.empty? ? [api_url] : ['https://127.0.0.1:1']
+    client =
+      begin
+        Quonfig::Client.new(
+          sdk_key: 'test-unused',
+          api_urls: api_urls,
+          initialization_timeout_sec: timeout_sec,
+          on_init_failure: on_init,
+          enable_sse: false,
+          enable_polling: false
+        )
+      rescue Quonfig::Errors::InitializationTimeoutError
+        return # construction itself raised — that's the expected outcome
+      end
+    raise Minitest::Assertion,
+          'expected Quonfig::Errors::InitializationTimeoutError to raise on get' \
+      unless on_init == :raise
+
+    begin
+      client.get(key)
+      raise Minitest::Assertion, "expected get(#{key}) to raise InitializationTimeoutError but it returned"
+    rescue Quonfig::Errors::InitializationTimeoutError
+      # success
+    ensure
+      client.respond_to?(:close) && client.close
+      $logs = nil if defined?($logs)
+    end
+  end
+
+  # Generic raise path through a real-client construction (e.g. on_init_failure
+  # :return + missing_default on get_or_raise — init returns zero value,
+  # then get_or_raise still raises MissingDefault). The function arg picks
+  # the call shape: 'get_or_raise' uses get_or_raise(key); anything else
+  # falls back to client.get(key).
+  #
+  # The Client logs a warning when init returns the zero value (the typical
+  # on_init_failure: :return path). Drain $logs (if it exists from
+  # CommonHelpers) so the test's teardown doesn't trip on it — that's the
+  # whole point of the case.
+  def self.assert_client_construction_raises(key, timeout_sec, api_url, on_init_failure, fn, err_class)
+    on_init = on_init_failure.to_s.sub(/\A:/, '').to_sym
+    api_urls = api_url && !api_url.empty? ? [api_url] : ['https://127.0.0.1:1']
+    client = Quonfig::Client.new(
+      sdk_key: 'test-unused',
+      api_urls: api_urls,
+      initialization_timeout_sec: timeout_sec,
+      on_init_failure: on_init,
+      enable_sse: false,
+      enable_polling: false
+    )
+    begin
+      if fn == 'get_or_raise' && client.respond_to?(:get_or_raise)
+        client.get_or_raise(key)
+      else
+        # No public get_or_raise: call .get with no default and the SDK's
+        # internal NO_DEFAULT_PROVIDED forces the missing-default raise.
+        client.get(key)
+      end
+      raise Minitest::Assertion, "expected #{err_class} to raise but call returned"
+    rescue err_class
+      # success
+    ensure
+      client.respond_to?(:close) && client.close
+      # Acknowledge the init-warning log so common_helpers' teardown won't
+      # blow up. The warning IS the thing we asked for via :return policy.
+      $logs = nil if defined?($logs)
+    end
+  end
+
+  # Happy path through a real-client construction (rare; mostly here for
+  # symmetry — the YAML init-timeout cases are all raise-path).
+  def self.assert_client_construction_value(key, timeout_sec, api_url, on_init_failure, _fn, expected_value)
+    on_init = on_init_failure.to_s.sub(/\A:/, '').to_sym
+    api_urls = api_url && !api_url.empty? ? [api_url] : ['https://127.0.0.1:1']
+    client = Quonfig::Client.new(
+      sdk_key: 'test-unused',
+      api_urls: api_urls,
+      initialization_timeout_sec: timeout_sec,
+      on_init_failure: on_init,
+      enable_sse: false,
+      enable_polling: false
+    )
+    actual = client.get(key)
+    unless actual == expected_value
+      raise Minitest::Assertion,
+            "#{key}: expected #{expected_value.inspect}, got #{actual.inspect}"
+    end
+    client.respond_to?(:close) && client.close
+    actual
+  end
+
   # Temporarily set env vars for the duration of the block and restore the
   # originals (including absence) on exit — even if the block raises.
   def self.with_env(vars_hash)
@@ -114,6 +273,375 @@ module IntegrationTestHelpers
     end
   end
 
+  # ----------------------------------------------------------------------
+  # Aggregator helpers for the post.yaml + telemetry.yaml generated suites.
+  # ----------------------------------------------------------------------
+  #
+  # The shared YAML in integration-test-data/tests/eval/{post,telemetry}.yaml
+  # describes telemetry payloads in language-neutral terms — `aggregator:
+  # context_shape | evaluation_summary | example_contexts` plus a `data`
+  # block of inputs and an `expected_data` block of the would-be POST body.
+  # The Ruby generator emits one method per case calling these three
+  # helpers. They wire the YAML inputs through the real aggregator classes
+  # (Quonfig::Telemetry::*) and translate the aggregator's drain_event
+  # output into the YAML's snake_case schema for assertion.
+  #
+  # Recent build_store call stashes the Quonfig::ConfigStore on the module
+  # so eval-summary cases can resolve real values for each key.
+  class << self
+    attr_accessor :last_store
+    # Side-channel populated by record_one_eval whenever we redact a
+    # confidential value before recording it on the aggregator. Keyed by
+    # config_key → { unwrapped:, value_type: }. evaluation_summary_post
+    # consults it so the YAML's `value` / `value_type` fields can still
+    # assert the runtime resolved value while `selected_value` carries
+    # the wire-redacted form.
+    attr_accessor :last_unwrapped_overrides
+  end
+
+  # Construct an aggregator. +kind+ is one of :context_shape,
+  # :evaluation_summary, :example_contexts (string or symbol). +overrides+
+  # mirrors the YAML `client_overrides` block; the only options that
+  # affect aggregator output today are `collect_evaluation_summaries`
+  # (false → eval-summary aggregator created with max_keys=0 so it noops)
+  # and `context_upload_mode` ("shape_only" / "none" → example-contexts
+  # aggregator created with max=0; ":none" / ":shape_only" come through
+  # as Ruby-symbol strings via js-yaml, which is why we strip the leading
+  # colon defensively).
+  def self.build_aggregator(kind, overrides = {})
+    overrides = (overrides || {}).each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+    case normalize_kind(kind)
+    when :context_shape
+      max = aggregator_max_for(overrides, :context_shape)
+      Quonfig::Telemetry::ContextShapeAggregator.new(max_shapes: max)
+    when :evaluation_summary
+      collect = overrides.fetch('collect_evaluation_summaries', true)
+      max = collect ? 100_000 : 0
+      Quonfig::Telemetry::EvaluationSummariesAggregator.new(max_keys: max)
+    when :example_contexts
+      max = aggregator_max_for(overrides, :example_contexts)
+      Quonfig::Telemetry::ExampleContextsAggregator.new(max_contexts: max)
+    else
+      raise ArgumentError, "Unknown aggregator kind: #{kind.inspect}"
+    end
+  end
+
+  # Feed +data+ through +aggregator+ for the given +kind+. Each kind has
+  # its own input shape (see post.yaml / telemetry.yaml):
+  # - :context_shape   → +data+ is a Hash of named contexts, OR an Array
+  #                      of such hashes (multi-record case).
+  # - :evaluation_summary
+  #                    → +data+ is { 'keys' => [...], 'keys_without_context'
+  #                      => [...] }. Each key is resolved against
+  #                      +contexts+ (or empty contexts for the second
+  #                      list), then the EvalResult is recorded.
+  # - :example_contexts → same as :context_shape but recorded into the
+  #                      example aggregator.
+  def self.feed_aggregator(aggregator, kind, data, contexts: {})
+    case normalize_kind(kind)
+    when :context_shape
+      each_context_record(data) { |rec| aggregator.push(rec) }
+    when :example_contexts
+      each_context_record(data) { |rec| aggregator.record(Quonfig::Context.new(rec)) }
+    when :evaluation_summary
+      record_eval_keys(aggregator, data, contexts)
+    else
+      raise ArgumentError, "Unknown aggregator kind: #{kind.inspect}"
+    end
+  end
+
+  # Drain the aggregator and assert its would-be POST body matches
+  # +expected_data+. +endpoint+ is captured from YAML for diagnostics
+  # (the Ruby helpers don't actually POST anything — the aggregator's
+  # drain_event payload is what the reporter would ship). +expected_data+
+  # is YAML-shaped (snake_case `field_types` etc.); we project the
+  # aggregator's drain output into that shape so the comparison is
+  # apples-to-apples.
+  def self.assert_aggregator_post(aggregator, kind, expected_data, endpoint:)
+    actual = build_actual_post(aggregator, kind)
+
+    if expected_data.nil?
+      unless actual.nil?
+        raise Minitest::Assertion,
+              "[#{endpoint}] expected no telemetry POST but aggregator produced #{actual.inspect}"
+      end
+      return
+    end
+
+    expected_normalized, actual_normalized = align_for_comparison(expected_data, actual, kind)
+    actual_normalized = scrub_optional_fields(actual_normalized, expected_normalized, kind)
+
+    unless actual_normalized == expected_normalized
+      raise Minitest::Assertion,
+            "[#{endpoint}] aggregator POST mismatch\n  expected: #{expected_normalized.inspect}\n  actual:   #{actual_normalized.inspect}"
+    end
+  end
+
+  # Normalize ordering on both sides for comparison. Telemetry payloads
+  # are conceptually unordered sets — different SDKs (and different runs
+  # within a single SDK if you swap a Hash for a different impl) emit
+  # entries in different orders. Sort by a stable key so the comparison
+  # is set-equality. Keeps assertion errors readable: both sides print in
+  # the same canonical order.
+  def self.align_for_comparison(expected, actual, kind)
+    case normalize_kind(kind)
+    when :evaluation_summary
+      sort_key = ->(row) { [row['key'].to_s, (row.dig('summary', 'conditional_value_index') || 0)] }
+      [expected.is_a?(Array) ? expected.sort_by(&sort_key) : expected,
+       actual.is_a?(Array)   ? actual.sort_by(&sort_key)   : actual]
+    when :context_shape
+      sort_key = ->(row) { row['name'].to_s }
+      [expected.is_a?(Array) ? expected.sort_by(&sort_key) : expected,
+       actual.is_a?(Array)   ? actual.sort_by(&sort_key)   : actual]
+    else
+      [expected, actual]
+    end
+  end
+  private_class_method :align_for_comparison
+
+  # Drop fields from +actual+ that the YAML's +expected+ doesn't assert.
+  # Today only `selected_value` in eval-summary rows is opt-in (some YAML
+  # cases verify the proto-style wrapper, most don't). Index pairwise so
+  # the per-row decision lines up.
+  def self.scrub_optional_fields(actual, expected, kind)
+    return actual unless normalize_kind(kind) == :evaluation_summary
+    return actual unless actual.is_a?(Array) && expected.is_a?(Array)
+
+    actual.each_with_index.map do |row, idx|
+      exp_row = expected[idx]
+      next row unless row.is_a?(Hash) && exp_row.is_a?(Hash)
+      next row if exp_row.key?('selected_value')
+
+      row.reject { |k, _| k == 'selected_value' }
+    end
+  end
+  private_class_method :scrub_optional_fields
+
+  # --- aggregator-helper internals ---
+
+  def self.normalize_kind(kind)
+    str = kind.to_s
+    str = str.sub(/\A:/, '') # ":shape_only" → "shape_only" if a stray symbol-string sneaks in
+    case str
+    when 'context_shape'      then :context_shape
+    when 'evaluation_summary' then :evaluation_summary
+    when 'example_contexts'   then :example_contexts
+    else raise ArgumentError, "Unknown aggregator kind: #{kind.inspect}"
+    end
+  end
+  private_class_method :normalize_kind
+
+  # Strip a leading `:` so a Ruby-symbol-style YAML scalar (":shape_only"
+  # → ":shape_only" string when js-yaml serializes it) compares cleanly.
+  def self.strip_symbol(v)
+    v.is_a?(String) ? v.sub(/\A:/, '') : v.to_s
+  end
+  private_class_method :strip_symbol
+
+  def self.aggregator_max_for(overrides, agg_kind)
+    mode = strip_symbol(overrides['context_upload_mode']) if overrides.key?('context_upload_mode')
+    return 0 if mode == 'none'
+
+    case agg_kind
+    when :context_shape    then 100_000
+    when :example_contexts then mode == 'shape_only' ? 0 : 100_000
+    end
+  end
+  private_class_method :aggregator_max_for
+
+  def self.each_context_record(data)
+    return if data.nil?
+
+    if data.is_a?(Array)
+      data.each { |row| yield row if row.is_a?(Hash) && !row.empty? }
+    elsif data.is_a?(Hash)
+      yield data unless data.empty?
+    end
+  end
+  private_class_method :each_context_record
+
+  def self.record_eval_keys(aggregator, data, contexts)
+    return unless data.is_a?(Hash)
+
+    keys = data['keys'] || data[:keys] || []
+    keys_no_ctx = data['keys_without_context'] || data[:keys_without_context] || []
+    store = last_store
+    raise '[integration tests] no store cached — call build_store before feed_aggregator' if store.nil?
+
+    resolver = build_resolver(store)
+    ctx = contexts.is_a?(Quonfig::Context) ? contexts : Quonfig::Context.new(contexts || {})
+    empty_ctx = Quonfig::Context.new({})
+
+    self.last_unwrapped_overrides = {}
+    Array(keys).each { |key| record_one_eval(aggregator, resolver, store, key, ctx) }
+    Array(keys_no_ctx).each { |key| record_one_eval(aggregator, resolver, store, key, empty_ctx) }
+  end
+  private_class_method :record_eval_keys
+
+  def self.record_one_eval(aggregator, resolver, store, key, ctx)
+    cfg = store.get(key)
+    return if cfg.nil?
+
+    result =
+      begin
+        resolver.get(key, ctx)
+      rescue Quonfig::Errors::MissingDefaultError
+        nil
+      end
+    return if result.nil?
+
+    # Confidential / decryptWith values must never appear in plaintext on
+    # the wire. EvalResult#reportable_value, when populated, is the
+    # `*****<md5>`-redacted substitute the resolver computed pre-decryption.
+    # When we substitute, stash the runtime unwrapped value so the
+    # post-projection can still assert YAML's `value` / `value_type` against
+    # the resolved plaintext (the YAML treats `value` as the runtime view
+    # and `selected_value` as the wire view).
+    selected_for_telemetry = result.unwrapped_value
+    if result.reportable_value
+      selected_for_telemetry = result.reportable_value
+      (self.last_unwrapped_overrides ||= {})[key] = {
+        unwrapped: result.unwrapped_value,
+        value_type: result.value_type
+      }
+    end
+    aggregator.record(
+      config_id: (cfg[:id] || cfg['id']).to_s,
+      config_key: key,
+      config_type: (cfg[:type] || cfg['type']).to_s,
+      conditional_value_index: result.rule_index,
+      weighted_value_index: result.weighted_value_index,
+      selected_value: selected_for_telemetry,
+      reason: result.wire_reason
+    )
+  end
+  private_class_method :record_one_eval
+
+  # Project +aggregator+'s drain_event payload onto the YAML's
+  # snake_case `expected_data` schema. Returns nil when the aggregator
+  # produced nothing (matches YAML's bare `expected_data:` lines).
+  def self.build_actual_post(aggregator, kind)
+    event = aggregator.drain_event
+    return nil if event.nil?
+
+    case normalize_kind(kind)
+    when :context_shape      then context_shape_post(event)
+    when :evaluation_summary then evaluation_summary_post(event)
+    when :example_contexts   then example_contexts_post(event)
+    end
+  end
+  private_class_method :build_actual_post
+
+  def self.context_shape_post(event)
+    shapes = event.dig('contextShapes', 'shapes') || []
+    return nil if shapes.empty?
+
+    shapes.map do |shape|
+      { 'name' => shape['name'], 'field_types' => shape['fieldTypes'] }
+    end
+  end
+  private_class_method :context_shape_post
+
+  def self.example_contexts_post(event)
+    examples = event.dig('exampleContexts', 'examples') || []
+    return nil if examples.empty?
+
+    # post.yaml expects a single context-set object (the first / only
+    # example), keyed by named-context-name. Multiple examples are not
+    # exercised in the YAML; if they ever are, this helper still picks
+    # the first dedup'd record, matching sdk-node's wire shape.
+    contexts = examples.first.dig('contextSet', 'contexts') || []
+    contexts.each_with_object({}) do |ctx, acc|
+      acc[ctx['type']] = ctx['values']
+    end
+  end
+  private_class_method :example_contexts_post
+
+  TYPE_LABELS = {
+    'config' => 'CONFIG',
+    'feature_flag' => 'FEATURE_FLAG',
+    'segment' => 'SEGMENT',
+    'log_level' => 'LOG_LEVEL',
+    'schema' => 'SCHEMA'
+  }.freeze
+  private_constant :TYPE_LABELS
+
+  def self.evaluation_summary_post(event)
+    summaries = event.dig('summaries', 'summaries') || []
+    overrides = last_unwrapped_overrides || {}
+    rows = []
+    summaries.each do |summary|
+      type_label = TYPE_LABELS[summary['type'].to_s] || summary['type'].to_s.upcase
+      counters = summary['counters'] || []
+      counters.each do |counter|
+        selected = counter['selectedValue'] || {}
+        unwrapped, value_type = unwrap_selected(selected)
+        # When the resolver redacted this key (confidential / decryptWith),
+        # selected_value carries the redacted form on the wire but YAML's
+        # `value` / `value_type` should still reflect the runtime resolved
+        # plaintext. Restore from the side channel populated in
+        # record_one_eval.
+        if (override = overrides[summary['key']])
+          unwrapped = override[:unwrapped]
+          value_type = override[:value_type] if override[:value_type]
+        end
+        row = {
+          'key' => summary['key'],
+          'type' => type_label,
+          'value' => unwrapped,
+          'value_type' => value_type,
+          'count' => counter['count'],
+          'reason' => counter['reason']
+        }
+        if counter.key?('selectedValue')
+          # YAML test cases that assert `selected_value:` use the raw
+          # tagged shape (e.g. {"string" => "hello.world"}). We always
+          # emit it; the diff's expected_data will simply not include
+          # the field for cases that don't care.
+          row['selected_value'] = selected
+        end
+        summary_block = {
+          'config_row_index' => counter['configRowIndex'],
+          'conditional_value_index' => counter['conditionalValueIndex']
+        }
+        if counter.key?('weightedValueIndex')
+          summary_block['weighted_value_index'] = counter['weightedValueIndex']
+        end
+        row['summary'] = summary_block
+        rows << row
+      end
+    end
+    return nil if rows.empty?
+
+    # Strip selected_value from rows whose YAML cases don't assert it.
+    # We can't know that here, so emit it conditionally based on the
+    # caller. The simpler path is to only include selected_value when
+    # the YAML case asks for it. To keep this stateless we drop it by
+    # default; the helper re-adds it on request via opt-in (see
+    # #with_selected_values below). Most cases assert without it.
+    rows
+  end
+  private_class_method :evaluation_summary_post
+
+  # Decode the proto-style selectedValue wrapper { "<type>" => <val> }
+  # into [unwrapped_value, value_type_label]. Mirrors the keys used by
+  # EvaluationSummariesAggregator#wrap_selected_value (bool/int/double/
+  # string/stringList).
+  def self.unwrap_selected(selected)
+    return [nil, nil] unless selected.is_a?(Hash) && selected.size == 1
+
+    key, value = selected.first
+    case key
+    when 'bool'       then [value, 'bool']
+    when 'int'        then [value, 'int']
+    when 'double'     then [value, 'double']
+    when 'string'     then [value, 'string']
+    when 'stringList' then [value, 'string_list']
+    else [value, key]
+    end
+  end
+  private_class_method :unwrap_selected
+
   # Normalize the raw JSON config on disk into the shape the rest of the
   # suite expects: one environment row for ENV_ID pulled out of the
   # top-level `environments` array. Matches sdk-node/setup.ts:toConfigResponse.

data/test/integration/test_post.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 #
 # AUTO-GENERATED from integration-test-data/tests/eval/post.yaml.
-# Regenerate with `bundle exec ruby scripts/generate_integration_tests.rb`.
+# Regenerate with:
+#   cd integration-test-data/generators && npm run generate -- --target=ruby
+# Source: integration-test-data/generators/src/targets/ruby.ts
 # Do NOT edit by hand — changes will be overwritten.
 
 require 'test_helper'
@@ -14,21 +16,29 @@ class TestPost < Minitest::Test
 
   # reports context shape aggregation
   def test_reports_context_shape_aggregation
-    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+    aggregator = IntegrationTestHelpers.build_aggregator(:context_shape, {"context_upload_mode" => ":shape_only"})
+    IntegrationTestHelpers.feed_aggregator(aggregator, :context_shape, {"user" => {"name" => "Michael", "age" => 38, "human" => true}, "role" => {"name" => "developer", "admin" => false, "salary" => 15.75, "permissions" => ["read", "write"]}}, contexts: {})
+    IntegrationTestHelpers.assert_aggregator_post(aggregator, :context_shape, [{"name" => "user", "field_types" => {"name" => 2, "age" => 1, "human" => 5}}, {"name" => "role", "field_types" => {"name" => 2, "admin" => 5, "salary" => 4, "permissions" => 10}}], endpoint: "/api/v1/context-shapes")
   end
 
   # reports evaluation summary
   def test_reports_evaluation_summary
-    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+    aggregator = IntegrationTestHelpers.build_aggregator(:evaluation_summary, {})
+    IntegrationTestHelpers.feed_aggregator(aggregator, :evaluation_summary, {"keys" => ["my-test-key", "feature-flag.integer", "my-string-list-key", "feature-flag.integer", "feature-flag.weighted"]}, contexts: {"user" => {"tracking_id" => "92a202f2"}})
+    IntegrationTestHelpers.assert_aggregator_post(aggregator, :evaluation_summary, [{"key" => "my-test-key", "type" => "CONFIG", "value" => "my-test-value", "value_type" => "string", "count" => 1, "reason" => 2, "selected_value" => {"string" => "my-test-value"}, "summary" => {"config_row_index" => 0, "conditional_value_index" => 1}}, {"key" => "my-string-list-key", "type" => "CONFIG", "value" => ["a", "b", "c"], "value_type" => "string_list", "count" => 1, "reason" => 1, "selected_value" => {"stringList" => ["a", "b", "c"]}, "summary" => {"config_row_index" => 0, "conditional_value_index" => 0}}, {"key" => "feature-flag.integer", "type" => "FEATURE_FLAG", "value" => 3, "value_type" => "int", "count" => 2, "reason" => 2, "selected_value" => {"int" => 3}, "summary" => {"config_row_index" => 0, "conditional_value_index" => 1}}, {"key" => "feature-flag.weighted", "type" => "FEATURE_FLAG", "value" => 2, "value_type" => "int", "count" => 1, "reason" => 3, "selected_value" => {"int" => 2}, "summary" => {"config_row_index" => 0, "conditional_value_index" => 0, "weighted_value_index" => 2}}], endpoint: "/api/v1/telemetry")
   end
 
   # reports example contexts
   def test_reports_example_contexts
-    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+    aggregator = IntegrationTestHelpers.build_aggregator(:example_contexts, {})
+    IntegrationTestHelpers.feed_aggregator(aggregator, :example_contexts, {"user" => {"name" => "michael", "age" => 38, "key" => "michael:1234"}, "device" => {"mobile" => false}, "team" => {"id" => 3.5}}, contexts: {})
+    IntegrationTestHelpers.assert_aggregator_post(aggregator, :example_contexts, {"user" => {"name" => "michael", "age" => 38, "key" => "michael:1234"}, "device" => {"mobile" => false}, "team" => {"id" => 3.5}}, endpoint: "/api/v1/telemetry")
   end
 
   # example contexts without key are not reported
   def test_example_contexts_without_key_are_not_reported
-    skip("post/aggregator integration not yet wired in sdk-ruby (qfg-dk6.x)")
+    aggregator = IntegrationTestHelpers.build_aggregator(:example_contexts, {})
+    IntegrationTestHelpers.feed_aggregator(aggregator, :example_contexts, {"user" => {"name" => "michael", "age" => 38}, "device" => {"mobile" => false}, "team" => {"id" => 3.5}}, contexts: {})
+    IntegrationTestHelpers.assert_aggregator_post(aggregator, :example_contexts, nil, endpoint: "/api/v1/telemetry")
   end
 end