@githolon/dsl 0.108.7 → 0.110.1

package/dart/test/acquire_session_test.dart

@@ -1,534 +0,0 @@
-// acquireSession — the ATOMIC session-open (co2 DX ask): reuses a mounted session, opens a plane-resident
-// (parked / resident-custody) workspace locally, JOINS an in-flight open (single-flight per workspace), and
-// invokes the credentials callback ONLY when a cloud open is genuinely required. Proven hermetically over a
-// fake transport (the same style as webview_bridge_test.dart) — the live-runner leg rides
-// cluster_local_autosync_test.dart.
-import 'dart:async';
-
-import 'package:nomos_client/src/nms_generated_runtime.dart';
-import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
-import 'package:test/test.dart';
-
-/// A fake runner: answers connect (after a real async gap, so concurrency is observable) and
-/// listWorkspaces (from [resident]); records every request.
-class FakeRunner implements BridgeTransport {
-  final _incoming = StreamController<Map<String, Object?>>.broadcast();
-  final List<Map<String, Object?>> sent = [];
-  final List<protocol.RuntimeRequest> runtimeRequests = [];
-  final List<String>
-      resident; // workspaces the plane already holds (realm.list())
-
-  FakeRunner({this.resident = const []}) {
-    scheduleMicrotask(() => _incoming.add({
-          'v': kWebviewBridgeVersion,
-          'event': 'ready',
-          'bundleVersion': 'unbundled-dev'
-        }));
-  }
-
-  int get connectCount => sent.where((m) => m['op'] == 'connect').length;
-  int autoSyncCount(String workspace) => runtimeRequests
-      .where((request) =>
-          request.whichCommand() ==
-              protocol.RuntimeRequest_Command.startAutoSync &&
-          request.startAutoSync.session == workspace)
-      .length;
-  Map<String, Object?> connectArgs(int i) =>
-      (sent.where((m) => m['op'] == 'connect').elementAt(i)['args'] as Map)
-          .cast<String, Object?>();
-
-  @override
-  Stream<Map<String, Object?>> get messages => _incoming.stream;
-
-  @override
-  Future<protocol.RuntimeResponse> invokeRuntime(
-    protocol.RuntimeRequest request,
-  ) async {
-    runtimeRequests.add(request.deepCopy());
-    final response = protocol.RuntimeResponse(
-      protocolVersion: 2,
-      requestId: request.requestId,
-    );
-    switch (request.whichCommand()) {
-      case protocol.RuntimeRequest_Command.listWorkspaces:
-        final connected = sent
-            .where((message) => message['op'] == 'connect')
-            .map(
-                (message) => ((message['args'] as Map)['workspace']).toString())
-            .toSet();
-        response.workspaceList = protocol.WorkspaceList(
-          workspaces: [
-            for (final workspace in {...resident, ...connected})
-              protocol.WorkspaceSummary(
-                session: workspace,
-                workspace: workspace,
-                residency: connected.contains(workspace)
-                    ? protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_MOUNTED
-                    : protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_PARKED,
-                syncPosture: protocol
-                    .WorkspaceSyncPosture.WORKSPACE_SYNC_POSTURE_LOCAL_ONLY,
-              ),
-          ],
-        );
-        break;
-      case protocol.RuntimeRequest_Command.startAutoSync:
-        response.autoSyncStarted =
-            protocol.AutoSyncStarted(session: request.startAutoSync.session);
-        break;
-      case protocol.RuntimeRequest_Command.stopAutoSync:
-        response.autoSyncStopped =
-            protocol.AutoSyncStopped(session: request.stopAutoSync.session);
-        break;
-      case protocol.RuntimeRequest_Command.closeRealm:
-        response.realmClosed = protocol.RealmClosed();
-        break;
-      default:
-        throw StateError(
-          'FakeRunner does not implement ${request.whichCommand().name}',
-        );
-    }
-    return response;
-  }
-
-  @override
-  void send(Map<String, Object?> message) {
-    sent.add(message);
-    final id = message['id'] as int;
-    final op = message['op'] as String;
-    final args = (message['args'] as Map).cast<String, Object?>();
-    Future<void>.delayed(const Duration(milliseconds: 5), () {
-      Object? result;
-      switch (op) {
-        case 'connect':
-          result = {'workspace': args['workspace']};
-          break;
-        case 'listWorkspaces':
-          // Realm truth: a CONNECTED workspace is mounted (holon live); a resident-but-unconnected one is
-          // parked custody. Reflect connects so the derived lifecycle `state` is observable in both postures.
-          final connected = sent
-              .where((m) => m['op'] == 'connect')
-              .map((m) => ((m['args'] as Map)['workspace']).toString())
-              .toSet();
-          final all = {...resident, ...connected};
-          result = {
-            'workspaces': [
-              for (final ws in all)
-                {
-                  'session': ws,
-                  'workspace': ws,
-                  'mounted': connected.contains(ws),
-                  'parked': !connected.contains(ws) && resident.contains(ws),
-                  'syncPosture': 'local-only'
-                }
-            ]
-          };
-          break;
-        case 'snapshotWorkspace':
-          result = {
-            'workspace': args['workspace'],
-            'head': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-            if (args['ifHead'] == 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
-              'unchanged': true
-            else
-              'snapshot': 'resident-snapshot-b64',
-          };
-          break;
-        default:
-          result = {};
-      }
-      _incoming.add(
-          {'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result});
-    });
-  }
-}
-
-void main() {
-  test(
-      'an already-connected session is reused — credentials NEVER invoked, no second connect',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await bridge.connect(workspace: 'home', session: 'home');
-    expect(runner.connectCount, 1);
-
-    final s = await bridge.acquireSession('home',
-        ifAbsentCredentials: () async =>
-            fail('credentials must not be requested for a mounted session'));
-    expect(identical(s, bridge.session('home')), isTrue);
-    expect(runner.connectCount, 1, reason: 'no re-connect for a live session');
-    expect(runner.autoSyncCount('home'), 1,
-        reason: 'an acquired application workspace continuously syncs');
-    await bridge.dispose();
-  });
-
-  test(
-      'a plane-resident workspace binds retained cloud credentials so background sync owns it',
-      () async {
-    final runner = FakeRunner(resident: ['estate']);
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-
-    var asked = false;
-    final s =
-        await bridge.acquireSession('estate', ifAbsentCredentials: () async {
-      asked = true;
-      return const NomosSessionCredentials(cloud: 'https://never.invalid');
-    });
-    expect(asked, isTrue,
-        reason:
-            'a generated resident child must acquire its continuous cloud posture');
-    expect(s.workspace, 'estate');
-    expect(runner.connectCount, 1);
-    expect(runner.connectArgs(0)['cloud'], 'https://never.invalid');
-    await bridge.dispose();
-  });
-
-  test(
-      'concurrent acquisition SINGLE-FLIGHTS: one open, one credentials call, the same session',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-
-    var credentialCalls = 0;
-    Future<NomosSessionCredentials> creds() async {
-      credentialCalls++;
-      await Future<void>.delayed(const Duration(milliseconds: 10));
-      return const NomosSessionCredentials(
-          cloud: 'https://cloud.example', authToken: 'tok', allowUnborn: true);
-    }
-
-    final results = await Future.wait([
-      bridge.acquireSession('cloudy', ifAbsentCredentials: creds),
-      bridge.acquireSession('cloudy', ifAbsentCredentials: creds),
-      bridge.acquireSession('cloudy', ifAbsentCredentials: creds),
-    ]);
-    expect(credentialCalls, 1,
-        reason: 'the credentials callback fires exactly once');
-    expect(runner.connectCount, 1,
-        reason: 'ONE connect for three concurrent acquires');
-    expect(identical(results[0], results[1]), isTrue);
-    expect(identical(results[1], results[2]), isTrue);
-    expect(runner.autoSyncCount('cloudy'), 1,
-        reason: 'the workspace lifecycle is single-flight too');
-    final args = runner.connectArgs(0);
-    expect(args['cloud'], 'https://cloud.example');
-    expect(args['authToken'], 'tok');
-    expect(args['allowUnborn'], isTrue);
-    await bridge.dispose();
-  });
-
-  test(
-      'genuinely absent + no credentials callback → a named StateError (never a silent cloudless mount)',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await expectLater(bridge.acquireSession('nowhere'), throwsStateError);
-    expect(runner.connectCount, 0);
-    await bridge.dispose();
-  });
-
-  test(
-      'an absent generated child restores opaque local custody before cloud convergence',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    var loads = 0;
-    bridge.nomosInternalRetainLocalCustodyLoader((workspace) async {
-      loads++;
-      expect(workspace, 'catalogue');
-      return 'opaque-kernel-snapshot';
-    });
-
-    final child = await bridge.acquireSession(
-      'catalogue',
-      ifAbsentCredentials: () async => const NomosSessionCredentials(
-        cloud: 'https://cloud.example',
-        authToken: 'token',
-      ),
-    );
-
-    expect(child.workspace, 'catalogue');
-    expect(loads, 1);
-    expect(runner.connectCount, 1);
-    expect(runner.connectArgs(0)['restoreFrom'], 'opaque-kernel-snapshot');
-    expect(runner.connectArgs(0)['cloud'], 'https://cloud.example');
-    await bridge.dispose();
-  });
-
-  test('opaque local custody can open without inventing cloud authority',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    bridge.nomosInternalRetainLocalCustodyLoader(
-      (_) async => 'opaque-kernel-snapshot',
-    );
-
-    final child = await bridge.acquireSession('offline-child');
-
-    expect(child.workspace, 'offline-child');
-    expect(runner.connectCount, 1);
-    final args = runner.connectArgs(0);
-    expect(args['restoreFrom'], 'opaque-kernel-snapshot');
-    expect(args.containsKey('cloud'), isFalse);
-    await bridge.dispose();
-  });
-
-  test(
-      'a NomosSession delegates acquireSession to the parent plane (one registry)',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await bridge.connect(workspace: 'home', session: 'home');
-    await bridge.connect(workspace: 'estate', session: 'estate');
-
-    final viaSession = await bridge.session('home').acquireSession('estate',
-        ifAbsentCredentials: () async =>
-            fail('estate is already mounted — no credentials'));
-    expect(identical(viaSession, bridge.session('estate')), isTrue);
-    await bridge.dispose();
-  });
-
-  test('a resident child inherits its opening session identity', () async {
-    final runner = FakeRunner(resident: ['child']);
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await bridge.connect(
-      workspace: 'home',
-      session: 'home',
-      authToken: 'header.eyJzdWIiOiJhZGEifQ.signature',
-    );
-
-    final child = await bridge.session('home').acquireSession('child');
-
-    expect(child.principal, 'user:ada');
-    await bridge.dispose();
-  });
-
-  test('an in-place signing-key refresh is inherited by later sibling opens',
-      () async {
-    final runner = FakeRunner(resident: ['catalogue', 'estate']);
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await bridge.connect(workspace: 'home', session: 'home');
-
-    await bridge
-        .session('home')
-        .refreshCredentials(authorSecret: 'newly-enrolled-device-key');
-    await bridge.session('home').acquireSession('catalogue');
-
-    expect(runner.connectCount, 2);
-    expect(runner.connectArgs(1)['authorSecret'], 'newly-enrolled-device-key',
-        reason:
-            'refreshing the resident holon must also advance the plane credential inherited by siblings');
-
-    await bridge.session('home').refreshCredentials(authorSecret: '');
-    await bridge.session('home').acquireSession('estate');
-    expect(runner.connectArgs(2).containsKey('authorSecret'), isFalse,
-        reason:
-            'clearing a resident signing key must not leak it into later sibling opens');
-    await bridge.dispose();
-  });
-
-  test(
-      'generated child inherits typed model decisions and stages opaque USDZ privately',
-      () async {
-    final runner = FakeRunner(resident: ['child']);
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await bridge.connect(
-      workspace: 'home',
-      session: 'home',
-      authToken: 'header.eyJzdWIiOiJhZGEifQ.signature',
-    );
-    var handled = false;
-    final home = bridge.session('home');
-    home.nomosInternalRetainModelChangeHandler((change) async {
-      handled = change.expectedDomainHash == 'candidate';
-    });
-    final child = await home.acquireSession('child');
-    await home.nomosInternalEnsureGeneratedModelInChild(
-      childWorkspace: 'child',
-      domain: 'catalogue',
-      candidateHash: 'candidate',
-      lawUsdz: const [1, 2, 3],
-    );
-    await child.nomosInternalHandleModelChange(
-      const DomainClientModelAdoptionRequired(
-        expectedDomainKey: 'catalogue',
-        expectedDomainHash: 'candidate',
-        status: 'needs-decision',
-        summary: 'review',
-        review: DomainModelReview(
-          checkedActions: 1,
-          candidateActions: 1,
-          sameOutcome: true,
-          differences: [],
-        ),
-      ),
-    );
-    expect(handled, isTrue);
-    final stage = runner.sent.singleWhere(
-      (message) => message['op'] == 'stageGeneratedModelFromParent',
-    );
-    expect((stage['args'] as Map)['sourceSession'], 'home');
-    expect((stage['args'] as Map)['session'], 'child');
-    expect((stage['args'] as Map)['lawUsdz'], 'AQID');
-    await home.nomosInternalStageGeneratedModel(
-      domain: 'catalogue',
-      candidateHash: 'candidate',
-      lawUsdz: const [4, 5, 6],
-    );
-    final rootStage = runner.sent.singleWhere(
-      (message) => message['op'] == 'stageGeneratedModel',
-    );
-    expect((rootStage['args'] as Map)['session'], 'home');
-    expect((rootStage['args'] as Map)['lawUsdz'], 'BAUG');
-    await bridge.dispose();
-  });
-
-  test(
-      'a generated application session privately refreshes cloud access for an absent referenced workspace',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    await bridge.connect(
-      cloud: 'https://cloud.example',
-      workspace: 'home',
-      session: 'home',
-      authToken: 'header.eyJzdWIiOiJhZGEifQ.signature',
-      authorSecret: 'device-secret',
-    );
-    var refreshes = 0;
-    bridge.session('home').nomosInternalRetainCloudAccess(
-          cloud: 'https://cloud.example',
-          signIn: () async {
-            refreshes += 1;
-            return 'fresh-token-$refreshes';
-          },
-        );
-
-    final target = await bridge.session('home').acquireSession('shared-home');
-    expect(target.workspace, 'shared-home');
-    expect(refreshes, 1);
-    expect(runner.connectArgs(1)['cloud'], 'https://cloud.example');
-    expect(runner.connectArgs(1)['authToken'], 'fresh-token-1');
-    expect(runner.connectArgs(1)['authorSecret'], 'device-secret');
-    expect(target.principal, 'user:ada');
-
-    // The retained posture follows the opened handle, so navigation can continue without a public lane.
-    final child = await target.acquireSession('shared-child');
-    expect(child.workspace, 'shared-child');
-    expect(refreshes, 2);
-    expect(runner.connectArgs(2)['authToken'], 'fresh-token-2');
-    await bridge.dispose();
-  });
-
-  // ── SESSION-STATE DX cluster (co2): explicit lifecycle state + fail-at-bind + openable refs ──
-
-  test(
-      'listWorkspaces() reports explicit state: resident/parked before open, connected after',
-      () async {
-    final runner = FakeRunner(
-        resident: ['estate']); // realm returns mounted:false, parked:true
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-
-    // Before any connect: the plane-resident (parked) workspace surfaces with an explicit non-connected state.
-    var list = await bridge.listWorkspaces();
-    final before =
-        list.firstWhere((workspace) => workspace.workspace == 'estate');
-    expect(before.residency,
-        protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_PARKED,
-        reason:
-            'parked custody is not connected — the app must acquire it first');
-
-    // After connecting it, the SAME workspace reports connected.
-    await bridge.connect(workspace: 'estate', session: 'estate');
-    list = await bridge.listWorkspaces();
-    final after =
-        list.firstWhere((workspace) => workspace.workspace == 'estate');
-    expect(after.residency,
-        protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_MOUNTED);
-    await bridge.dispose();
-  });
-
-  test(
-      'plane snapshot exports resident custody without manufacturing a Dart session',
-      () async {
-    final runner = FakeRunner(resident: ['born-child']);
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-
-    final saved = await bridge.nomosInternalSnapshotWorkspace('born-child');
-    expect(saved.workspace, 'born-child');
-    expect(saved.head, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
-    expect(saved.snapshot, 'resident-snapshot-b64');
-    expect(saved.unchanged, isFalse);
-    expect(runner.connectCount, 0,
-        reason:
-            'save-all must not acquire an unopened child or invent host authority');
-
-    final unchanged = await bridge.nomosInternalSnapshotWorkspace('born-child',
-        ifHead: saved.head);
-    expect(unchanged.unchanged, isTrue);
-    expect(unchanged.snapshot, isNull);
-    expect(runner.connectCount, 0);
-    await bridge.dispose();
-  });
-
-  test(
-      'NomosSession.isConnected + assertConnected: fail at BIND, not on first query',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-
-    // A held-but-unopened handle is valid to construct but not connected — assertConnected throws NOW.
-    final lazy = bridge.session('estate');
-    expect(lazy.isConnected, isFalse);
-    expect(lazy.assertConnected, throwsStateError);
-
-    await bridge.connect(workspace: 'estate', session: 'estate');
-    final live = bridge.session('estate');
-    expect(live.isConnected, isTrue);
-    expect(live.assertConnected, returnsNormally);
-    await bridge.dispose();
-  });
-
-  test(
-      'NomosRef.acquire(bridge) opens a born/resident ref directly → a live session',
-      () async {
-    final runner = FakeRunner(resident: ['estate-42']);
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-
-    // The shape a `.births()` outcome yields: outcome.bornRefs.single is a NomosRef on the born workspace.
-    final ref = NmsInternalNomosRefs.create<Object?>(
-        workspace: 'estate-42', type: 'nomos.Workspace', id: 'estate-42');
-    final session =
-        await ref.acquire(bridge); // no credentials — resident opens local-only
-    expect(session.workspace, 'estate-42');
-    expect(session.isConnected, isTrue);
-    expect(identical(session, bridge.session('estate-42')), isTrue);
-    await bridge.dispose();
-  });
-
-  test(
-      'NomosRef.acquire refuses a workspace-less ref (a bad locator fails HERE, not later)',
-      () async {
-    final runner = FakeRunner();
-    final bridge = NomosBridge(runner);
-    await bridge.ready;
-    final bad = NmsInternalNomosRefs.create<Object?>(
-        workspace: '', type: 'nomos.Workspace', id: 'x');
-    expect(() => bad.acquire(bridge), throwsArgumentError);
-    await bridge.dispose();
-  });
-}