fix: cleanup rendering

Author: unional

packages/tester/package.json

@@ -14,7 +14,7 @@
     "find": "^0.3.0",
     "handlebars": "^4.7.7",
     "json5": "^2.2.3",
-    "type-plus": "^5.4.1"
+    "type-plus": "^5.5.1"
   },
   "devDependencies": {
     "@types/find": "^0.2.1",

packages/tester/ts/app.ts

@@ -5,7 +5,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { context } from 'type-plus'
 import { getProjectPath, getTestSubjects, readPackageJson } from './logic/project'
-import { getTestResults } from './testResults'
+import { genTestResults, getTestResults } from './testResults'
 
 export const app = cli({ name: 'tester', version: '0.0.1' })
   .default({
@@ -24,18 +24,14 @@ export const app = cli({ name: 'tester', version: '0.0.1' })
 
       fs.writeFileSync(
         path.join(ctx.projectPath, 'test-result.md'),
-        await render(ctx)
+        [genTestConfiguration(ctx),
+        genTestSubjects(ctx),
+        genLegends(),
+        genTestResults({ ...ctx, results: await ctx.results })].join('\n')
       )
     }
   })
 
-async function render(ctx: any) {
-  return [genTestConfiguration(ctx),
-  genTestSubjects(ctx),
-  genLegends(),
-  genTestResults(await ctx.results)].join('\n')
-}
-
 function getTSConfig(ctx: { projectPath: string }) {
   const tsconfigPath = path.join(ctx.projectPath, 'tsconfig.base.json')
   return {
@@ -48,7 +44,7 @@ function genTestConfiguration({ tsconfig }: { tsconfig: any }) {
   return template(tsconfig.compilerOptions)
 }
 
-function genTestSubjects({ subjects }: { subjects: ReturnType<typeof getTestSubjects> }) {
+function genTestSubjects({ subjects }: ReturnType<typeof getTestSubjects>) {
   const template = compile(fs.readFileSync(path.join(__dirname, '../templates/test-subjects.hbs'), 'utf8'), { noEscape: true })
   return template({ subjects })
 }
@@ -57,8 +53,3 @@ function genLegends() {
   const template = compile(fs.readFileSync(path.join(__dirname, '../templates/legends.hbs'), 'utf8'))
   return template({})
 }
-
-function genTestResults(ctx: { results: Awaited<ReturnType<typeof getTestResults>> }) {
-  const template = compile(fs.readFileSync(path.join(__dirname, '../templates/test-results.hbs'), 'utf8'))
-  return template(ctx)
-}

packages/tester/ts/logic/project.ts

@@ -23,7 +23,6 @@ export function getTestSubjects({
   const dependencies = getDependencies(packageJson)
   return {
     subjects: dependencies.map(name => ({
-      packageJson,
       name,
       files: getTestFiles(projectPath, name)
     }))
@@ -39,7 +38,8 @@ export function readPackageJson(ctx: { projectPath: string }) {
 
 function getTestFiles(projectPath: string, dependencyName: string) {
   const base = path.join(projectPath, 'ts')
-  const filePrefix = path.join(base, `${dependencyName}`)
+  // the `.` at the end makes sure it match the exact package name.
+  const filePrefix = path.join(base, `${dependencyName}.`)
   return fileSync(base)
     .filter(f => f.startsWith(filePrefix))
     .map(filepath => ({
@@ -82,17 +82,32 @@ function getPackageNameFromTransient(filename: string) {
   return undefined
 }
 
-export function toImportMap(results: Array<{ importType: string, value: string, transient: boolean }> | undefined) {
+export function toImportMap(results: Array<{
+  importType: string,
+  notApply?: boolean,
+  transient?: boolean
+  value?: string,
+}> | undefined) {
   return {
     'importDefault': toImportMapEntry(results, 'default'),
     'importDefaultAs': toImportMapEntry(results, 'default-as'),
     'importStarAs': toImportMapEntry(results, 'star'),
   }
 }
 
-function toImportMapEntry(results: Array<{ importType: string, value: string, transient: boolean }> | undefined, importType: string) {
+function toImportMapEntry(results: Array<{
+  importType: string,
+  notApply?: boolean,
+  value?: string,
+  transient?: boolean
+}> | undefined, importType: string) {
   const entry = results?.find(r => r.importType === importType)
   if (entry) {
+    if (entry.notApply) {
+      return {
+        icon: '➖'
+      }
+    }
     return {
       icon: entry.value ? entry.transient ? '🟡' : '🔴' : '🟢',
       value: entry.value

packages/tester/ts/logic/runtime.ts

@@ -4,7 +4,7 @@ import path from 'node:path'
 import { getTestSubjects } from './project'
 
 export type RuntimeResult = {
-  package: string
+  name: string
   results: {
     filename: string
     importType: string
@@ -20,7 +20,7 @@ export async function runProject(ctx: {
   const base = path.join(ctx.projectPath, moduleType)
   const files = fileSync(base)
   return Promise.all(ctx.subjects.map(async testSubject => {
-    const filePrefix = path.join(base, `${testSubject.name}`)
+    const filePrefix = path.join(base, `${testSubject.name}.`)
     const results = await Promise.all(files.filter(f => f.startsWith(filePrefix) && f.endsWith('.js'))
       .map(file => file.slice(base.length + 1))
       .map(filename => new Promise<{
@@ -35,11 +35,10 @@ export async function runProject(ctx: {
             error: error ? error : undefined
           })
         })
-      })
-      ))
+      })))
     return {
-      package: testSubject.name,
+      name: testSubject.name,
       results
     }
-  }))
+  })).then(r => r.filter(r => r.results.length > 0))
 }

packages/tester/ts/testResults.ts

@@ -1,4 +1,7 @@
-import { record } from 'type-plus'
+import { compile } from 'handlebars'
+import fs from 'node:fs'
+import path from 'node:path'
+import { AwaitedProp, record } from 'type-plus'
 import { CompileResult, PackageCompileResults, compileProject } from './logic/compile'
 import { getTestSubjects, toImportMap } from './logic/project'
 import { RuntimeResult, runProject } from './logic/runtime'
@@ -19,45 +22,94 @@ export function getTestResults(ctx: {
             compileResults: compileResults[moduleType],
             runtimeResults
           }))))
-      ).then(collectTestResults)
+      )
   }
 }
 
-function collectTestResults(results: Array<{
-  moduleType: string
-  compileResults: PackageCompileResults,
-  runtimeResults: Array<RuntimeResult>
-}>) {
+type TestSubjectsContext = ReturnType<typeof getTestSubjects>
+type TestResultsContext = AwaitedProp<ReturnType<typeof getTestResults>, 'results'>
+
+export function genTestResults(
+  ctx: TestSubjectsContext & TestResultsContext) {
+  const results = collectTestResults(ctx)
+  const template = compile(fs.readFileSync(path.join(__dirname, '../templates/test-results.hbs'), 'utf8'))
+  return template(results)
+}
+
+function collectTestResults({ subjects, results }: TestSubjectsContext & TestResultsContext) {
   const errors = toErrorRecord(results)
   return {
     results: results.flatMap(({ moduleType, compileResults, runtimeResults }) => {
-      return runtimeResults.flatMap((r, i) => {
+      return subjects.flatMap((s, i) => {
+        const compileResult = compileResults[s.name]
+        const runtimeResult = runtimeResults.find(r => r.name === s.name)
         return [{
           moduleType: i === 0 ? moduleType : undefined,
-          package: r.package,
+          package: s.name,
           type: '💻 compile',
-          ...toImportMap(compileResults[r.package]?.map(c => {
+          ...toImportMap(compileResult ? compileResult.map(c => {
             const error = errors.compile.find(e => e.message === c.messageText)
             return {
               importType: c.importType,
               transient: c.transient,
               value: error?.key ?? ''
             }
-          }))
+          }) : (s.files.length === 0 ? [
+            { importType: 'default', notApply: true },
+            { importType: 'default-as', notApply: true },
+            { importType: 'star', notApply: true },
+          ] : [
+            { importType: 'default', },
+            { importType: 'default-as' },
+            { importType: 'star' },
+          ]))
         }, {
-          moduleType: undefined,
-          package: r.package,
           type: '🏃 runtime',
-          ...toImportMap(r.results.map(r => {
+          ...toImportMap(runtimeResult ? runtimeResult.results.map(r => {
             const error = errors.runtime.find(e => e.message === extractRuntimeErrorMessage(r.error))
             return {
               importType: r.importType,
               transient: false,
               value: error?.key ?? ''
             }
-          }))
+          }) : (s.files.length === 0 ? [
+            { importType: 'default', notApply: true },
+            { importType: 'default-as', notApply: true },
+            { importType: 'star', notApply: true },
+          ] : [
+            { importType: 'default', },
+            { importType: 'default-as' },
+            { importType: 'star' },
+          ]))
         }]
       })
+      // return runtimeResults.flatMap((r, i) => {
+      //   return [{
+      //     moduleType: i === 0 ? moduleType : undefined,
+      //     package: r.name,
+      //     type: '💻 compile',
+      //     ...toImportMap(compileResults[r.name]?.map(c => {
+      //       const error = errors.compile.find(e => e.message === c.messageText)
+      //       return {
+      //         importType: c.importType,
+      //         transient: c.transient,
+      //         value: error?.key ?? ''
+      //       }
+      //     }))
+      //   }, {
+      //     moduleType: undefined,
+      //     package: r.name,
+      //     type: '🏃 runtime',
+      //     ...toImportMap(r.results.map(r => {
+      //       const error = errors.runtime.find(e => e.message === extractRuntimeErrorMessage(r.error))
+      //       return {
+      //         importType: r.importType,
+      //         transient: false,
+      //         value: error?.key ?? ''
+      //       }
+      //     }))
+      //   }]
+      // })
     }),
     errors: [...errors.compile, ...errors.runtime]
   }