pr-report-core 0.0.5 → 0.1.0

package/src/start-after.test.mts

@@ -2,10 +2,13 @@ import {
   decideStartStates,
   inheritStartAfter,
   issuesInProgress,
+  progressOf,
   referenceStatusOf,
   waitsFor,
   withProgress,
+  type InheritedOrder,
   type ReferenceStatus,
+  type StartState,
 } from './start-after.mjs';
 
 describe(referenceStatusOf, () => {
@@ -90,7 +93,7 @@ describe(decideStartStates, () => {
   test('an issue that declares nothing is free', () => {
     assert.deepStrictEqual(
       decideStartStates([{ number: 1, startAfter: [] }], known([])),
-      new Map([[1, 'free']]),
+      new Map<number, StartState>([[1, 'free']]),
     );
   });
 
@@ -103,7 +106,7 @@ describe(decideStartStates, () => {
         ],
         known([]),
       ),
-      new Map([
+      new Map<number, StartState>([
         [1, 'free'],
         [2, 'blocked'],
       ]),
@@ -119,7 +122,7 @@ describe(decideStartStates, () => {
           [2, 'done'],
         ]),
       ),
-      new Map([[3, 'ready']]),
+      new Map<number, StartState>([[3, 'ready']]),
     );
   });
 
@@ -137,7 +140,7 @@ describe(decideStartStates, () => {
           [3, 'waiting'],
         ]),
       ),
-      new Map([
+      new Map<number, StartState>([
         [10, 'blocked'],
         [11, 'attention'],
         [12, 'attention'],
@@ -158,7 +161,7 @@ describe(decideStartStates, () => {
           [9, 'waiting'],
         ]),
       ),
-      new Map([
+      new Map<number, StartState>([
         [1, 'blocked'],
         [2, 'blocked'],
         [3, 'ready'],
@@ -177,7 +180,7 @@ describe(decideStartStates, () => {
         ],
         known([]),
       ),
-      new Map([
+      new Map<number, StartState>([
         [1, 'cycle'],
         [2, 'cycle'],
         [3, 'cycle'],
@@ -195,10 +198,10 @@ describe(inheritStartAfter, () => {
           { number: 10, closes: [1] },
           { number: 20, closes: [] },
         ],
-        startAfterOf: new Map([[1, [20]]]),
-        openIssues: new Set([1]),
+        startAfterOf: new Map<number, readonly number[]>([[1, [20]]]),
+        openIssues: new Set<number>([1]),
       }),
-      new Map([
+      new Map<number, InheritedOrder>([
         [10, { mergeAfter: [20], notStarted: [] }],
         [20, { mergeAfter: [], notStarted: [] }],
       ]),
@@ -213,8 +216,8 @@ describe(inheritStartAfter, () => {
           { number: 21, closes: [2] },
           { number: 22, closes: [2] },
         ],
-        startAfterOf: new Map([[1, [2]]]),
-        openIssues: new Set([1, 2]),
+        startAfterOf: new Map<number, readonly number[]>([[1, [2]]]),
+        openIssues: new Set<number>([1, 2]),
       }).get(10),
       { mergeAfter: [21, 22], notStarted: [] },
     );
@@ -224,8 +227,8 @@ describe(inheritStartAfter, () => {
     assert.deepStrictEqual(
       inheritStartAfter({
         pulls: [{ number: 10, closes: [1] }],
-        startAfterOf: new Map([[1, [2]]]),
-        openIssues: new Set([1, 2]),
+        startAfterOf: new Map<number, readonly number[]>([[1, [2]]]),
+        openIssues: new Set<number>([1, 2]),
       }).get(10),
       { mergeAfter: [], notStarted: [2] },
     );
@@ -237,8 +240,8 @@ describe(inheritStartAfter, () => {
     assert.deepStrictEqual(
       inheritStartAfter({
         pulls: [{ number: 10, closes: [1] }],
-        startAfterOf: new Map([[1, [3]]]),
-        openIssues: new Set([1]),
+        startAfterOf: new Map<number, readonly number[]>([[1, [3]]]),
+        openIssues: new Set<number>([1]),
       }).get(10),
       { mergeAfter: [], notStarted: [] },
     );
@@ -252,13 +255,13 @@ describe(inheritStartAfter, () => {
           { number: 10, closes: [1, 2] },
           { number: 11, closes: [3] },
         ],
-        startAfterOf: new Map([
+        startAfterOf: new Map<number, readonly number[]>([
           [1, [2]],
           [3, [11]],
         ]),
-        openIssues: new Set([1, 2, 3]),
+        openIssues: new Set<number>([1, 2, 3]),
       }),
-      new Map([
+      new Map<number, InheritedOrder>([
         [10, { mergeAfter: [], notStarted: [] }],
         [11, { mergeAfter: [], notStarted: [] }],
       ]),
@@ -273,11 +276,11 @@ describe(inheritStartAfter, () => {
           { number: 30, closes: [] },
           { number: 20, closes: [5] },
         ],
-        startAfterOf: new Map([
+        startAfterOf: new Map<number, readonly number[]>([
           [1, [30, 5, 6]],
           [2, [5, 30, 6]],
         ]),
-        openIssues: new Set([1, 2, 5, 6]),
+        openIssues: new Set<number>([1, 2, 5, 6]),
       }).get(10),
       { mergeAfter: [20, 30], notStarted: [6] },
     );
@@ -287,8 +290,8 @@ describe(inheritStartAfter, () => {
     assert.deepStrictEqual(
       inheritStartAfter({
         pulls: [{ number: 10, closes: [1] }],
-        startAfterOf: new Map(),
-        openIssues: new Set([1]),
+        startAfterOf: new Map<number, readonly number[]>(),
+        openIssues: new Set<number>([1]),
       }).get(10),
       { mergeAfter: [], notStarted: [] },
     );
@@ -311,20 +314,66 @@ describe(waitsFor, () => {
 });
 
 describe(withProgress, () => {
-  test('a startable issue an open pull request closes is in progress', () => {
-    assert.strictEqual(withProgress('free', true), 'in-progress');
+  test('a startable issue someone has got to says how far', () => {
+    assert.strictEqual(withProgress('free', 'in-progress'), 'in-progress');
 
-    assert.strictEqual(withProgress('ready', true), 'in-progress');
+    assert.strictEqual(withProgress('ready', 'in-progress'), 'in-progress');
 
-    assert.strictEqual(withProgress('ready', false), 'ready');
+    assert.strictEqual(withProgress('free', 'planned'), 'planned');
+
+    assert.strictEqual(withProgress('ready', 'none'), 'ready');
   });
 
   test('one that is not startable says why, worked on or not', () => {
-    assert.strictEqual(withProgress('blocked', true), 'blocked');
+    assert.strictEqual(withProgress('blocked', 'in-progress'), 'blocked');
+
+    assert.strictEqual(withProgress('cycle', 'in-progress'), 'cycle');
+
+    assert.strictEqual(withProgress('attention', 'planned'), 'attention');
+  });
+});
+
+describe(progressOf, () => {
+  test('an open pull request closing it is in progress', () => {
+    assert.strictEqual(progressOf([], true), 'in-progress');
+  });
+
+  test('so is the in-progress label, with no pull request yet', () => {
+    assert.strictEqual(
+      progressOf([{ name: 'bug' }, { name: 'in-progress' }], false),
+      'in-progress',
+    );
+  });
+
+  test('the planned label is planned', () => {
+    assert.strictEqual(progressOf([{ name: 'planned' }], false), 'planned');
+  });
 
-    assert.strictEqual(withProgress('cycle', true), 'cycle');
+  test('being worked on wins over being planned', () => {
+    assert.strictEqual(progressOf([{ name: 'planned' }], true), 'in-progress');
+
+    assert.strictEqual(
+      progressOf([{ name: 'planned' }, { name: 'in-progress' }], false),
+      'in-progress',
+    );
+  });
+
+  test('neither, or a label only like them, is none', () => {
+    assert.strictEqual(progressOf([], false), 'none');
+
+    assert.strictEqual(
+      progressOf([{ name: 'in-progress-x' }, { name: 'planned-later' }], false),
+      'none',
+    );
+  });
+
+  test('reads a label whatever its case, as GitHub does', () => {
+    assert.strictEqual(
+      progressOf([{ name: 'In-Progress' }], false),
+      'in-progress',
+    );
 
-    assert.strictEqual(withProgress('attention', true), 'attention');
+    assert.strictEqual(progressOf([{ name: 'Planned' }], false), 'planned');
   });
 });
 
@@ -336,7 +385,7 @@ describe(issuesInProgress, () => {
         { linkedIssues: [{ number: 2 }] },
         { linkedIssues: [] },
       ]),
-      new Set([1, 2]),
+      new Set<number>([1, 2]),
     );
   });
 });