load subtasks on startup

Signed-off-by: shmck <shawn.j.mckay@gmail.com>

Author: ShMcK

src/actions/utils/loadWatchers.ts

@@ -38,9 +38,11 @@ const loadWatchers = (watchers: string[]) => {
         const now = +new Date()
         if (!lastFire || lastFire - now > 1000) {
           vscode.commands.executeCommand(COMMANDS.RUN_TEST, {
-            onSuccess: () => {
-              // cleanup watcher on success
-              disposeWatcher(watcher)
+            callbacks: {
+              onSuccess: () => {
+                // cleanup watcher on success
+                disposeWatcher(watcher)
+              },
             },
           })
         }

src/channel/index.ts

@@ -306,7 +306,7 @@ class Channel implements Channel {
         await vscode.commands.executeCommand(COMMANDS.SET_CURRENT_POSITION, action.payload.position)
         await solutionActions({ actions: action.payload.actions, send: this.send })
         // run test following solution to update position
-        vscode.commands.executeCommand(COMMANDS.RUN_TEST)
+        vscode.commands.executeCommand(COMMANDS.RUN_TEST, { subtasks: true })
         return
       case 'EDITOR_SYNC_PROGRESS':
         // update progress when a level is deemed complete in the client
@@ -317,7 +317,7 @@ class Channel implements Channel {
         await showOutput(channel)
         return
       case 'EDITOR_RUN_TEST':
-        vscode.commands.executeCommand(COMMANDS.RUN_TEST)
+        vscode.commands.executeCommand(COMMANDS.RUN_TEST, action?.payload)
         return
       default:
         logger(`No match for action type: ${actionType}`)

src/editor/commands.ts

@@ -81,21 +81,27 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
           // send test run message back to client
           webview.send({ type: 'TEST_RUNNING', payload: { position } })
         },
+        onLoadSubtasks: ({ summary }) => {
+          webview.send({ type: 'LOAD_TEST_SUBTASKS', payload: { summary } })
+        },
       })
     },
     [COMMANDS.SET_CURRENT_POSITION]: (position: T.Position) => {
       // set from last setup stepAction
       currentPosition = position
     },
-    [COMMANDS.RUN_TEST]: (callback?: { onSuccess: () => void }) => {
+    [COMMANDS.RUN_TEST]: ({
+      subtasks,
+      callbacks,
+    }: { subtasks?: boolean; callbacks?: { onSuccess: () => void } } = {}) => {
       logger('run test current', currentPosition)
       // use stepId from client, or last set stepId
       // const position: T.Position = {
       //   ...current,
       //   stepId: current && current.position.stepId?.length ? current.position.stepId : currentPosition.stepId,
       // }
       logger('currentPosition', currentPosition)
-      testRunner({ position: currentPosition, onSuccess: callback?.onSuccess })
+      testRunner({ position: currentPosition, onSuccess: callbacks?.onSuccess, subtasks })
     },
   }
 }

src/services/testRunner/index.ts

@@ -13,20 +13,22 @@ interface Callbacks {
   onFail(position: T.Position, failSummary: T.TestFail): void
   onRun(position: T.Position): void
   onError(position: T.Position): void
+  onLoadSubtasks({ summary }: { summary: { [testName: string]: boolean } }): void
 }
 
 const failChannelName = 'CodeRoad (Tests)'
 const logChannelName = 'CodeRoad (Logs)'
 
 interface TestRunnerParams {
   position: T.Position
+  subtasks?: boolean
   onSuccess?: () => void
 }
 
 const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
   const testRunnerConfig = data.config.testRunner
   const testRunnerFilterArg = testRunnerConfig.args?.filter
-  return async ({ position, onSuccess }: TestRunnerParams): Promise<void> => {
+  return async ({ position, onSuccess, subtasks }: TestRunnerParams): Promise<void> => {
     const startTime = throttle()
     // throttle time early
     if (!startTime) {
@@ -36,7 +38,9 @@ const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
     logger('------------------- RUN TEST -------------------')
 
     // flag as running
-    callbacks.onRun(position)
+    if (!subtasks) {
+      callbacks.onRun(position)
+    }
 
     let result: { stdout: string | undefined; stderr: string | undefined }
     try {
@@ -79,6 +83,12 @@ const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
 
     const tap: ParserOutput = parser(stdout || '')
 
+    if (subtasks) {
+      callbacks.onLoadSubtasks({ summary: tap.summary })
+      // exit early
+      return
+    }
+
     addOutput({ channel: logChannelName, text: tap.logs.join('\n'), show: false })
 
     if (stderr) {
@@ -105,7 +115,9 @@ const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
     // PASS
     if (tap.ok) {
       clearOutput(failChannelName)
+
       callbacks.onSuccess(position)
+
       if (onSuccess) {
         onSuccess()
       }

typings/index.d.ts

@@ -39,7 +39,7 @@ export interface Environment {
 }
 
 export interface TestStatus {
-  type: 'success' | 'warning' | 'error' | 'loading'
+  type: 'success' | 'warning' | 'error' | 'loading' | 'hidden'
   title: string
   content?: string
   summary?: { [testName: string]: boolean }

typings/tutorial.d.ts

@@ -27,6 +27,7 @@ export type Step = {
   content: string
   setup: StepActions
   solution: Maybe<StepActions>
+  subtasks?: { [testName: string]: boolean }
 }
 
 /** A tutorial for use in VSCode CodeRoad */

web-app/src/components/Message/index.tsx

@@ -2,7 +2,7 @@ import { Message as AlifdMessage } from '@alifd/next'
 import * as React from 'react'
 
 interface Props {
-  type?: 'success' | 'warning' | 'error' | 'notice' | 'help' | 'loading'
+  type?: 'success' | 'warning' | 'error' | 'notice' | 'help' | 'loading' | 'hidden'
   shape?: 'inline' | 'addon' | 'toast'
   size?: 'medium' | 'large'
   title: string
@@ -16,6 +16,9 @@ interface Props {
 
 const Message = (props: Props) => {
   const [visible, setVisible] = React.useState(true)
+  if (props.type === 'hidden') {
+    return null
+  }
   function onClose() {
     if (props.onClose) {
       props.onClose()

web-app/src/components/ProcessMessages/TestMessage.tsx

@@ -8,6 +8,7 @@ const durations = {
   warning: 20000,
   error: 4500,
   loading: 300000,
+  hidden: 0,
 }
 
 const useTimeout = ({ duration, key }: { duration: number; key: string }) => {

web-app/src/containers/Tutorial/components/Level.tsx

@@ -158,14 +158,12 @@ const Level = ({
                   return null
                 }
                 let subtasks = null
-                if (step.setup.subtasks) {
-                  if (testStatus?.summary) {
-                    subtasks = Object.keys(testStatus.summary).map((testName: string) => ({
-                      name: testName,
-                      // @ts-ignore typescript is wrong here
-                      pass: testStatus.summary[testName],
-                    }))
-                  }
+                if (step.setup.subtasks && testStatus?.summary) {
+                  subtasks = Object.keys(testStatus.summary).map((testName: string) => ({
+                    name: testName,
+                    // @ts-ignore typescript is wrong here
+                    pass: testStatus.summary[testName],
+                  }))
                 }
                 return (
                   <Step
@@ -184,7 +182,7 @@ const Level = ({
 
         <div ref={pageBottomRef} />
 
-        {(testStatus || processes.length > 0) && (
+        {((testStatus && testStatus.type !== 'hidden') || processes.length > 0) && (
           <div css={styles.processes}>
             <ProcessMessages processes={processes} testStatus={testStatus} onOpenLogs={onOpenLogs} />
           </div>

web-app/src/services/state/actions/editor.ts

@@ -56,6 +56,17 @@ export default (editorSend: any) => ({
           actions: step.setup,
         },
       })
+
+      if (step.setup.subtasks) {
+        // load subtask data by running tests and parsing result
+        editorSend({
+          type: 'EDITOR_RUN_TEST',
+          payload: {
+            position: context.position,
+            subtasks: true,
+          },
+        })
+      }
     }
   },
   editorLoadSolution(context: T.MachineContext): void {