Add information about number of tests and subtests

mrego · delan · mrego · commit 9d04a8768493 · 2025-04-03T08:11:24.000+02:00
This modifies the scores.json file so it now provides more data: * total_tests: The total number of tests * total_score: The total scores for the tests * per_mille: Per mille value of dividing total_score by total_tests * total_subtests: The total number of subtests * total_subtests_passed: The number of subtests that pass * per_mille_subtests: Per mille value of dividing total_subtests by total_subtests_passed This is based on previous work by Delan Azabani at #35. Co-authored-by: Delan Azabani <dazabani@igalia.com> Signed-off-by: Manuel Rego Casasnovas <rego@igalia.com>
diff --git a/process-wpt-results.js b/process-wpt-results.js
@@ -199,47 +199,56 @@ export function score_run (run, against_run, focus_areas_map) {
     for (const area of Object.keys(FOCUS_AREAS)) {
         scores[area] = {
             total_tests: 0,
-            total_score: 0
+            total_score: 0,
+            per_mille: 0,
+            total_subtests: 0,
+            total_subtests_passed: 0,
+            per_mille_subtests: 0
         }
     }
 
     for (const [test, { subtests }] of Object.entries(against_run.test_scores)) {
         const areas = focus_areas_map[test]
+        const subtest_names = Object.keys(subtests)
 
         for (const area of areas) {
             scores[area].total_tests += 1
+            scores[area].total_subtests += !subtest_names.length ? 1 : subtest_names.length
         }
 
         const run_test = run.test_scores[test]
 
         // score new tests not present in older runs
         if (!run_test) continue
 
-        const subtest_names = Object.keys(subtests)
         if (!subtest_names.length) {
             for (const area of areas) {
                 scores[area].total_score += run_test.score
+                scores[area].total_subtests_passed += run_test.score
             }
         } else {
-            let test_score = 0
+            let subtests_passed = 0
             for (const subtest of subtest_names) {
                 if (Object.hasOwn(run_test.subtests, subtest)) {
-                    test_score += run_test.subtests[subtest].score
+                    subtests_passed += run_test.subtests[subtest].score
                 }
             }
-            test_score /= subtest_names.length
             for (const area of areas) {
-                scores[area].total_score += test_score
+                scores[area].total_score += subtests_passed / subtest_names.length
+                scores[area].total_subtests_passed += subtests_passed
             }
         }
     }
 
     return Object.entries(scores).reduce((scores, [area, totals]) => {
-        scores[area] = 0
+        scores[area] = totals
         if (totals.total_tests !== 0) {
-            scores[area] = Math.floor(
+            scores[area].per_mille = Math.floor(
                 1000 * totals.total_score / totals.total_tests
             )
+            scores[area].per_mille_subtests = Math.floor(
+                1000 * totals.total_subtests_passed / totals.total_subtests
+            )
         }
         return scores
     }, {})
diff --git a/test/process-wpt-results.test.js b/test/process-wpt-results.test.js
@@ -166,11 +166,109 @@ describe('Scoring', () => {
             test2: ['all']
         }
         let score = score_run(run, run, focus_area_map)
-        assert.deepEqual(score.all, 1000)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 2,
+                per_mille: 1000,
+                total_subtests: 2,
+                total_subtests_passed: 2,
+                per_mille_subtests: 1000
+            })
 
         run.test_scores.test2.score = 0
         score = score_run(run, run, focus_area_map)
-        assert.deepEqual(score.all, 500)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 1,
+                per_mille: 500,
+                total_subtests: 2,
+                total_subtests_passed: 1,
+                per_mille_subtests: 500
+            })
+    })
+    it('calculates subtests count', () => {
+        const run = {
+            test_scores: {
+                test1: {
+                    score: 1,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 1 },
+                        subtest3: { score: 1 }
+                    }
+                },
+                test2: {
+                    score: 0,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 0 }
+                    }
+                }
+            }
+        }
+
+        const focus_area_map = {
+            test1: ['all'],
+            test2: ['all']
+        }
+        const score = score_run(run, run, focus_area_map)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 1.5,
+                per_mille: 750,
+                total_subtests: 5,
+                total_subtests_passed: 4,
+                per_mille_subtests: 800
+            })
+    })
+    it('calculates subtests counts with simple tests', () => {
+        const run = {
+            test_scores: {
+                test1: {
+                    score: 1,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 1 },
+                        subtest3: { score: 1 }
+                    }
+                },
+                test2: {
+                    score: 0,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 0 }
+                    }
+                },
+                test3: {
+                    score: 1,
+                    subtests: {}
+                },
+                test4: {
+                    score: 0,
+                    subtests: {}
+                }
+            }
+        }
+
+        const focus_area_map = {
+            test1: ['all'],
+            test2: ['all'],
+            test3: ['all'],
+            test4: ['all']
+        }
+        const score = score_run(run, run, focus_area_map)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 4,
+                total_score: 2.5,
+                per_mille: 625,
+                total_subtests: 7,
+                total_subtests_passed: 5,
+                per_mille_subtests: 714
+            })
     })
     it('calculates scores for subtests', () => {
         const run = {
@@ -187,7 +285,15 @@ describe('Scoring', () => {
         }
 
         const score = score_run(run, run, { test1: ['all'] })
-        assert.equal(score.all, 1000)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 1,
+                total_score: 1,
+                per_mille: 1000,
+                total_subtests: 3,
+                total_subtests_passed: 3,
+                per_mille_subtests: 1000
+            })
     })
     it('calculates scores for subtests by averaging', () => {
         const run = {
@@ -204,7 +310,15 @@ describe('Scoring', () => {
         }
 
         const score = score_run(run, run, { test1: ['all'] })
-        assert.equal(score.all, 333)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 1,
+                total_score: 1 / 3,
+                per_mille: 333,
+                total_subtests: 3,
+                total_subtests_passed: 1,
+                per_mille_subtests: 333
+            })
     })
     it('calculates scores correctly even subtest name collides with JS builtins', () => {
         const run = {
@@ -237,7 +351,15 @@ describe('Scoring', () => {
         }
 
         const score = score_run(run, against_run, { test1: ['all'], test2: ['all'] })
-        assert.equal(score.all, 500)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 1,
+                per_mille: 500,
+                total_subtests: 2,
+                total_subtests_passed: 1,
+                per_mille_subtests: 500
+            })
     })
     it('calculates scores based only on tests in new runs', () => {
         const old_run = {
@@ -258,11 +380,93 @@ describe('Scoring', () => {
             test1: all, test2: all, test3: all
         }
         let score = score_run(old_run, new_run, focus_map)
-        assert.equal(score.all, 0)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 0,
+                per_mille: 0,
+                total_subtests: 2,
+                total_subtests_passed: 0,
+                per_mille_subtests: 0
+            })
+        old_run.test_scores.test3.score = 1
+        score = score_run(old_run, new_run, focus_map)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 1,
+                per_mille: 500,
+                total_subtests: 2,
+                total_subtests_passed: 1,
+                per_mille_subtests: 500
+            })
+    })
+    it('calculates scores based only on subtests in new runs', () => {
+        const old_run = {
+            test_scores: {
+                test1: {
+                    score: 0,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 0 }
+                    }
+                },
+                test3: {
+                    score: 0,
+                    subtests: {
+                        subtest1: { score: 0 },
+                        subtest2: { score: 1 }
+                    }
+                }
+            }
+        }
+        const new_run = {
+            test_scores: {
+                test2: {
+                    score: 1,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 1 },
+                        subtest3: { score: 1 },
+                        subtest4: { score: 1 }
+                    }
+                },
+                test3: {
+                    score: 1,
+                    subtests: {
+                        subtest1: { score: 1 },
+                        subtest2: { score: 1 }
+                    }
+                }
+            }
+        }
 
+        const all = ['all']
+        const focus_map = {
+            test1: all, test2: all, test3: all
+        }
+        let score = score_run(old_run, new_run, focus_map)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 0.5,
+                per_mille: 250,
+                total_subtests: 6,
+                total_subtests_passed: 1,
+                per_mille_subtests: 166
+            })
         old_run.test_scores.test3.score = 1
+        old_run.test_scores.test3.subtests.subtest1.score = 1
         score = score_run(old_run, new_run, focus_map)
-        assert.equal(score.all, 500)
+        assert.deepEqual(score.all,
+            {
+                total_tests: 2,
+                total_score: 1,
+                per_mille: 500,
+                total_subtests: 6,
+                total_subtests_passed: 2,
+                per_mille_subtests: 333
+            })
     })
 })
 

Original file line number	Diff line number	Diff line change
`@@ -199,47 +199,56 @@ export function score_run (run, against_run, focus_areas_map) {`
`199`	`199`	`for (const area of Object.keys(FOCUS_AREAS)) {`
`200`	`200`	`scores[area] = {`
`201`	`201`	`total_tests: 0,`
`202`		`- total_score: 0`
	`202`	`+ total_score: 0,`
	`203`	`+ per_mille: 0,`
	`204`	`+ total_subtests: 0,`
	`205`	`+ total_subtests_passed: 0,`
	`206`	`+ per_mille_subtests: 0`
`203`	`207`	`}`
`204`	`208`	`}`
`205`	`209`
`206`	`210`	`for (const [test, { subtests }] of Object.entries(against_run.test_scores)) {`
`207`	`211`	`const areas = focus_areas_map[test]`
	`212`	`+ const subtest_names = Object.keys(subtests)`
`208`	`213`
`209`	`214`	`for (const area of areas) {`
`210`	`215`	`scores[area].total_tests += 1`
	`216`	`+ scores[area].total_subtests += !subtest_names.length ? 1 : subtest_names.length`
`211`	`217`	`}`
`212`	`218`
`213`	`219`	`const run_test = run.test_scores[test]`
`214`	`220`
`215`	`221`	`// score new tests not present in older runs`
`216`	`222`	`if (!run_test) continue`
`217`	`223`
`218`		`- const subtest_names = Object.keys(subtests)`
`219`	`224`	`if (!subtest_names.length) {`
`220`	`225`	`for (const area of areas) {`
`221`	`226`	`scores[area].total_score += run_test.score`
	`227`	`+ scores[area].total_subtests_passed += run_test.score`
`222`	`228`	`}`
`223`	`229`	`} else {`
`224`		`- let test_score = 0`
	`230`	`+ let subtests_passed = 0`
`225`	`231`	`for (const subtest of subtest_names) {`
`226`	`232`	`if (Object.hasOwn(run_test.subtests, subtest)) {`
`227`		`- test_score += run_test.subtests[subtest].score`
	`233`	`+ subtests_passed += run_test.subtests[subtest].score`
`228`	`234`	`}`
`229`	`235`	`}`
`230`		`- test_score /= subtest_names.length`
`231`	`236`	`for (const area of areas) {`
`232`		`- scores[area].total_score += test_score`
	`237`	`+ scores[area].total_score += subtests_passed / subtest_names.length`
	`238`	`+ scores[area].total_subtests_passed += subtests_passed`
`233`	`239`	`}`
`234`	`240`	`}`
`235`	`241`	`}`
`236`	`242`
`237`	`243`	`return Object.entries(scores).reduce((scores, [area, totals]) => {`
`238`		`- scores[area] = 0`
	`244`	`+ scores[area] = totals`
`239`	`245`	`if (totals.total_tests !== 0) {`
`240`		`- scores[area] = Math.floor(`
	`246`	`+ scores[area].per_mille = Math.floor(`
`241`	`247`	`1000 * totals.total_score / totals.total_tests`
`242`	`248`	`)`
	`249`	`+ scores[area].per_mille_subtests = Math.floor(`
	`250`	`+ 1000 * totals.total_subtests_passed / totals.total_subtests`
	`251`	`+ )`
`243`	`252`	`}`
`244`	`253`	`return scores`
`245`	`254`	`}, {})`