subtask progress

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

Author: ShMcK

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, { subtasks: true })
+        vscode.commands.executeCommand(COMMANDS.RUN_TEST)
         return
       case 'EDITOR_SYNC_PROGRESS':
         // update progress when a level is deemed complete in the client

src/editor/commands.ts

@@ -82,7 +82,7 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
           webview.send({ type: 'TEST_RUNNING', payload: { position } })
         },
         onLoadSubtasks: ({ summary }) => {
-          webview.send({ type: 'LOAD_TEST_SUBTASKS', payload: { summary } })
+          webview.send({ type: 'LOAD_SUBTASK_RESULTS', payload: { summary } })
         },
       })
     },

src/services/testRunner/index.ts

@@ -3,6 +3,7 @@ import * as TT from 'typings/tutorial'
 import { exec } from '../node'
 import logger from '../logger'
 import parser, { ParserOutput } from './parser'
+import parseSubtasks from './subtasks'
 import { debounce, throttle } from './throttle'
 import onError from '../sentry/onError'
 import { clearOutput, addOutput } from './output'
@@ -13,7 +14,7 @@ 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
+  onLoadSubtasks({ summary }: { summary: { [testId: number]: boolean } }): void
 }
 
 const failChannelName = 'CodeRoad (Tests)'
@@ -28,7 +29,7 @@ interface TestRunnerParams {
 const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
   const testRunnerConfig = data.config.testRunner
   const testRunnerFilterArg = testRunnerConfig.args?.filter
-  return async ({ position, onSuccess, subtasks }: TestRunnerParams): Promise<void> => {
+  return async ({ position, onSuccess }: TestRunnerParams): Promise<void> => {
     const startTime = throttle()
     // throttle time early
     if (!startTime) {
@@ -37,8 +38,24 @@ const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
 
     logger('------------------- RUN TEST -------------------')
 
+    // calculate level & step from position
+    const level: TT.Level | null = data.levels.find((l) => l.id === position.levelId) || null
+    if (!level) {
+      console.warn(`Level "${position.levelId}" not found`)
+      return
+    }
+    const step: TT.Step | null = level.steps.find((s) => s.id === position.stepId) || null
+    if (!step) {
+      console.warn(`Step "${position.stepId}" not found`)
+      return
+    }
+
+    console.log('STEP')
+    console.log(JSON.stringify(step))
+
     // flag as running
-    if (!subtasks) {
+    // no need to flag subtasks as running
+    if (!step.setup?.subtasks) {
       callbacks.onRun(position)
     }
 
@@ -81,8 +98,12 @@ const createTestRunner = (data: TT.Tutorial, callbacks: Callbacks) => {
 
     const tap: ParserOutput = parser(stdout || '')
 
-    if (subtasks) {
-      callbacks.onLoadSubtasks({ summary: tap.summary })
+    if (step.setup.subtasks) {
+      const summary = parseSubtasks(tap.summary, position.stepId || '')
+
+      console.log('---subtask summary')
+      console.log(summary)
+      callbacks.onLoadSubtasks({ summary })
       // exit early
       return
     }

src/services/testRunner/parser.test.ts

@@ -269,3 +269,28 @@ not ok 2 test_add_one_number (tests.math_test.MathTest)
     })
   })
 })
+
+describe('subtasks', () => {
+  it('should parse subtasks', () => {
+    const summary = {
+      'SUBTASKS 1.1 :1 should add one number': true,
+      'SUBTASKS 1.1 :2 should add two numbers': false,
+      'SUBTASKS 1.1 :3 should add three numbers': false,
+    }
+    const subtaskRegex = /^SUBTASKS\s(?<stepId>(\d+\.\d+))\s:(?<testId>\d+)\s/
+    const subtaskSummary = {}
+    Object.keys(summary).forEach((key) => {
+      const match = key.match(subtaskRegex)
+      if (!!match) {
+        const { stepId, testId } = match.groups || {}
+        const testIndex = Number(testId) - 1
+        subtaskSummary[testIndex] = summary[key]
+      }
+    })
+    expect(subtaskSummary).toEqual({
+      0: true,
+      1: false,
+      2: false,
+    })
+  })
+})

src/services/testRunner/subtasks.ts

@@ -0,0 +1,24 @@
+interface Summary {
+  [key: string]: boolean
+}
+
+// if a subtask matches the current stepId name
+// in the format "SUBTASKS 1.1 :1" where 1.1 is the stepId & :1 is the testId
+// values will be parsed and sent to the client
+const parseSubtasks = (summary: Summary, expectedStepId: string | null): Summary => {
+  const subtaskRegex = /^SUBTASKS\s(?<stepId>(\d+\.\d+))\s:(?<testId>\d+)\s/
+  const subtaskSummary = {}
+  Object.keys(summary).forEach((key) => {
+    const match = key.match(subtaskRegex)
+    if (!!match) {
+      const { stepId, testId } = match.groups || {}
+      if (stepId === expectedStepId) {
+        const testIndex = Number(testId) - 1
+        subtaskSummary[testIndex] = summary[key]
+      }
+    }
+  })
+  return subtaskSummary
+}
+
+export default parseSubtasks

typings/tutorial.d.ts

@@ -27,7 +27,7 @@ export type Step = {
   content: string
   setup: StepActions
   solution: Maybe<StepActions>
-  subtasks?: { [testName: string]: boolean }
+  subtasks?: { [index: number]: boolean }
   hints?: string[]
 }
 
@@ -52,7 +52,7 @@ export type StepActions = {
   files?: string[]
   watchers?: string[]
   filter?: string
-  subtasks?: boolean
+  subtasks?: string[]
 }
 
 export interface TestRunnerArgs {

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

@@ -199,14 +199,12 @@ const Level = ({
                   return null
                 }
                 let subtasks = null
-                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],
+                if (step?.setup?.subtasks) {
+                  subtasks = step.setup.subtasks.map((subtask: string, subtaskIndex: number) => ({
+                    name: subtask,
+                    pass: !!(testStatus?.summary ? testStatus.summary[subtaskIndex] : false),
                   }))
                 }
-                const hints = step.hints
                 return (
                   <Step
                     key={step.id}

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

@@ -58,7 +58,7 @@ export default (editorSend: any) => ({
       })
 
       if (step.setup.subtasks) {
-        // load subtask data by running tests and parsing result
+        // load subtask summary by running tests and parsing result
         editorSend({
           type: 'EDITOR_RUN_TEST',
           payload: {

web-app/src/services/state/machine.ts

@@ -155,7 +155,7 @@ export const createMachine = (options: any) => {
                 Normal: {
                   id: 'tutorial-level',
                   on: {
-                    LOAD_TEST_SUBTASKS: {
+                    LOAD_SUBTASK_RESULTS: {
                       actions: ['testSubtasks'],
                     },
                     TEST_RUNNING: 'TestRunning',