@teambit/ci 1.0.505 → 1.0.508

package/dist/sync/lane-sync-executor.spec.js

@@ -566,6 +566,10 @@ describe('executeExportBranch reports the ledger-race wording when only the ledg
     executor.lastNonSyncCommitMessage = async () => 'feat: some change';
     executor.checkoutFromRemote = async () => {};
     executor.restoreWorkspace = async () => {};
+    executor.materializeLane = async () => undefined;
+    executor.deps.ci = {
+      hasUnsyncedWorkChanges: async () => true
+    };
     // The export half already succeeded; only the ledger commit that follows raced.
     executor.snapAndExportOntoLane = async () => ({
       status: 'exported'
@@ -587,6 +591,157 @@ describe('executeExportBranch reports the ledger-race wording when only the ledg
   });
 });
 
+// The probe's "clean" answer means converged only against the lane the PLAN read. A lane that moved
+// in between must re-plan — comparing the branch's files with the newer lane would misread the
+// lane's own advance as branch work and export a revert over a concurrent developer's export.
+describe('executeExportBranch bails when the lane moved since planning', () => {
+  function stubExport(currentLaneComponents, plannedLaneComponents) {
+    const {
+      executor
+    } = stubExecutor();
+    const touched = [];
+    executor.checkoutFromRemote = async () => {};
+    executor.restoreWorkspace = async () => {};
+    executor.materializeLane = async () => undefined;
+    executor.lastNonSyncCommitMessage = async () => 'feat: some change';
+    executor.getRemoteLane = async () => ({
+      components: currentLaneComponents
+    });
+    executor.deps.ci = {
+      hasUnsyncedWorkChanges: async () => {
+        touched.push('status');
+        return false;
+      }
+    };
+    executor.snapAndExportOntoLane = async () => {
+      touched.push('snap');
+      return {
+        status: 'exported'
+      };
+    };
+    const run = () => executor.executeExportBranch({
+      target: {
+        hostScope: 'acme.shop',
+        name: 'my-lane'
+      },
+      laneIdStr: 'acme.shop/my-lane',
+      branch: 'my-lane',
+      defaultBranch: 'main',
+      preExportLane: {
+        components: plannedLaneComponents
+      }
+    });
+    return {
+      run,
+      touched
+    };
+  }
+  const L1 = [comp('acme.shop/comp1', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1')];
+  const L2 = [comp('acme.shop/comp1', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2')];
+  it('a moved lane returns a re-plan noop before the status read or any snap', async () => {
+    const {
+      run,
+      touched
+    } = stubExport(L2, L1);
+    const summary = await run();
+    (0, _chai().expect)(summary).to.include('my-lane -> noop');
+    (0, _chai().expect)(summary).to.include('moved');
+    (0, _chai().expect)(touched).to.deep.equal([]);
+  });
+  it('an unmoved lane proceeds to the probe', async () => {
+    const {
+      run,
+      touched
+    } = stubExport(L1, L1);
+    const summary = await run();
+    (0, _chai().expect)(summary).to.include('my-lane -> noop (converged)');
+    (0, _chai().expect)(touched).to.deep.equal(['status']);
+  });
+});
+
+// The merge path snaps whatever the merge produced — which can be nothing new, now routinely: a
+// source-bundling tip plus a moved lane plans merge-diverged, and a branch with nothing of its own
+// merges clean and leaves the snap a noop. The summary must say so, and the run-summary comment
+// belongs only to runs that actually exported.
+describe('executeMergeDiverged distinguishes an exporting merge from a nothing-new merge', () => {
+  function stubMerge(snapStatus, currentLaneComponents = []) {
+    const {
+      executor
+    } = stubExecutor();
+    const summaryCalls = [];
+    executor.checkoutFromRemote = async () => {};
+    executor.restoreWorkspace = async () => {};
+    executor.getRemoteLane = async () => ({
+      components: currentLaneComponents
+    });
+    executor.mergeLaneIntoBranchWorkingTree = async () => ({
+      conflicts: [],
+      conflictedFileCount: 0
+    });
+    executor.snapAndExportOntoLane = async () => ({
+      status: snapStatus
+    });
+    executor.recordLaneHeadOnBranch = async () => ({
+      status: 'ok',
+      laneHead: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1',
+      remoteLane: {
+        components: []
+      }
+    });
+    executor.postRunSummaryComment = async args => summaryCalls.push(args);
+    const run = () => executor.executeMergeDiverged({
+      target: {
+        hostScope: 'acme.shop',
+        name: 'my-lane'
+      },
+      laneIdStr: 'acme.shop/my-lane',
+      branch: 'my-lane',
+      defaultBranch: 'main',
+      preExportLane: {
+        components: []
+      }
+    });
+    return {
+      run,
+      summaryCalls
+    };
+  }
+  it('a nothing-new merge says so, and posts no run summary', async () => {
+    const {
+      run,
+      summaryCalls
+    } = stubMerge('noop');
+    const summary = await run();
+    (0, _chai().expect)(summary).to.include('my-lane -> merge-diverged');
+    (0, _chai().expect)(summary).to.include('nothing new to export');
+    (0, _chai().expect)(summary).to.not.include('then exported');
+    (0, _chai().expect)(summaryCalls).to.have.lengthOf(0);
+  });
+  it('an exporting merge keeps the exported wording and posts the run summary', async () => {
+    const {
+      run,
+      summaryCalls
+    } = stubMerge('exported');
+    const summary = await run();
+    (0, _chai().expect)(summary).to.include('then exported');
+    (0, _chai().expect)(summaryCalls).to.have.lengthOf(1);
+    (0, _chai().expect)(summaryCalls[0].laneHead).to.equal('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1');
+  });
+
+  // Same freshness rule as the export probe: the plan's inputs must still describe the world.
+  it('a lane that moved since planning bails to a re-plan before merging anything', async () => {
+    const moved = [comp('acme.shop/comp1', 'ccccccccccccccccccccccccccccccccccccccc3')];
+    const {
+      run,
+      summaryCalls
+    } = stubMerge('exported', moved);
+    const summary = await run();
+    (0, _chai().expect)(summary).to.include('my-lane -> noop');
+    (0, _chai().expect)(summary).to.include('moved');
+    (0, _chai().expect)(summaryCalls).to.have.lengthOf(0);
+  });
+});
+
 // Adoption never snaps or exports, so its raced line must NOT claim the lane was updated — the lane
 // is untouched and only the branch's pointer commit lost the race.
 describe('executeAdoptBranch reports a lane-untouched race when its ledger push races', () => {
@@ -634,5 +789,186 @@ describe('isProtectedBranch', () => {
     (0, _chai().expect)((0, _laneSyncExecutor().isProtectedBranch)('my-lane', 'develop', 'bit-sync/main')).to.equal(false);
   });
 });
+describe('laneSummaryComponents', () => {
+  it('includes hidden updateDependents — a cascade export must not read as "nothing changed"', () => {
+    const lane = {
+      components: [comp('acme.shop/comp1', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1')],
+      updateDependents: [comp('acme.shop/dep1', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2')]
+    };
+    (0, _chai().expect)((0, _laneSyncExecutor().laneSummaryComponents)(lane).map(c => c.id.toStringWithoutVersion())).to.deep.equal(['acme.shop/comp1', 'acme.shop/dep1']);
+  });
+  it('an absent lane lists nothing', () => {
+    (0, _chai().expect)((0, _laneSyncExecutor().laneSummaryComponents)(undefined)).to.deep.equal([]);
+  });
+});
+describe('changedLaneComponents', () => {
+  it('includes a component new to the lane, and one whose head moved', () => {
+    const before = [comp('acme.shop/comp1', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1')];
+    const after = [comp('acme.shop/comp1', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2'), comp('acme.shop/comp2', 'ccccccccccccccccccccccccccccccccccccccc3')];
+    const changed = (0, _laneSyncExecutor().changedLaneComponents)(before, after);
+    (0, _chai().expect)(changed.map(c => c.id.toStringWithoutVersion())).to.deep.equal(['acme.shop/comp1', 'acme.shop/comp2']);
+  });
+  it('excludes a component whose head did not move', () => {
+    const stable = comp('acme.shop/comp1', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1');
+    (0, _chai().expect)((0, _laneSyncExecutor().changedLaneComponents)([stable], [stable])).to.deep.equal([]);
+  });
+  it('treats an undefined "before" (never seen this lane) as everything being new', () => {
+    const after = [comp('acme.shop/comp1', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1')];
+    (0, _chai().expect)((0, _laneSyncExecutor().changedLaneComponents)(undefined, after)).to.deep.equal(after);
+  });
+});
+describe('runSummaryCommentBody', () => {
+  it('carries the marker, the changed components, and the branch/lane anchors', () => {
+    const body = (0, _laneSyncExecutor().runSummaryCommentBody)({
+      laneIdStr: 'acme.shop/my-lane',
+      laneUrl: 'https://bit.cloud/acme/shop/~lane/my-lane',
+      branch: 'my-lane',
+      branchTipSha: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1',
+      laneHead: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2',
+      changed: [comp('acme.shop/comp1', 'ccccccccccccccccccccccccccccccccccccccc3')]
+    });
+    (0, _chai().expect)(body).to.include(_laneSyncExecutor().RUN_SUMMARY_MARKER);
+    (0, _chai().expect)(body).to.include('acme.shop/comp1` @ `ccccccccc');
+    (0, _chai().expect)(body).to.include('branch: `my-lane` @ `aaaaaaaaa`');
+    // the lane anchor is a LINK — the reader lands on the lane, not on a name to copy-paste
+    (0, _chai().expect)(body).to.include('lane: [`acme.shop/my-lane`](https://bit.cloud/acme/shop/~lane/my-lane) @ `bbbbbbbbb`');
+  });
+  it('says plainly that nothing changed, rather than an empty list', () => {
+    const body = (0, _laneSyncExecutor().runSummaryCommentBody)({
+      laneIdStr: 'acme.shop/my-lane',
+      laneUrl: 'https://bit.cloud/acme/shop/~lane/my-lane',
+      branch: 'my-lane',
+      branchTipSha: undefined,
+      laneHead: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2',
+      changed: []
+    });
+    (0, _chai().expect)(body).to.include('none — nothing on the lane changed this run');
+    (0, _chai().expect)(body).to.not.include('@ `undefined');
+  });
+});
+
+// The comment is a pure surface effect: it must never gate the run's own outcome, and must degrade
+// silently through every "nothing to comment on" state a real host, PR or branch can be in.
+describe('postRunSummaryComment', () => {
+  const BEFORE = [comp('acme.shop/comp1', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1')];
+  const AFTER = [comp('acme.shop/comp1', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2')];
+  function executorWith(gitHost, warnings = []) {
+    const executor = new (_laneSyncExecutor().LaneSyncExecutor)({
+      lanes: {},
+      ci: {},
+      logger: {
+        console: () => {},
+        consoleWarning: msg => warnings.push(msg),
+        error: () => {}
+      },
+      gitHost,
+      cfg: (0, _syncConfig().resolveSyncConfig)({}),
+      defaultScope: 'acme.shop'
+    });
+    executor.currentBranchTip = async () => 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1';
+    return executor;
+  }
+  const call = executor => executor.postRunSummaryComment({
+    target: {
+      hostScope: 'acme.shop',
+      name: 'my-lane'
+    },
+    laneIdStr: 'acme.shop/my-lane',
+    branch: 'my-lane',
+    laneHead: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2',
+    branchTipSha: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1',
+    preComponents: BEFORE,
+    postComponents: AFTER
+  });
+
+  // The anchor is the ledger sha THIS run pushed — passed in, never refetched: a concurrent developer
+  // push must not be presented as the synced tip, and no remote read exists to fail the path.
+  it('anchors the body on the given pushed sha without any branch refetch', async () => {
+    const upserts = [];
+    const gitHost = {
+      findPrByBranch: async () => ({
+        number: 7,
+        htmlUrl: 'https://example.test/pr/7',
+        labels: []
+      }),
+      upsertComment: async (_n, _m, body) => upserts.push(body)
+    };
+    const executor = executorWith(gitHost);
+    executor.currentBranchTip = async () => {
+      throw new Error('must not be called');
+    };
+    await call(executor);
+    (0, _chai().expect)(upserts).to.have.lengthOf(1);
+    (0, _chai().expect)(upserts[0]).to.include('branch: `my-lane` @ `aaaaaaaaa`');
+  });
+  it('upserts the marked comment on the open PR when the host supports it', async () => {
+    const calls = [];
+    const gitHost = {
+      findPrByBranch: async () => ({
+        number: 7,
+        htmlUrl: 'https://example.test/pr/7',
+        labels: []
+      }),
+      upsertComment: async (prNumber, marker, body) => {
+        calls.push({
+          prNumber,
+          marker,
+          body
+        });
+      }
+    };
+    await call(executorWith(gitHost));
+    (0, _chai().expect)(calls).to.have.lengthOf(1);
+    (0, _chai().expect)(calls[0].prNumber).to.equal(7);
+    (0, _chai().expect)(calls[0].marker).to.equal(_laneSyncExecutor().RUN_SUMMARY_MARKER);
+    (0, _chai().expect)(calls[0].body).to.include('acme.shop/comp1` @ `bbbbbbbbb');
+  });
+  it('is a no-op with no configured git host', async () => {
+    await call(executorWith(undefined)); // would throw on any host call; nothing to assert but "did not throw"
+  });
+  it('is a no-op when the host does not implement upsertComment', async () => {
+    const calls = [];
+    const gitHost = {
+      findPrByBranch: async () => {
+        calls.push('findPrByBranch');
+        return {
+          number: 7,
+          htmlUrl: 'https://example.test/pr/7',
+          labels: []
+        };
+      }
+    };
+    await call(executorWith(gitHost));
+    // upsertComment is feature-tested BEFORE the PR lookup — an unsupported host must not even look up the PR.
+    (0, _chai().expect)(calls).to.deep.equal([]);
+  });
+  it('is a no-op when the branch has no open PR yet', async () => {
+    const calls = [];
+    const gitHost = {
+      findPrByBranch: async () => undefined,
+      upsertComment: async () => {
+        calls.push('upsertComment');
+      }
+    };
+    await call(executorWith(gitHost));
+    (0, _chai().expect)(calls).to.deep.equal([]);
+  });
+  it('warns and does not throw when the comment API call fails', async () => {
+    const warnings = [];
+    const gitHost = {
+      findPrByBranch: async () => ({
+        number: 7,
+        htmlUrl: 'https://example.test/pr/7',
+        labels: []
+      }),
+      upsertComment: async () => {
+        throw new Error('rate limited');
+      }
+    };
+    await call(executorWith(gitHost, warnings));
+    (0, _chai().expect)(warnings.join('\n')).to.contain('Could not post the run-summary comment');
+    (0, _chai().expect)(warnings.join('\n')).to.contain('rate limited');
+  });
+});
 
 //# sourceMappingURL=lane-sync-executor.spec.js.map