Initial curated chimera source from a8ae5b1db07fb49926c94585e2718e5130330974

test/server/ch-1401-p15-r2-qualification.test.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const test = require('node:test');
+const {
+  A10_OBSERVER,
+  PPSA_ARTIFACT,
+  armP15R2LaunchBudget,
+  assessP15R2Dependencies,
+  assessP15R2Foreground,
+  assessP15R2InstalledContent,
+  assessP15R2LaunchReadiness,
+  classifyP15R2LaunchResult,
+  consumeP15R2LaunchBudget,
+  createP15R2LaunchBudget,
+  createP15R2Profile,
+  selectP15R2ObserverLane,
+} = require('../../src/services/ps5-p15-r2-qualification');
+
+function installedComplete() {
+  return {
+    installedObserved: true,
+    scanCoverageComplete: true,
+    scanCurrent: true,
+    titleIdExact: true,
+    contentIdExact: true,
+    versionExact: true,
+    applicationDrmTypeExpected: true,
+    sonyManagedInstallation: true,
+    appPkgPresent: true,
+    appPkgFullRead: true,
+    appPkgSizeCoherent: true,
+    appPkgHashStable: true,
+    paramJsonPresent: true,
+    paramJsonMatchesReference: true,
+    sourceManifestEbootPresent: true,
+    manifestCoverageComplete: true,
+    materiallyComplete: true,
+    ghostRegistrationAbsent: true,
+    mountRedirectAbsent: true,
+  };
+}
+
+function exactProfileInput() {
+  const tree = 'c'.repeat(40);
+  return {
+    repository: { commit: 'a'.repeat(40), tree, workingTreeDigest: crypto.createHash('sha256').update(`git-tree:${tree}`).digest('hex') },
+    firmware: '9.60',
+    installedContent: installedComplete(),
+    runtime: {
+      production: { status: 'exact', lane: 'production', identityExact: true },
+      ps5uploadRevision: A10_OBSERVER.baseRevision,
+      engineSha256: A10_OBSERVER.engineSha256,
+      payloadSha256: A10_OBSERVER.payloadSha256,
+      identityExact: true,
+      kstuffRevision: '3b2ab4a16ba43c8ab38daf7ec83cc297014e0e47',
+      kstuffIdentityExact: true,
+    },
+    observer: { ...A10_OBSERVER, identityExact: true },
+    foreground: {
+      inventoryComplete: true,
+      shellUiPid: 110,
+      runningBigAppId: -1,
+      applicationProcesses: [],
+    },
+  };
+}
+
+test('FTP offline only blocks when no complete alternative installed-content provider exists', () => {
+  const blocked = assessP15R2Dependencies({ ftp: { online: false }, alternativeInstalledContentProvider: { complete: false } });
+  assert.equal(blocked.ready, false);
+  assert.deepEqual(blocked.blocking, ['installed_content_provider_unavailable']);
+  const alternative = assessP15R2Dependencies({ ftp: { online: false }, alternativeInstalledContentProvider: { complete: true } });
+  assert.equal(alternative.ready, true);
+});
+
+test('optional provider outages do not block R2 qualification', () => {
+  const result = assessP15R2Dependencies({
+    ftp: { online: true },
+    optionalProviders: { standaloneDpi: false, voidPkg: false, websrv: false },
+  });
+  assert.equal(result.ready, true);
+  assert.deepEqual(result.blocking, []);
+  assert.deepEqual([...result.optionalOffline].sort(), ['standaloneDpi', 'voidPkg', 'websrv']);
+});
+
+test('installed visibility remains unproven until current full material evidence is complete', () => {
+  assert.equal(assessP15R2InstalledContent({ installedObserved: true }).status, 'installed_unproven');
+  assert.equal(assessP15R2InstalledContent({ ...installedComplete(), appPkgFullRead: false }).status, 'installed_incomplete');
+  const complete = assessP15R2InstalledContent({ ...installedComplete(), appPkgMatchesTransportHash: false });
+  assert.equal(complete.status, 'installed_complete');
+  assert.equal(complete.transportHashComparisonRequired, false);
+});
+
+test('launch stays blocked unless install, runtime, observer and foreground are exact', () => {
+  const input = exactProfileInput();
+  const cases = [
+    { installedContent: { installedObserved: true }, reason: 'installed_content_integrity_unproven' },
+    { runtime: { ...input.runtime, identityExact: false }, reason: 'active_runtime_identity_unproven' },
+    { observer: { ...input.observer, identityExact: false }, reason: 'observer_identity_unproven' },
+    { foreground: { ...input.foreground, applicationProcesses: [{ titleId: 'FAKE00000', pid: 222 }] }, reason: 'foreground_not_clean' },
+  ];
+  for (const entry of cases) {
+    const readiness = assessP15R2LaunchReadiness({ ...input, ...entry });
+    assert.equal(readiness.launchEligible, false);
+    assert.ok(readiness.reasons.includes(entry.reason));
+    assert.deepEqual(readiness.launchBudget, { state: 'blocked', used: 0, total: 1, remaining: 1 });
+  }
+});
+
+test('profile rejects missing or mismatched Git tree identity', () => {
+  const missing = exactProfileInput();
+  delete missing.repository.tree;
+  assert.throws(() => createP15R2Profile(missing), error => error.code === 'P15_R2_PROFILE_UNPROVEN' && error.details.reasons.includes('repository_identity_unproven'));
+  const mismatch = exactProfileInput();
+  mismatch.repository.workingTreeDigest = 'f'.repeat(64);
+  assert.throws(() => createP15R2Profile(mismatch), error => error.code === 'P15_R2_PROFILE_UNPROVEN' && error.details.reasons.includes('repository_identity_unproven'));
+});
+
+test('budget arms once, is consumed before dispatch and ambiguity can never rearm it', () => {
+  const profile = createP15R2Profile(exactProfileInput());
+  const readiness = assessP15R2LaunchReadiness(profile);
+  const initial = createP15R2LaunchBudget();
+  assert.deepEqual(initial, { schema: 'chimera.ps5-p15-r2-launch-budget.v1', state: 'blocked', used: 0, total: 1, profileFingerprint: null, operationId: null, terminalOutcome: null });
+  const armed = armP15R2LaunchBudget(initial, readiness);
+  assert.equal(armed.state, 'armed');
+  const consumed = consumeP15R2LaunchBudget(armed, {
+    confirmation: 'LAUNCH VERIFY PPSA99099', operationId: 'p15-r2-owned-hardware-1', profileFingerprint: profile.fingerprint,
+  });
+  assert.equal(consumed.state, 'consumed');
+  assert.equal(consumed.used, 1);
+  assert.throws(() => armP15R2LaunchBudget(consumed, readiness), { code: 'P15_R2_LAUNCH_BUDGET_FINAL' });
+});
+
+test('R2 profile and observer lane bind exact artifact, runtime, observer and clean baseline', () => {
+  const profile = createP15R2Profile(exactProfileInput());
+  assert.equal(profile.id, 'P15-R2-PPSA99099');
+  assert.equal(profile.artifact.sha256, PPSA_ARTIFACT.sha256);
+  assert.equal(Object.isFrozen(profile), true);
+  const readiness = assessP15R2LaunchReadiness(profile);
+  assert.equal(readiness.launchEligible, true);
+  assert.equal(readiness.confirmation, 'LAUNCH VERIFY PPSA99099');
+  assert.equal(selectP15R2ObserverLane({ titleId: 'PPSA99099', readiness }), 'a10_transition');
+  assert.equal(selectP15R2ObserverLane({ titleId: 'PPSA99099', readiness: { ...readiness, launchEligible: false } }), 'blocked');
+  assert.equal(selectP15R2ObserverLane({ titleId: 'FAKE00000', readiness }), 'production');
+});
+
+test('foreground requires complete inventory, idle BigApp and no application process', () => {
+  assert.equal(assessP15R2Foreground(exactProfileInput().foreground).clean, true);
+  assert.equal(assessP15R2Foreground({ ...exactProfileInput().foreground, inventoryComplete: false }).clean, false);
+  assert.equal(assessP15R2Foreground({ ...exactProfileInput().foreground, runningBigAppId: 7 }).clean, false);
+  assert.equal(assessP15R2Foreground({ ...exactProfileInput().foreground, applicationProcesses: [{ titleId: 'CHIM00003', pid: 321 }] }).clean, false);
+});
+
+test('a numeric BigApp allocation without exact title attribution or process is not verified', () => {
+  const result = classifyP15R2LaunchResult({
+    lncAccepted: true, preRunningBigAppId: -1,
+    samples: [{ observedAfterMs: 100, runningBigAppId: 44, processInventoryComplete: true, targetPid: null }],
+  });
+  assert.equal(result.classification, 'accepted_unattributed_bigapp');
+  assert.equal(result.launchVerified, false);
+});
+
+test('exact PPSA BigApp attribution narrows the boundary but does not verify launch without a process', () => {
+  const result = classifyP15R2LaunchResult({
+    lncAccepted: true, preRunningBigAppId: -1,
+    samples: [{ observedAfterMs: 100, runningBigAppId: 44, resolvedTitleId: 'PPSA99099', processInventoryComplete: true, targetPid: null }],
+  });
+  assert.equal(result.classification, 'exact_title_bigapp_observed');
+  assert.equal(result.launchVerified, false);
+});
+
+test('stable exact PPSA process qualifies while content-auth internals remain unknown', () => {
+  const result = classifyP15R2LaunchResult({
+    lncAccepted: true, preRunningBigAppId: -1,
+    samples: [
+      { observedAfterMs: 250, runningBigAppId: 44, processInventoryComplete: true, targetPid: 777, targetTitleId: 'PPSA99099' },
+      { observedAfterMs: 1000, runningBigAppId: 44, processInventoryComplete: true, targetPid: 777, targetTitleId: 'PPSA99099' },
+    ],
+  });
+  assert.equal(result.classification, 'stable_exact_title_process_observed');
+  assert.equal(result.launchVerified, true);
+  assert.deepEqual(result.contentAuthentication, { verifyImage: 'unknown', eicv: 'unknown', pfs: 'unknown' });
+});