refactor(utils): check scoring prerequisites

Author: Tlacenka

packages/utils/src/lib/reports/scoring.ts

@@ -29,33 +29,6 @@ export type ScoredReport = Omit<Report, 'plugins' | 'categories'> & {
   categories: ScoredCategoryConfig[];
 };
 
-export function calculateScore<T extends { weight: number }>(
-  refs: T[],
-  scoreFn: (ref: T) => number,
-): number {
-  const { numerator, denominator } = refs.reduce(
-    (acc, ref) => {
-      const score = scoreFn(ref);
-      return {
-        numerator: acc.numerator + score * ref.weight,
-        denominator: acc.denominator + ref.weight,
-      };
-    },
-    { numerator: 0, denominator: 0 },
-  );
-  // No division by 0, otherwise we produce NaN
-  // This can be caused by:
-  // - empty category refs
-  // - categories with refs only containing weight of `0`
-  // both should get caught when validating the model
-  if (!numerator && !denominator) {
-    throw new Error(
-      '0 division for score. This can be caused by refs only weighted with 0 or empty refs',
-    );
-  }
-  return numerator / denominator;
-}
-
 // eslint-disable-next-line max-lines-per-function
 export function scoreReport(report: Report): ScoredReport {
   const allScoredAuditsAndGroups = new Map<
@@ -119,3 +92,47 @@ export function scoreReport(report: Report): ScoredReport {
     categories: scoredCategories,
   };
 }
+
+export function calculateScore<T extends { weight: number }>(
+  refs: T[],
+  scoreFn: (ref: T) => number,
+): number {
+  const validatedRefs = parseScoringParameters(refs, scoreFn);
+  const { numerator, denominator } = validatedRefs.reduce(
+    (acc, ref) => ({
+      numerator: acc.numerator + ref.score * ref.weight,
+      denominator: acc.denominator + ref.weight,
+    }),
+    { numerator: 0, denominator: 0 },
+  );
+
+  return numerator / denominator;
+}
+
+function parseScoringParameters<T extends { weight: number }>(
+  refs: T[],
+  scoreFn: (ref: T) => number,
+): { weight: number; score: number }[] {
+  if (refs.length === 0) {
+    throw new Error('Reference array cannot be empty.');
+  }
+
+  if (refs.some(ref => ref.weight < 0)) {
+    throw new Error('Weight cannot be negative.');
+  }
+
+  if (refs.every(ref => ref.weight === 0)) {
+    throw new Error('All references cannot have zero weight.');
+  }
+
+  const scoredRefs = refs.map(ref => ({
+    weight: ref.weight,
+    score: scoreFn(ref),
+  }));
+
+  if (scoredRefs.some(ref => ref.score < 0 || ref.score > 1)) {
+    throw new Error('All scores must be in range 0-1.');
+  }
+
+  return scoredRefs;
+}

packages/utils/src/lib/reports/scoring.unit.test.ts

@@ -56,7 +56,16 @@ describe('calculateScore', () => {
   it('should throw for an empty reference array', () => {
     expect(() =>
       calculateScore<{ weight: number }>([], ref => ref.weight),
-    ).toThrow('0 division for score');
+    ).toThrow('Reference array cannot be empty.');
+  });
+
+  it('should throw negative weight', () => {
+    expect(() =>
+      calculateScore(
+        [{ slug: 'first-contentful-paint', weight: -1, score: 0.5 }],
+        ref => ref.score,
+      ),
+    ).toThrow('Weight cannot be negative.');
   });
 
   it('should throw for a reference array full of zero weights', () => {
@@ -66,9 +75,27 @@ describe('calculateScore', () => {
           { slug: 'first-contentful-paint', weight: 0, score: 0 },
           { slug: 'cumulative-layout-shift', weight: 0, score: 1 },
         ],
-        ref => ref.weight,
+        ref => ref.score,
+      ),
+    ).toThrow('All references cannot have zero weight.');
+  });
+
+  it('should throw for a negative score', () => {
+    expect(() =>
+      calculateScore(
+        [{ slug: 'first-contentful-paint', weight: 1, score: -0.8 }],
+        ref => ref.score,
+      ),
+    ).toThrow('All scores must be in range 0-1.');
+  });
+
+  it('should throw for score above 1', () => {
+    expect(() =>
+      calculateScore(
+        [{ slug: 'first-contentful-paint', weight: 1, score: 2 }],
+        ref => ref.score,
       ),
-    ).toThrow('0 division for score');
+    ).toThrow('All scores must be in range 0-1.');
   });
 });
 

packages/utils/src/lib/reports/utils.unit.test.ts

@@ -70,23 +70,15 @@ describe('compareIssueSeverity', () => {
 
 describe('formatReportScore', () => {
   it.each([
-    [Number.NaN, 'NaN'],
-    [Number.POSITIVE_INFINITY, 'Infinity'],
-    [Number.NEGATIVE_INFINITY, '-Infinity'],
-    [-1, '-100'],
-    [-0.1, '-10'],
     [0, '0'],
     [0.0049, '0'],
     [0.005, '1'],
     [0.01, '1'],
     [0.123, '12'],
-    [0.245, '25'],
-    [0.2449, '24'],
     [0.99, '99'],
     [0.994, '99'],
     [0.995, '100'],
     [1, '100'],
-    [1.1, '110'],
   ] satisfies readonly [number, string][])(
     "should format a score of %d as '%s'",
     (score, expected) => {