Background Jobs Stage 3-4

.github/workflows/test.yml

@@ -8,18 +8,11 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Set up Go
-        uses: actions/setup-go@v6
-        with:
-          go-version: 1.24.x
-      - name: setup-env
-        run: |
-          sudo apt remove bpfcc-tools
-          bash --version
-          uname -a
-          compgen -ac | sort | grep '^ex'
-
-      - run: make tests_excluding_ash
+
+      # TODO: Generalize using docker container across all testers
+      # Right now, we just use the docker test for recording fixtures and testing manually in this repo
+      - name: Run tests (Docker)
+        run: ./docker_test/docker_test.sh tests_excluding_ash
 
   lint:
     runs-on: ubuntu-latest

Makefile

@@ -174,7 +174,9 @@ endef
 define _BACKGROUND_JOBS_STAGES
 [ \
 	{"slug":"af3","tester_log_prefix":"tester::#af3","title":"Stage#1: The jobs builtin"}, \
-	{"slug":"at7","tester_log_prefix":"tester::#at7","title":"Stage#2: Background launch"} \
+	{"slug":"at7","tester_log_prefix":"tester::#at7","title":"Stage#2: Starting background jobs"}, \
+	{"slug":"jd6","tester_log_prefix":"tester::#jd6","title":"Stage#3: List a single job"}, \
+	{"slug":"dk5","tester_log_prefix":"tester::#dk5","title":"Stage#4: List multiple jobs"} \
 ]
 endef
 

internal/stage_bg1.go

@@ -16,20 +16,18 @@ func testBG1(stageHarness *test_case_harness.TestCaseHarness) error {
 		return err
 	}
 
-	typeTestCase := test_cases.CommandResponseTestCase{
-		Command:        "type jobs",
-		ExpectedOutput: "jobs is a shell builtin",
-		SuccessMessage: "Expected type for 'jobs' found",
+	typeTestCase := test_cases.TypeOfCommandTestCase{
+		Command: "jobs",
 	}
 
-	if err := typeTestCase.Run(asserter, shell, logger); err != nil {
+	if err := typeTestCase.RunForBuiltin(asserter, shell, logger); err != nil {
 		return err
 	}
 
 	jobsTestCase := test_cases.JobsBuiltinResponseTestCase{
 		SuccessMessage: "✓ Received empty response",
 		// Expect no output
-		ExpectedOutputItems: []test_cases.JobsBuiltinOutputEntry{},
+		ExpectedOutputEntries: []test_cases.JobsBuiltinOutputEntry{},
 	}
 
 	if err := jobsTestCase.Run(asserter, shell, logger); err != nil {

internal/stage_bg3.go

@@ -0,0 +1,47 @@
+package internal
+
+import (
+	"github.com/codecrafters-io/shell-tester/internal/logged_shell_asserter"
+	"github.com/codecrafters-io/shell-tester/internal/shell_executable"
+	"github.com/codecrafters-io/shell-tester/internal/test_cases"
+	"github.com/codecrafters-io/tester-utils/test_case_harness"
+)
+
+func testBG3(stageHarness *test_case_harness.TestCaseHarness) error {
+	logger := stageHarness.Logger
+	shell := shell_executable.NewShellExecutable(stageHarness)
+	asserter := logged_shell_asserter.NewLoggedShellAsserter(shell)
+
+	if err := asserter.StartShellAndAssertPrompt(true); err != nil {
+		return err
+	}
+
+	// Launch a program in the background
+	backgroundLaunchCommand := "sleep 100"
+	backgroundLaunchTestCase := test_cases.BackgroundCommandResponseTestCase{
+		Command:           backgroundLaunchCommand,
+		SuccessMessage:    "✓ Output includes job number with PID",
+		ExpectedJobNumber: 1,
+	}
+
+	if err := backgroundLaunchTestCase.Run(asserter, shell, logger); err != nil {
+		return err
+	}
+
+	// Assert the job output
+	jobsTestCase := test_cases.JobsBuiltinResponseTestCase{
+		ExpectedOutputEntries: []test_cases.JobsBuiltinOutputEntry{{
+			JobNumber:     1,
+			Status:        "Running",
+			LaunchCommand: backgroundLaunchCommand,
+			Marker:        test_cases.CurrentJob,
+		}},
+		SuccessMessage: "✓ 1 entry matches the running job",
+	}
+
+	if err := jobsTestCase.Run(asserter, shell, logger); err != nil {
+		return err
+	}
+
+	return logAndQuit(asserter, nil)
+}

internal/stage_bg4.go

@@ -0,0 +1,91 @@
+package internal
+
+import (
+	"fmt"
+
+	"github.com/codecrafters-io/shell-tester/internal/logged_shell_asserter"
+	"github.com/codecrafters-io/shell-tester/internal/shell_executable"
+	"github.com/codecrafters-io/shell-tester/internal/test_cases"
+	"github.com/codecrafters-io/tester-utils/logger"
+	"github.com/codecrafters-io/tester-utils/test_case_harness"
+	"github.com/dustin/go-humanize/english"
+)
+
+func testBG4(stageHarness *test_case_harness.TestCaseHarness) error {
+	logger := stageHarness.Logger
+	shell := shell_executable.NewShellExecutable(stageHarness)
+	asserter := logged_shell_asserter.NewLoggedShellAsserter(shell)
+
+	if err := asserter.StartShellAndAssertPrompt(true); err != nil {
+		return err
+	}
+
+	commands := []string{"sleep 100", "sleep 200", "sleep 300"}
+
+	if err := launchBgCommandAndAssertJobs(asserter, shell, logger, commands); err != nil {
+		return err
+	}
+
+	return logAndQuit(asserter, nil)
+}
+
+// launchBgCommandAndAssertJobs launches the given bgCommands one by one
+// with a 'jobs' call after each launch
+func launchBgCommandAndAssertJobs(asserter *logged_shell_asserter.LoggedShellAsserter, shell *shell_executable.ShellExecutable, logger *logger.Logger, bgCommands []string) error {
+	type jobInfo struct {
+		JobNumber int
+		Command   string
+	}
+
+	var jobs []jobInfo
+
+	for i, bgCommand := range bgCommands {
+		backgroundLaunchTestCase := test_cases.BackgroundCommandResponseTestCase{
+			Command:           bgCommand,
+			SuccessMessage:    "✓ Output includes job number with PID",
+			ExpectedJobNumber: i + 1,
+		}
+
+		if err := backgroundLaunchTestCase.Run(asserter, shell, logger); err != nil {
+			return err
+		}
+
+		jobs = append(jobs, jobInfo{JobNumber: i + 1, Command: bgCommand})
+
+		jobsOutputEntries := make([]test_cases.JobsBuiltinOutputEntry, 0, len(jobs))
+
+		for i, job := range jobs {
+			// Default marker is unmarked
+			marker := test_cases.UnmarkedJob
+
+			// If the job was recently launched, it is the 'Current' job
+			if i == len(jobs)-1 {
+				marker = test_cases.CurrentJob
+				// If the job was launched previously, it is the 'Previous' job
+			} else if i == len(jobs)-2 {
+				marker = test_cases.PreviousJob
+			}
+
+			jobsOutputEntries = append(jobsOutputEntries, test_cases.JobsBuiltinOutputEntry{
+				JobNumber:     job.JobNumber,
+				Status:        "Running",
+				LaunchCommand: job.Command,
+				Marker:        marker,
+			})
+		}
+
+		jobsTestCase := test_cases.JobsBuiltinResponseTestCase{
+			ExpectedOutputEntries: jobsOutputEntries,
+			SuccessMessage: fmt.Sprintf(
+				"✓ %s match the running %s",
+				english.Plural(len(jobsOutputEntries), "entry", "entries"),
+				english.PluralWord(len(jobsOutputEntries), "job", "jobs"),
+			),
+		}
+
+		if err := jobsTestCase.Run(asserter, shell, logger); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/stages_test.go

@@ -98,7 +98,7 @@ func TestStages(t *testing.T) {
 			NormalizeOutputFunc: normalizeTesterOutput,
 		},
 		"background_jobs_pass_bash": {
-			StageSlugs:          []string{"af3", "at7"},
+			StageSlugs:          []string{"af3", "at7", "jd6", "dk5"},
 			CodePath:            "./test_helpers/bash",
 			ExpectedExitCode:    0,
 			StdoutFixturePath:   "./test_helpers/fixtures/bash/background_jobs/pass",
@@ -118,6 +118,20 @@ func TestStages(t *testing.T) {
 			StdoutFixturePath:   "./test_helpers/fixtures/background_jobs_incorrect_job_number",
 			NormalizeOutputFunc: normalizeTesterOutput,
 		},
+		"background_jobs_jobs_builtin_incorrect_marker": {
+			StageSlugs:          []string{"dk5"},
+			CodePath:            "./test_helpers/scenarios/background_jobs_jobs_builtin_incorrect_marker",
+			ExpectedExitCode:    1,
+			StdoutFixturePath:   "./test_helpers/fixtures/background_jobs_jobs_builtin_incorrect_marker",
+			NormalizeOutputFunc: normalizeTesterOutput,
+		},
+		"background_jobs_jobs_builtin_incorrect_output_format": {
+			StageSlugs:          []string{"dk5"},
+			CodePath:            "./test_helpers/scenarios/background_jobs_jobs_builtin_incorrect_output_format",
+			ExpectedExitCode:    1,
+			StdoutFixturePath:   "./test_helpers/fixtures/background_jobs_jobs_builtin_incorrect_output_format",
+			NormalizeOutputFunc: normalizeTesterOutput,
+		},
 		"pipelines_pass_bash": {
 			StageSlugs:          []string{"br6", "ny9", "xk3"},
 			CodePath:            "./test_helpers/bash",

internal/test_cases/jobs_builtin_response_test_case.go

@@ -3,7 +3,6 @@ package test_cases
 import (
 	"fmt"
 	"regexp"
-	"strings"
 
 	"github.com/codecrafters-io/shell-tester/internal/assertions"
 	"github.com/codecrafters-io/shell-tester/internal/logged_shell_asserter"
@@ -20,7 +19,7 @@ const (
 type JobsBuiltinOutputEntry struct {
 	// The job number value in the square brackets
 	JobNumber int
-	// Status: "Running", "Done", "Terminated", etc
+	// Status: "Running", "Done", "Terminated", "1 Exit", etc
 	Status string
 	// LaunchCommand: Command that was run and sent to the background without trailing &
 	LaunchCommand string
@@ -29,8 +28,8 @@ type JobsBuiltinOutputEntry struct {
 }
 
 type JobsBuiltinResponseTestCase struct {
-	ExpectedOutputItems []JobsBuiltinOutputEntry
-	SuccessMessage      string
+	ExpectedOutputEntries []JobsBuiltinOutputEntry
+	SuccessMessage        string
 }
 
 func (t JobsBuiltinResponseTestCase) Run(asserter *logged_shell_asserter.LoggedShellAsserter, shell *shell_executable.ShellExecutable, logger *logger.Logger) (err error) {
@@ -51,48 +50,56 @@ func (t JobsBuiltinResponseTestCase) Run(asserter *logged_shell_asserter.LoggedS
 		ExpectedOutput: commandReflection,
 	})
 
-	// If we don't expect any items directly assert next prompt
-	if len(t.ExpectedOutputItems) == 0 {
+	// In case of no output entries, assert only the command reflection
+	if len(t.ExpectedOutputEntries) == 0 {
 		return asserter.AssertWithPrompt()
 	}
 
-	for i, outputEntry := range t.ExpectedOutputItems {
-		marker := convertJobMarkerToString(outputEntry.Marker)
+	for i, expectedOutputEntry := range t.ExpectedOutputEntries {
+		expectedJobMarkerString := convertJobMarkerToString(expectedOutputEntry.Marker)
+
+		// This regex aims to match lines like: [1]+  Running                 sleep 5 &
 		regexString := fmt.Sprintf(
 			`^\[%d\]\s*%s\s+(?i)%s\s+(?-i)%s`,
-			outputEntry.JobNumber,
-			marker,
-			regexp.QuoteMeta(outputEntry.Status),
-			regexp.QuoteMeta(outputEntry.LaunchCommand),
+			expectedOutputEntry.JobNumber,
+			regexp.QuoteMeta(expectedJobMarkerString),
+			regexp.QuoteMeta(expectedOutputEntry.Status),
+			regexp.QuoteMeta(expectedOutputEntry.LaunchCommand),
 		)
 
-		// For 'running' jobs, bash displays the trailing & sign
-		// This is optional since ZSH doesn't use this
-		if strings.ToLower(outputEntry.Status) == "running" {
+		// For 'Running' jobs, bash displays the trailing & sign
+		// Users shall comply with bash for consistency (Ensured this by appending this to expected output)
+		// But this should be optional since ZSH doesn't use this
+		if expectedOutputEntry.Status == "Running" {
 			regexString += "( &)?$"
 		} else {
 			regexString += "$"
 		}
 
-		regex := regexp.MustCompile(regexString)
+		expectedOutput := fmt.Sprintf(
+			"[%d]%s  %s                 %s",
+			expectedOutputEntry.JobNumber, expectedJobMarkerString, expectedOutputEntry.Status, expectedOutputEntry.LaunchCommand,
+		)
+
+		// For 'Running' jobs, the trailing sign is expected
+		if expectedOutputEntry.Status == "Running" {
+			expectedOutput += " &"
+		}
 
 		asserter.AddAssertion(assertions.SingleLineAssertion{
-			ExpectedOutput: fmt.Sprintf(
-				"[%d]%s  %s                 %s",
-				outputEntry.JobNumber, marker, outputEntry.Status, outputEntry.LaunchCommand,
-			),
-			FallbackPatterns: []*regexp.Regexp{regex},
+			ExpectedOutput:   expectedOutput,
+			FallbackPatterns: []*regexp.Regexp{regexp.MustCompile(regexString)},
 		})
 
-		shouldAssertWithPrompt := false
+		assertWithPrompt := false
+		var err error
 
-		if i == len(t.ExpectedOutputItems)-1 {
-			shouldAssertWithPrompt = true
+		if i == len(t.ExpectedOutputEntries)-1 {
+			assertWithPrompt = true
 		}
 
-		var err error
-
-		if shouldAssertWithPrompt {
+		// Assert with prompt on last entry
+		if assertWithPrompt {
 			err = asserter.AssertWithPrompt()
 		} else {
 			err = asserter.AssertWithoutPrompt()
@@ -101,6 +108,7 @@ func (t JobsBuiltinResponseTestCase) Run(asserter *logged_shell_asserter.LoggedS
 		if err != nil {
 			return err
 		}
+
 	}
 
 	return nil

internal/test_helpers/course_definition.yml

@@ -1259,6 +1259,20 @@ stages:
     marketing_md: |-
       In this stage, you'll implement launching commands in the background.
 
+  - slug: "jd6"
+    primary_extension_slug: "background-jobs"
+    name: "List a single job"
+    difficulty: medium
+    marketing_md: |-
+      In this stage, you'll implement the `jobs` builtin so it can list a single background job.
+
+  - slug: "dk5"
+    primary_extension_slug: "background-jobs"
+    name: "List multiple jobs"
+    difficulty: medium
+    marketing_md: |-
+      In this stage, you'll extend the `jobs` builtin so it can list background jobs.
+
   - slug: "br6"
     primary_extension_slug: "pipelines"
     name: "Dual-command pipeline"

internal/test_helpers/fixtures/background_jobs_jobs_builtin_incorrect_marker

@@ -0,0 +1,15 @@
+Debug = true
+
+[tester::#DK5] Running tests for Stage #DK5 (dk5)
+[tester::#DK5] Running ./your_program.sh
+[your-program] $ sleep 100 &
+[your-program] [1] 2518
+[tester::#DK5] ✓ Output includes job number with PID
+[your-program] $ jobs
+[your-program] [1]-  Running                 sleep 100 &
+[tester::#DK5] ^ Line does not match expected value.
+[tester::#DK5] Expected: "[1]+  Running                 sleep 100 &"
+[tester::#DK5] Received: "[1]-  Running                 sleep 100 &"
+[your-program] $ 
+[tester::#DK5] Assertion failed.
+[tester::#DK5] Test failed

internal/test_helpers/fixtures/background_jobs_jobs_builtin_incorrect_output_format

@@ -0,0 +1,15 @@
+Debug = true
+
+[tester::#DK5] Running tests for Stage #DK5 (dk5)
+[tester::#DK5] Running ./your_program.sh
+[your-program] $ sleep 100 &
+[your-program] [1] 2318
+[tester::#DK5] ✓ Output includes job number with PID
+[your-program] $ jobs
+[your-program] [1]+Running                 sleep 100 &
+[tester::#DK5] ^ Line does not match expected value.
+[tester::#DK5] Expected: "[1]+  Running                 sleep 100 &"
+[tester::#DK5] Received: "[1]+Running                 sleep 100 &"
+[your-program] $ 
+[tester::#DK5] Assertion failed.
+[tester::#DK5] Test failed