haveapi 0.30.1 → 0.30.2

data/spec/client_examples/context_spec.rb

@@ -25,6 +25,212 @@ describe HaveAPI::ClientExample::Context do
     expect(child).to be_frozen
   end
 
+  describe '#with' do
+    let(:fields) do
+      {
+        version: 1, host: 'api.test', base_url: 'https://api.test/mount/',
+        version_url: 'https://api.test/mount/v1/',
+        description: { 'resources' => { 'widget' => { 'label' => 'Widget' } } },
+        resource_path: [:widget, 2], resource: { 'label' => 'Widget' },
+        action_name: :show, action: { 'method' => 'GET' },
+        sample: { 'request' => { 'values' => [0, false, '', nil] } }, profile: Object.new
+      }
+    end
+    let(:parent) { described_class.new(**fields) }
+    let(:replacements) do
+      {
+        version: 2, host: 'other.test', base_url: 'https://other.test/api/',
+        version_url: 'https://other.test/api/v2/',
+        description: { 'resources' => { 'other' => { 'label' => 'Other' } } },
+        resource_path: [:other, 3], resource: { 'label' => 'Other' },
+        action_name: :update, action: { 'method' => 'POST' },
+        sample: { 'request' => { 'values' => [false, 0, nil, ''] } },
+        profile: Object.new
+      }
+    end
+
+    it 'returns a distinct frozen context sharing every unchanged field' do
+      child = parent.with
+
+      expect(child).not_to equal(parent)
+      expect(child).to be_frozen
+      described_class::FIELDS.each do |field|
+        expect(child.public_send(field)).to equal(parent.public_send(field))
+      end
+      expect(child.description['resources']['widget']).to equal(parent.description['resources']['widget'])
+    end
+
+    HaveAPI::ClientExample::Context::FIELDS.each do |field|
+      it "normalizes an explicit #{field} replacement like the constructor and shares other fields" do
+        changed = { field => replacements.fetch(field) }
+        child = parent.with(**changed)
+        constructor = described_class.new(**fields, **changed)
+
+        expect(child).to be_frozen
+        expect(child.public_send(field)).to eq(constructor.public_send(field))
+        (described_class::FIELDS - [field]).each do |unchanged|
+          expect(child.public_send(unchanged)).to equal(parent.public_send(unchanged))
+        end
+        expect(parent.public_send(field)).to eq(described_class.new(**fields).public_send(field))
+      end
+    end
+
+    it 'copies supplied nested containers and strings even when their outer hash is frozen' do
+      key = ['mutable key']
+      source = { key => [{ 'value' => 'safe' }] }.freeze
+      child = parent.with(description: source, resource: source, action: source, sample: source)
+
+      %i[description resource action sample].each do |field|
+        owned = child.public_send(field)
+        expect(owned).not_to equal(source)
+        expect(owned).to be_frozen
+        expect(owned.keys.first).not_to equal(key)
+        expect(owned.keys.first).to be_frozen
+        expect(owned.keys.first.first).to be_frozen
+        expect(owned.values.first).to be_frozen
+        expect(owned.values.first.first).to be_frozen
+        expect(owned.values.first.first.keys.first).to be_frozen
+        expect(owned.values.first.first['value']).to be_frozen
+      end
+      expect(key).not_to be_frozen
+      expect(key.first).not_to be_frozen
+      expect(source.values.first).not_to be_frozen
+      expect(source.values.first.first['value']).not_to be_frozen
+      key.first.replace('changed key')
+      source.values.first.first['value'].replace('changed')
+      %i[description resource action sample].each do |field|
+        expect(child.public_send(field)).to eq(['mutable key'] => [{ 'value' => 'safe' }])
+      end
+    end
+
+    it 'detaches explicitly supplied strings and converts resource path elements without retaining them' do
+      text = +'value'
+      path = [text, :widget, 7]
+      child = parent.with(version: text, host: text, base_url: text, version_url: text,
+                          resource_path: path, action_name: text)
+
+      %i[version host base_url version_url action_name].each do |field|
+        expect(child.public_send(field)).to eq('value')
+        expect(child.public_send(field)).not_to equal(text)
+        expect(child.public_send(field)).to be_frozen
+      end
+      expect(child.resource_path).to eq(%w[value widget 7])
+      expect(child.resource_path).to be_frozen
+      expect(child.resource_path).not_to equal(path)
+      expect(child.resource_path).to all(be_frozen)
+      expect(path).not_to be_frozen
+      expect(text).not_to be_frozen
+      text.replace('changed')
+      path << 'extra'
+      expect(child.version).to eq('value')
+      expect(child.resource_path).to eq(%w[value widget 7])
+    end
+
+    it 'copies explicitly supplied owned values again instead of treating frozen data as trusted' do
+      child = parent.with(description: parent.description, resource_path: parent.resource_path,
+                          sample: parent.sample)
+
+      %i[description resource_path sample].each do |field|
+        expect(child.public_send(field)).to eq(parent.public_send(field))
+        expect(child.public_send(field)).not_to equal(parent.public_send(field))
+      end
+      expect(child.description['resources']).not_to equal(parent.description['resources'])
+      expect(child.sample['request']['values']).not_to equal(parent.sample['request']['values'])
+    end
+
+    it 'keeps parent, sibling and chained derivations detached from their supplied inputs' do
+      data = { request: { name: 'safe' } }
+      child = parent.with(sample: data)
+      sibling = parent.with(sample: data)
+      grandchild = child.with(action_name: :update)
+      fields[:description]['resources']['widget']['label'].replace('changed source')
+      data[:request][:name].replace('changed sample')
+
+      expect(parent.description['resources']['widget']['label']).to eq('Widget')
+      expect(child.description).to equal(parent.description)
+      expect(sibling.description).to equal(parent.description)
+      expect(grandchild.description).to equal(parent.description)
+      expect(parent.sample).to eq('request' => { 'values' => [0, false, '', nil] })
+      expect(child.sample).to eq(request: { name: 'safe' })
+      expect(sibling.sample).to eq(child.sample)
+      expect(sibling.sample).not_to equal(child.sample)
+      expect(grandchild.sample).to equal(child.sample)
+      expect(child.action_name).to eq('show')
+      expect(grandchild.action_name).to eq('update')
+      expect { child.sample[:request][:name].replace('forbidden') }.to raise_error(FrozenError)
+    end
+
+    it 'distinguishes omitted fields from explicit nil replacements' do
+      child = parent.with(description: nil, resource: nil, action_name: nil, action: nil, sample: nil, profile: nil)
+
+      %i[description resource action_name action sample profile].each do |field|
+        expect(child.public_send(field)).to be_nil
+        expect(parent.public_send(field)).not_to be_nil
+      end
+      expect(child.version).to equal(parent.version)
+      expect(parent.with(version: nil, host: nil, base_url: nil, version_url: nil))
+        .to have_attributes(version: '', host: '', base_url: '', version_url: '')
+      expect(context.with.action_name).to be_nil
+    end
+
+    it 'shares arbitrary profiles and non-container leaves without freezing them' do
+      leaf = Object.new
+      profile = fields.fetch(:profile)
+      child = parent.with(description: { custom: leaf }, profile: leaf)
+
+      expect(parent.profile).to equal(profile)
+      expect(parent.with.profile).to equal(profile)
+      expect(profile).not_to be_frozen
+      expect(child.profile).to equal(leaf)
+      expect(child.description[:custom]).to equal(leaf)
+      expect(leaf).not_to be_frozen
+    end
+
+    it 'continues rejecting invalid resource paths' do
+      expect { parent.with(resource_path: nil) }.to raise_error(NoMethodError)
+      expect { described_class.new(**fields, resource_path: nil) }.to raise_error(NoMethodError)
+      expect(parent.resource_path).to eq(%w[widget 2])
+    end
+
+    it 'rejects unknown keywords before normalizing any supplied values' do
+      value = Object.new
+      allow(value).to receive(:to_s).and_call_original
+
+      expect { parent.with(version: value, unknown: true) }.to raise_error(ArgumentError, 'unknown keyword: :unknown')
+      expect { parent.with(unknown: true, other: false) }
+        .to raise_error(ArgumentError, 'unknown keywords: :unknown, :other')
+      expect { parent.with('version' => '2') }.to raise_error(ArgumentError, 'unknown keyword: "version"')
+      expect(value).not_to have_received(:to_s)
+      expect(parent).not_to respond_to(:unknown)
+      expect(parent.version).to eq('1')
+    end
+
+    it 'keeps subclass constructors, extra keywords and constructor effects on every derivation' do
+      subclass = Class.new(described_class) do
+        attr_reader :marker, :initializations
+
+        def initialize(marker: :default, initializations: 0, **fields)
+          @marker = marker
+          @initializations = initializations + 1
+          super(**fields)
+        end
+      end
+      original = subclass.new(**fields, marker: :original)
+      child = original.with(marker: :child, initializations: original.initializations)
+      defaulted = original.with
+
+      expect(child).to be_a(subclass)
+      expect(child).to be_frozen
+      expect(child.marker).to eq(:child)
+      expect(child.initializations).to eq(2)
+      expect(defaulted.marker).to eq(:default)
+      expect(original.marker).to eq(:original)
+      expect(original.initializations).to eq(1)
+      expect(child.description).to eq(original.description)
+      expect(child.description).not_to equal(original.description)
+    end
+  end
+
   it 'preserves legacy initialization constructors and wraps plain source' do
     renderer = Class.new(HaveAPI::ClientExample) do
       def initialize(host, base_url, version)

data/spec/documentation/performance_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'base64'
+require_relative '../../test_support/documentation_performance_fixture'
+
+describe HaveAPI::Server, '#mount' do
+  let(:server) do
+    HaveAPI::DocumentationPerformanceFixture.build(resource_count: 3, actions_per_resource: 2)
+  end
+  let(:contexts) { [] }
+  let(:help_inputs) { [] }
+
+  before do
+    HaveAPI::ClientExample.clients.each do |client|
+      allow(client).to receive(:render).and_wrap_original do |original, kind, context:, **arguments|
+        contexts << context
+        original.call(kind, context:, **arguments)
+      end
+    end
+    allow(server).to receive(:describe_version).and_wrap_original do |original, *arguments|
+      original.call(*arguments).tap do |help|
+        help_inputs << [help, Marshal.dump(help)]
+      end
+    end
+  end
+
+  def request_as(user)
+    contexts.clear
+    Rack::MockRequest.new(server.app).get(
+      '/benchmark/api/v1/', 'HTTP_HOST' => 'example.test',
+                            'HTTP_AUTHORIZATION' => "Basic #{Base64.strict_encode64("#{user}:fixture-only")}"
+    )
+  end
+
+  def expect_shared_request(response)
+    expect(response.status).to eq(200)
+    expect(response.body).to include('PUBLIC_SAMPLE_0', 'example-resource0-action0-0',
+                                     'init-javascript-callback', 'init-javascript-async',
+                                     'init-typescript-callback', 'init-typescript-async',
+                                     'init-python-sync', 'init-python-async')
+    expect(contexts.length).to be > 20
+    description = contexts.first.description
+    contexts.each { |context| expect(context.description).to equal(description) }
+    expect(description).to be_frozen
+    description
+  end
+
+  it 'shares one description across real panels and isolates sequential admin/member/admin requests' do
+    first_admin = request_as('admin')
+    admin_description = expect_shared_request(first_admin)
+    privileged_markers = %w[ADMIN_ONLY_ACTION ADMIN_ONLY_DEFAULT ADMIN_ONLY_REQUEST ADMIN_ONLY_RESPONSE
+                            ADMIN_ONLY_ACTION_SAMPLE admin_field admin_only]
+    privileged_markers.each { |marker| expect(first_admin.body).to include(marker) }
+
+    member = request_as('member')
+    member_description = expect_shared_request(member)
+    expect(member_description).not_to equal(admin_description)
+    privileged_markers.each { |marker| expect(member.body).not_to include(marker) }
+    expect(JSON.generate(contexts.map { |context| [context.description, context.action, context.sample] }))
+      .not_to match(/ADMIN_ONLY_|admin_field|admin_only/)
+    expect(member_description[:resources]['resource0'][:actions]).not_to have_key('admin_only')
+    selected = contexts.find { |context| context.action_name == 'action0' }
+    expect(selected.action[:input][:parameters]).not_to have_key(:admin_field)
+    expect(selected.sample[:request]).to include(enabled: false, count: 0, nullable: nil, value0: '')
+
+    last_admin = request_as('admin')
+    restored_description = expect_shared_request(last_admin)
+    expect(restored_description).not_to equal(admin_description)
+    expect(restored_description).not_to equal(member_description)
+    expect(restored_description).to eq(admin_description)
+    privileged_markers.each { |marker| expect(last_admin.body).to include(marker) }
+
+    help_inputs.each do |help, original|
+      expect(Marshal.dump(help)).to eq(original)
+      expect(help).not_to be_frozen
+      expect(help[:resources]).not_to be_frozen
+      expect(help[:resources]['resource0'][:actions]['action0'][:examples].first[:request]).not_to be_frozen
+    end
+  end
+end

data/spec/performance/comparator_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'open3'
+require_relative 'support/samples'
+
+describe HaveAPI::Performance::Comparator do
+  def compare_cli(samples, budgets)
+    Dir.mktmpdir('haveapi-comparator-') do |directory|
+      input = File.join(directory, 'samples.json')
+      policy = File.join(directory, 'budgets.json')
+      output = File.join(directory, 'result')
+      File.write(input, JSON.generate(samples))
+      File.write(policy, budgets)
+      _stdout, _stderr, status = Open3.capture3(RbConfig.ruby, File.expand_path('../../benchmarks/endpoints.rb', __dir__),
+                                                'compare', '--input', input, '--budgets', policy, '--output', output)
+      [status.exitstatus, JSON.parse(File.read(File.join(output, 'report.json')))]
+    end
+  end
+
+  def replace_raw_body(sample, body)
+    output = sample['outputs'].first
+    raw = sample['bodies'].delete(output['body_sha256'])
+    digest = Digest::SHA256.hexdigest(body)
+    sample['bodies'][digest] = raw.merge('body' => body)
+    output.merge!('body_sha256' => digest, 'body_bytes' => body.bytesize)
+  end
+
+  def rebind_source(samples, role, sha)
+    samples["#{role}_sha"] = sha
+    samples['sources'][role]['sha'] = sha
+    samples['observations'].each_value do |observation|
+      observation['source']['sha'] = sha if observation['source']['root'] == samples['sources'][role]['root']
+    end
+  end
+
+  it 'passes controlled AA traces through the actual CLI' do
+    samples, budgets = PerformanceSamples.fixture
+    code, report = compare_cli(samples, budgets)
+    expect(code).to eq(0)
+    expect(report['status']).to eq('pass')
+    expect(report['cases'].first['timing'].keys).to eq(%w[wall_seconds cpu_seconds])
+    expect(report['schema_version']).to eq(2)
+    expect(report['cases'].first['correctness']).to include('status' => 'pass', 'operations_per_sample' => 1)
+    expect(JSON.generate(report)).not_to include('canonical_body', 'body_sha256', 'self_pairs', 'observations', 'loaded_sources')
+  end
+
+  it 'rejects unsupported sample formats without converting historical evidence' do
+    samples, budgets = PerformanceSamples.fixture
+    samples['schema_version'] = 1
+    code, report = compare_cli(samples, budgets)
+    expect(code).to eq(3)
+    expect(report.dig('error', 'message')).to include('Unsupported samples schema; expected 2')
+  end
+
+  it 'blocks an agreed meaningful slowdown for either clock independently' do
+    %w[wall_seconds cpu_seconds].each do |metric|
+      samples, budgets = PerformanceSamples.fixture
+      samples['cases'].first['pairs'].each { |pair| pair['candidate'][metric] = 3.0 }
+      code, report = compare_cli(samples, budgets)
+      expect(code).to eq(1)
+      expect(report['cases'].first['timing'][metric]['regression_agreement']).to eq(5)
+    end
+  end
+
+  it 'retains noisy inconclusive diagnostics without failing readiness' do
+    samples, budgets = PerformanceSamples.fixture
+    samples['cases'].first['self_pairs'].first['candidate']['wall_seconds'] = 6.0
+    code, report = compare_cli(samples, budgets)
+    expect(code).to eq(0)
+    expect(report['status']).to eq('inconclusive')
+  end
+
+  it 'requires four of five quick agreements and six of seven weekly agreements' do
+    %w[quick weekly].each do |profile|
+      samples, budgets = PerformanceSamples.fixture(profile:)
+      agreement = HaveAPI::Performance::PROFILES.fetch(profile).fetch(:agreement)
+      samples['cases'].first['pairs'].first(agreement - 1).each { |pair| pair['candidate']['wall_seconds'] = 3.0 }
+      code, report = compare_cli(samples, budgets)
+      expect(code).to eq(0)
+      expect(report['status']).to eq('inconclusive')
+      samples['cases'].first['pairs'][agreement - 1]['candidate']['wall_seconds'] = 3.0
+      expect(compare_cli(samples, budgets).first).to eq(1)
+    end
+  end
+
+  it 'uses the stricter weekly budget on the same fifteen percent increase' do
+    %w[quick weekly].each do |profile|
+      samples, budgets = PerformanceSamples.fixture(profile:)
+      samples['cases'].first['pairs'].each { |pair| pair['candidate']['wall_seconds'] = 2.30 }
+      expect(compare_cli(samples, budgets).first).to eq(profile == 'quick' ? 0 : 1)
+    end
+  end
+
+  it 'detects a cheap-request twenty-five percent regression using the batch floor' do
+    samples, budgets = PerformanceSamples.fixture
+    item = samples['cases'].first
+    item['iterations'] = 25_000
+    (item['self_pairs'] + item['pairs']).each do |pair|
+      pair.each_value do |sample|
+        next unless sample.is_a?(Hash)
+
+        sample['operations'] = 25_000
+        sample['outputs'].first['count'] = 25_000
+        sample['counters']['operations'] = 25_000
+        sample['wall_seconds'] = sample['cpu_seconds'] = 0.00004
+      end
+    end
+    item['pairs'].each { |pair| pair['candidate']['wall_seconds'] = 0.00005 }
+    expect(compare_cli(samples, budgets).first).to eq(1)
+  end
+
+  it 'validates distinct examples and rejects malformed compact counts, identities and counter summaries' do
+    samples, json = PerformanceSamples.fixture
+    budget = JSON.parse(json)
+    spec = samples['cases'].first
+    sample = Marshal.load(Marshal.dump(spec['pairs'].first['candidate']))
+    sample['operations'] = 4
+    sample['outputs'].first['count'] = 4
+    sample['counters']['operations'] = 4
+    comparator = described_class.new(samples, budget, budget_sha256: samples['budget_sha256'])
+    body = sample['bodies'].values.first['body']
+    allow(HaveAPI::Performance::Identity).to receive(:parse).and_call_original
+    comparator.send(:validate_sample, sample, 4, budget['profiles']['quick'].first, spec)
+    expect(HaveAPI::Performance::Identity).to have_received(:parse).with(body).once
+    %w[http_status envelope_status body_bytes body_sha256 canonical_sha256 comparison counter missing zero negative float total counter_count duplicate unreferenced].each do |fault|
+      broken = Marshal.load(Marshal.dump(sample))
+      output = broken['outputs'].last
+      case fault
+      when 'http_status' then output[fault] = 403
+      when 'envelope_status' then output[fault] = false
+      when 'body_bytes' then output[fault] += 1
+      when 'comparison' then output[fault] = { 'kind' => 'own-webui-href', 'own_version' => '0.30.2' }
+      when 'counter' then broken['counters']['record']['authorizations'] = 0
+      when 'missing' then broken['counters'].delete('record')
+      when 'zero' then output['count'] = 0
+      when 'negative' then output['count'] = -1
+      when 'float' then output['count'] = 4.0
+      when 'total' then output['count'] = 3
+      when 'counter_count' then broken['counters']['operations'] = 4.0
+      when 'duplicate'
+        output['count'] = 2
+        broken['outputs'] << output.dup
+      when 'unreferenced'
+        other_body = '{"status":true}'
+        broken['bodies'][Digest::SHA256.hexdigest(other_body)] = { 'body' => other_body, 'canonical_body' => JSON.parse(other_body) }
+      else output[fault] = '0' * 64
+      end
+      expect { comparator.send(:validate_sample, broken, 4, budget['profiles']['quick'].first, spec) }.to raise_error(StandardError)
+    end
+    # A second sample must independently prove its retained body again.
+    comparator.send(:validate_sample, sample, 4, budget['profiles']['quick'].first, spec)
+    expect(HaveAPI::Performance::Identity).to have_received(:parse).with(body).at_least(:twice)
+  end
+
+  it 'rejects raw/canonical disagreement and duplicate JSON on a reused body and rejects counts above the shared cap' do
+    %w[canonical duplicate cap].each do |fault|
+      samples, json = PerformanceSamples.fixture
+      spec = samples['cases'].first
+      sample = spec['pairs'].first['candidate']
+      if fault == 'canonical'
+        sample['bodies'].values.first['canonical_body']['response']['zero'] = 1
+      elsif fault == 'duplicate'
+        body = sample['bodies'].values.first['body'].sub('"status":true', '"status":false,"status":true')
+        replace_raw_body(sample, body)
+      else
+        spec['iterations'] = 100_001
+      end
+      comparator = described_class.new(samples, JSON.parse(json), budget_sha256: samples['budget_sha256'])
+      expect { comparator.compare }.to raise_error(HaveAPI::Performance::ContractError)
+    end
+  end
+
+  it 'compares response occurrence totals across revisions without retaining request order' do
+    samples, json = PerformanceSamples.fixture
+    spec = samples['cases'].first
+    spec['iterations'] = 3
+    (spec['self_pairs'] + spec['pairs']).each do |pair|
+      %w[baseline candidate].each do |role|
+        sample = pair[role]
+        output = sample['outputs'].first
+        body = sample['bodies'].values.first['body'].sub('"zero":0', '"zero":1')
+        canonical = JSON.parse(body)
+        digest = Digest::SHA256.hexdigest(body)
+        sample['bodies'][digest] = { 'body' => body, 'canonical_body' => canonical }
+        sample['operations'] = 3
+        sample['outputs'] << output.merge('body_sha256' => digest, 'body_bytes' => body.bytesize,
+                                          'canonical_sha256' => HaveAPI::Performance::Identity.digest(canonical), 'count' => 2)
+        sample['counters']['operations'] = 3
+      end
+    end
+    comparator = described_class.new(samples, JSON.parse(json), budget_sha256: samples['budget_sha256'])
+    expect(comparator.compare['status']).to eq('pass')
+    spec['pairs'].last['candidate']['outputs'].reverse!
+    expect(comparator.compare['status']).to eq('pass')
+    spec['pairs'].last['candidate']['outputs'].each { |example| example['count'] = 3 - example['count'] }
+    expect { comparator.compare }.to raise_error(HaveAPI::Performance::ContractError, /Response identity/)
+  end
+
+  it 'rejects retained runaway request batches even if both sources are equally slow' do
+    samples, budgets = PerformanceSamples.fixture
+    item = samples['cases'].first
+    (item['self_pairs'] + item['pairs']).each do |pair|
+      %w[baseline candidate].each { |role| pair[role]['wall_seconds'] = 100.0 }
+    end
+    code, report = compare_cli(samples, budgets)
+    expect(code).to eq(3)
+    expect(report.dig('error', 'message')).to include('Request batch exceeds 30.0s')
+  end
+
+  it 'rejects raw integer/float drift even when forged raw metadata is consistent' do
+    [[0, 0.0], [0.0, 0]].each do |original, changed|
+      samples, budgets = PerformanceSamples.fixture(zero: original)
+      target = samples['cases'].first['pairs'].first['candidate']
+      body = JSON.parse(target['bodies'].values.first['body'])
+      body['response']['zero'] = changed
+      replace_raw_body(target, JSON.generate(body))
+      code, report = compare_cli(samples, budgets)
+      expect(code).to eq(3)
+      expect(report.dig('error', 'message')).to include('Raw/canonical output values differ')
+    end
+  end
+
+  it 'allows raw map-order changes through the actual CLI' do
+    samples, budgets = PerformanceSamples.fixture
+    target = samples['cases'].first['pairs'].first['candidate']
+    body = JSON.parse(target['bodies'].values.first['body'])
+    body['response'] = body['response'].to_a.reverse.to_h
+    replace_raw_body(target, JSON.generate(body.to_a.reverse.to_h))
+    expect(compare_cli(samples, budgets).first).to eq(0)
+  end
+
+  it 'rejects identical source SHAs even with consistently rebound provenance' do
+    samples, budgets = PerformanceSamples.fixture
+    rebind_source(samples, 'candidate', samples['baseline_sha'])
+    code, report = compare_cli(samples, budgets)
+    expect(code).to eq(3)
+    expect(report.dig('error', 'message')).to include('Baseline and candidate must differ')
+  end
+
+  it 'requires the fixed weekly baseline and accepts valid fixed-reference evidence' do
+    samples, budgets = PerformanceSamples.fixture(profile: 'weekly')
+    expect(compare_cli(samples, budgets).first).to eq(0)
+    rebind_source(samples, 'baseline', 'a' * 40)
+    code, report = compare_cli(samples, budgets)
+    expect(code).to eq(3)
+    expect(report.dig('error', 'message')).to include('Weekly baseline must be the fixed reference')
+  end
+
+  it 'requires both the percentage and absolute timing thresholds' do
+    samples, budgets = PerformanceSamples.fixture
+    samples['cases'].first['pairs'].each do |pair|
+      pair['baseline']['wall_seconds'] = 0.0001
+      pair['candidate']['wall_seconds'] = 0.00013
+    end
+    expect(compare_cli(samples, budgets).first).to eq(0)
+  end
+
+  it 'blocks allocation growth and the independent fixed reference ceiling' do
+    samples, budgets = PerformanceSamples.fixture
+    samples['cases'].first['pairs'].each { |pair| pair['candidate']['allocated_objects'] = 140 }
+    expect(compare_cli(samples, budgets).first).to eq(1)
+    samples['cases'].first['pairs'].each do |pair|
+      pair['baseline']['allocated_objects'] = 180
+      pair['candidate']['allocated_objects'] = 180
+    end
+    expect(compare_cli(samples, budgets).first).to eq(1)
+  end
+
+  it 'requires full Rust cases and their relative allocation and authorization contracts' do
+    %w[missing allocations authorization].each do |fault|
+      samples, budgets = PerformanceSamples.fixture
+      case fault
+      when 'missing'
+        samples['inventory'].pop
+        samples['cases'].pop
+      when 'allocations'
+        samples['cases'].last['pairs'].each { |pair| pair['candidate']['allocated_objects'] = 200 }
+      else
+        samples['cases'].last['pairs'].first['candidate']['counters']['record']['authorizations'] -= 1
+      end
+      expect(compare_cli(samples, budgets).first).to eq(fault == 'allocations' ? 1 : 3)
+    end
+  end
+
+  it 'blocks uncalibrated reference budgets' do
+    samples, json = PerformanceSamples.fixture
+    budgets = JSON.parse(json)
+    budgets.delete('calibration')
+    json = JSON.generate(budgets)
+    samples['budget_sha256'] = Digest::SHA256.hexdigest(json)
+    expect(compare_cli(samples, json).first).to eq(3)
+  end
+
+  it 'blocks missing cases, operations, dependency graphs and source provenance' do
+    %w[cases outputs inputs sources].each do |missing|
+      samples, budgets = PerformanceSamples.fixture
+      case missing
+      when 'cases' then samples['cases'].clear
+      when 'outputs' then samples['cases'].first['pairs'].first['candidate']['outputs'].clear
+      else samples.delete(missing)
+      end
+      expect(compare_cli(samples, budgets).first).to eq(3)
+    end
+  end
+
+  it 'rejects missing or changed workload order and runtime policy' do
+    %w[workload_order worker_order runtime_policy].each do |fault|
+      samples, budgets = PerformanceSamples.fixture
+      case fault
+      when 'workload_order' then samples['cases'].first['pairs'][1]['workload_order'] = 'forward'
+      when 'worker_order' then samples['observations']['candidate-reverse']['workload_order'] = 'forward'
+      else samples['observations']['baseline']['runtime_policy']['timezone'] = 'local'
+      end
+      expect(compare_cli(samples, budgets).first).to eq(3)
+    end
+  end
+
+  it 'blocks extra queries, lost authorizations, wrong output and changed dependency graphs' do
+    %w[queries authorizations output environment].each do |fault|
+      samples, budgets = PerformanceSamples.fixture
+      target = samples['cases'].first['pairs'].first['candidate']
+      case fault
+      when 'queries' then target['counters']['record']['queries'] = 1
+      when 'authorizations' then target['counters']['record']['authorizations'] = 0
+      when 'output' then target['outputs'].first['canonical_sha256'] = '0' * 64
+      else samples['observations']['candidate']['environment'] = {}
+      end
+      expect(compare_cli(samples, budgets).first).to eq(3)
+    end
+  end
+
+  it 'preserves scalar types and array order while ignoring map order only' do
+    identity = HaveAPI::Performance::Identity
+    expect(identity.digest(a: 0, b: [false, '', nil])).to eq(identity.digest('b' => [false, '', nil], 'a' => 0))
+    expect(identity.digest(a: 0)).not_to eq(identity.digest(a: 0.0))
+    expect(identity.digest(a: [false, nil])).not_to eq(identity.digest(a: [nil, false]))
+    expect { identity.digest(a: 0, 'a' => 1) }.to raise_error(HaveAPI::Performance::ContractError)
+    ['{"status":false,"status":true}', '{"a":[{"b":1,"b":2}]}'].each do |json|
+      expect { identity.parse(json) }.to raise_error(HaveAPI::Performance::ContractError, /Duplicate/)
+    end
+  end
+end