Estimate time from several workflow runs

action.yaml

@@ -15,6 +15,10 @@ inputs:
   test-report-branch:
     description: Branch to find the test report artifacts
     required: true
+  test-report-workflow-count:
+    description: Number of workflows to find the test report artifacts
+    required: true
+    default: '1'
   shard-count:
     description: Number of shards
     required: true

src/artifact.ts

@@ -6,6 +6,7 @@ import { Octokit } from './github'
 
 type Inputs = {
   testReportWorkflowFilename: string
+  testReportWorkflowCount: number
   testReportArtifactNamePrefix: string
   testReportBranch: string
   testReportDirectory: string
@@ -22,18 +23,18 @@ export type TestWorkflowRun = {
 export const downloadTestReportsFromLastWorkflowRuns = async (
   octokit: Octokit,
   inputs: Inputs,
-): Promise<TestWorkflowRun | undefined> => {
-  const lastWorkflowRuns = await findLastWorkflowRuns(octokit, inputs)
-  if (lastWorkflowRuns.length === 0) {
-    return
-  }
-  const lastWorkflowRun = lastWorkflowRuns[0]
+): Promise<TestWorkflowRun[]> => {
   const artifactClient = new DefaultArtifactClient()
-  const testReportFiles = await downloadTestReportArtifacts(octokit, artifactClient, inputs, lastWorkflowRun.id)
-  return {
-    url: lastWorkflowRun.html_url,
-    testReportFiles,
+  const workflowRuns = await findLastWorkflowRuns(octokit, inputs)
+  const testWorkflowRuns: TestWorkflowRun[] = []
+  for (const lastWorkflowRun of workflowRuns) {
+    const testReportFiles = await downloadTestReportArtifacts(octokit, artifactClient, inputs, lastWorkflowRun.id)
+    testWorkflowRuns.push({
+      url: lastWorkflowRun.url,
+      testReportFiles,
+    })
   }
+  return testWorkflowRuns
 }
 
 const findLastWorkflowRuns = async (octokit: Octokit, inputs: Inputs) => {
@@ -44,7 +45,7 @@ const findLastWorkflowRuns = async (octokit: Octokit, inputs: Inputs) => {
     workflow_id: inputs.testReportWorkflowFilename,
     branch: inputs.testReportBranch,
     status: 'success',
-    per_page: 1,
+    per_page: inputs.testReportWorkflowCount,
   })
   core.info(`Found ${listWorkflowRuns.workflow_runs.length} workflow run:`)
   for (const lastWorkflowRun of listWorkflowRuns.workflow_runs) {

src/main.ts

@@ -9,6 +9,7 @@ const main = async (): Promise<void> => {
     testFiles: core.getInput('test-files', { required: true }),
     testReportArtifactNamePrefix: core.getInput('test-report-artifact-name-prefix', { required: true }),
     testReportBranch: core.getInput('test-report-branch', { required: true }),
+    testReportWorkflowCount: parseInt(core.getInput('test-report-workflow-count', { required: true })),
     shardCount: parseInt(core.getInput('shard-count', { required: true })),
     shardsArtifactName: core.getInput('shards-artifact-name', { required: true }),
     owner: github.context.repo.owner,

src/run.ts

@@ -5,7 +5,7 @@ import * as os from 'os'
 import * as path from 'path'
 import { getOctokit } from './github'
 import { downloadTestReportsFromLastWorkflowRuns } from './artifact'
-import { parseTestReportFiles } from './junitxml'
+import { parseTestReportsOfWorkflowRuns } from './testreport'
 import {
   tryDownloadShardsIfAlreadyExists,
   distributeTestFilesToShards,
@@ -19,6 +19,7 @@ type Inputs = {
   testFiles: string
   testReportArtifactNamePrefix: string
   testReportBranch: string
+  testReportWorkflowCount: number
   shardCount: number
   shardsArtifactName: string
   owner: string
@@ -47,23 +48,24 @@ export const run = async (inputs: Inputs): Promise<Outputs> => {
   }
 
   const testReportDirectory = path.join(tempDirectory, 'test-reports')
-  const testWorkflowRun = await downloadTestReportsFromLastWorkflowRuns(octokit, {
+  const testWorkflowRuns = await downloadTestReportsFromLastWorkflowRuns(octokit, {
     testReportArtifactNamePrefix: inputs.testReportArtifactNamePrefix,
+    testReportWorkflowCount: inputs.testReportWorkflowCount,
     testReportBranch: inputs.testReportBranch,
     testReportWorkflowFilename: inputs.workflowFilename,
     testReportDirectory,
     owner: inputs.owner,
     repo: inputs.repo,
     token: inputs.token,
   })
-  const testFiles = await parseTestReportFiles(testWorkflowRun?.testReportFiles ?? [])
+  const testFiles = await parseTestReportsOfWorkflowRuns(testWorkflowRuns)
 
   const shardSet = distributeTestFilesToShards(workingTestFilenames, testFiles, inputs.shardCount)
   core.info(`Generated ${shardSet.shards.length} shards`)
 
   const shardsLock = await writeShardsWithLock(shardSet.shards, shardsDirectory, inputs.shardsArtifactName)
   if (shardsLock.currentJobAcquiredLock) {
-    writeSummary(shardSet, testWorkflowRun)
+    writeSummary(shardSet, testWorkflowRuns)
   }
 
   await ensureTestFilesConsistency(shardsDirectory, workingTestFilenames)

src/summary.ts

@@ -2,7 +2,7 @@ import * as core from '@actions/core'
 import { ShardSet } from './shard'
 import { TestWorkflowRun } from './artifact'
 
-export const writeSummary = (shardSet: ShardSet, testWorkflowRun: TestWorkflowRun | undefined) => {
+export const writeSummary = (shardSet: ShardSet, testWorkflowRuns: TestWorkflowRun[]) => {
   core.summary.addHeading('Summary of parallel-test-action')
   core.summary.addRaw(
     'This action distributes the test files to the shards based on the estimated time from the test reports.',
@@ -51,11 +51,14 @@ export const writeSummary = (shardSet: ShardSet, testWorkflowRun: TestWorkflowRu
   )
 
   core.summary.addHeading('Test reports', 2)
-  if (testWorkflowRun) {
-    core.summary.addRaw('This action downloaded the test reports from ')
-    core.summary.addLink('the last success workflow run', testWorkflowRun.url)
-    core.summary.addHeading('Files', 3)
-    core.summary.addList(testWorkflowRun.testReportFiles)
+  if (testWorkflowRuns.length > 0) {
+    core.summary.addRaw('This action downloaded the test reports from:')
+    for (const [index, testWorkflowRun] of testWorkflowRuns.entries()) {
+      core.summary.addHeading(`Workflow Run #${index + 1}`, 3)
+      core.summary.addLink(testWorkflowRun.url, testWorkflowRun.url)
+      core.summary.addHeading(`Files`, 4)
+      core.summary.addList(testWorkflowRun.testReportFiles)
+    }
   } else {
     core.summary.addRaw('No test reports found')
   }

src/testreport.ts

@@ -0,0 +1,50 @@
+import { parseTestReportFiles } from './junitxml'
+
+type TestReportsOfWorkflowRun = {
+  testReportFiles: string[]
+}
+
+type TestFile = {
+  filename: string
+  totalTime: number
+  totalTestCases: number
+}
+
+export const parseTestReportsOfWorkflowRuns = async (
+  testReportsOfWorkflowRuns: TestReportsOfWorkflowRun[],
+): Promise<TestFile[]> => {
+  const testFilesOfWorkflowRuns: TestFile[][] = []
+  for (const testReportsOfWorkflowRun of testReportsOfWorkflowRuns) {
+    const testFiles = await parseTestReportFiles(testReportsOfWorkflowRun.testReportFiles)
+    testFilesOfWorkflowRuns.push(testFiles)
+  }
+  return calculateAveregedTestFiles(testFilesOfWorkflowRuns)
+}
+
+const calculateAveregedTestFiles = (testFilesOfWorkflowRuns: TestFile[][]): TestFile[] => {
+  const testFileMap = new Map<
+    string,
+    TestFile & {
+      effectiveWorkflowRuns: number
+    }
+  >()
+  for (const testFilesOfWorkflowRun of testFilesOfWorkflowRuns) {
+    for (const testFile of testFilesOfWorkflowRun) {
+      const currentTestFile = testFileMap.get(testFile.filename) ?? {
+        filename: testFile.filename,
+        totalTime: 0,
+        totalTestCases: 0,
+        effectiveWorkflowRuns: 0,
+      }
+      currentTestFile.totalTime += testFile.totalTime
+      currentTestFile.totalTestCases += testFile.totalTestCases
+      currentTestFile.effectiveWorkflowRuns++
+      testFileMap.set(testFile.filename, currentTestFile)
+    }
+  }
+  for (const [, testFile] of testFileMap) {
+    testFile.totalTime /= testFile.effectiveWorkflowRuns
+    testFile.totalTestCases /= testFile.effectiveWorkflowRuns
+  }
+  return [...testFileMap.values()]
+}