forge-workflow 0.1.0-beta.5 → 0.1.0-beta.6

package/lib/pr-monitor/differ.js

@@ -14,6 +14,107 @@
  */
 
 const { EVENT_TYPES: T, makeEvent } = require('./events');
+const {
+  VERDICT_STATES,
+  normalizePrNumber,
+  normalizeRepository,
+  normalizeSha,
+  object,
+  readArrayItems,
+  readDataProperty,
+} = require('./verdict');
+
+const CURRENT_VERDICT_STATES = new Set(Object.values(VERDICT_STATES));
+
+function compareText(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+function normalizedReasonCodes(verdict) {
+  const reasons = readArrayItems(readDataProperty(verdict, 'reasons').value);
+  if (!reasons) return null;
+  const codes = [];
+  for (const entry of reasons) {
+    const code = readDataProperty(entry, 'code').value;
+    if (!object(entry) || typeof code !== 'string' || !code.trim()) return null;
+    codes.push(code.trim());
+  }
+  return [...new Set(codes)].sort(compareText);
+}
+
+function normalizeCurrentVerdict(verdict, { absent = false } = {}) {
+  if (absent && verdict == null) {
+    return {
+      state: null, repository: null, prNumber: null, headSha: null, baseSha: null, reasons: [],
+    };
+  }
+  const record = object(verdict);
+  const state = readDataProperty(record, 'state').value;
+  const repository = normalizeRepository(readDataProperty(record, 'repository').value);
+  const prNumber = normalizePrNumber(readDataProperty(record, 'prNumber').value);
+  const headSha = normalizeSha(readDataProperty(record, 'headSha').value);
+  const baseSha = normalizeSha(readDataProperty(record, 'baseSha').value);
+  const valid = record && CURRENT_VERDICT_STATES.has(state)
+    && repository && prNumber && headSha && baseSha;
+  const reasons = valid ? normalizedReasonCodes(verdict) : null;
+  if (!valid || reasons === null
+    || (state === VERDICT_STATES.MERGE_READY && reasons.length > 0)
+    || (state !== VERDICT_STATES.MERGE_READY && reasons.length === 0)) {
+    return {
+      state: VERDICT_STATES.INCOMPLETE,
+      repository: null,
+      prNumber: null,
+      headSha: null,
+      baseSha: null,
+      reasons: ['malformed_verdict'],
+    };
+  }
+  return {
+    state,
+    repository,
+    prNumber,
+    headSha,
+    baseSha,
+    reasons,
+  };
+}
+
+function difference(left, right) {
+  const rightSet = new Set(right);
+  return left.filter((value) => !rightSet.has(value));
+}
+
+/** Deterministically describe a transition between exact-current-head verdicts. */
+function diffVerdictEvidence(previous, next) {
+  const before = normalizeCurrentVerdict(previous, { absent: true });
+  const after = normalizeCurrentVerdict(next);
+  const addedReasons = difference(after.reasons, before.reasons);
+  const removedReasons = difference(before.reasons, after.reasons);
+  const headChanged = before.headSha !== after.headSha;
+  const baseChanged = before.baseSha !== after.baseSha;
+  const repositoryChanged = before.repository !== after.repository;
+  const prChanged = before.prNumber !== after.prNumber;
+  const stateChanged = before.state !== after.state;
+  return {
+    changed: headChanged || baseChanged || repositoryChanged || prChanged || stateChanged
+      || addedReasons.length > 0 || removedReasons.length > 0,
+    headChanged,
+    stateChanged,
+    baseChanged,
+    repositoryChanged,
+    prChanged,
+    from: before.state,
+    to: after.state,
+    repository: after.repository,
+    prNumber: after.prNumber,
+    headSha: after.headSha,
+    baseSha: after.baseSha,
+    addedReasons,
+    removedReasons,
+  };
+}
 
 /** Index an array of objects by a key field into a Map. */
 function indexBy(list, field) {
@@ -44,9 +145,9 @@ function diffChecks(prev, next, out) {
     const before = prevByName.get(String(c.name));
     const wasFailed = before?.class === 'failed';
     if (c.class === 'failed' && !wasFailed) {
-      out.push(makeEvent(T.CHECK_FAILED, `${c.name}:${next.headSha}`, { name: c.name }));
+      out.push(makeEvent(T.CHECK_FAILED, `${c.name}:${next.headSha}`, { name: c.displayName || c.name }));
     } else if (c.class === 'green' && wasFailed) {
-      out.push(makeEvent(T.CHECK_RECOVERED, `${c.name}:${next.headSha}`, { name: c.name }));
+      out.push(makeEvent(T.CHECK_RECOVERED, `${c.name}:${next.headSha}`, { name: c.displayName || c.name }));
     }
   }
   if (allGreen(next.checks) && !allGreen(prev.checks)) {
@@ -92,7 +193,9 @@ function diffReviews(prev, next, out) {
       || before.commitOid !== r.commitOid;
     if (changed) {
       out.push(makeEvent(T.REVIEW_SUBMITTED, `${r.author}:${r.commitOid || r.submittedAt}`, {
-        author: r.author, verdict: r.state, commitOid: r.commitOid || null,
+        author: r.displayAuthor || r.author,
+        verdict: r.state,
+        commitOid: r.displayCommitOid || r.commitOid || null,
       }));
     }
   }
@@ -139,7 +242,9 @@ function diffDegraded(prev, next, out) {
   const prevSurfaces = new Set((prev.degraded || []).map((d) => d.surface));
   for (const d of (next.degraded || [])) {
     if (!prevSurfaces.has(d.surface)) {
-      out.push(makeEvent(T.MONITOR_DEGRADED, d.surface, { surface: d.surface, error: d.error || '' }));
+      out.push(makeEvent(T.MONITOR_DEGRADED, d.surface, {
+        surface: d.displaySurface || d.surface, error: d.error || '',
+      }));
     }
   }
 }
@@ -190,6 +295,7 @@ function diffSnapshots(prev, next) {
 
 module.exports = {
   diffSnapshots,
+  diffVerdictEvidence,
   allGreen,
   indexBy,
 };