Use workspace manager to setup workspace instead of utils, make prompts short, only keep relevant logs

Author: UdeshyaDhungana

internal/assertions/filesystem_assertion/file_contents_assertion.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 	"unicode"
 
@@ -15,44 +14,42 @@ type FileContentsAssertion struct {
 	ExpectedContents string
 }
 
-func (a FileContentsAssertion) Run(path string, logger *logger.Logger) error {
-	_, err := os.Stat(path)
+func (a FileContentsAssertion) Run(absolutePath string, logger *logger.Logger, shortFilePathConverter func(string) string) error {
+	_, err := os.Stat(absolutePath)
+	shortFilePath := shortFilePathConverter(absolutePath)
 
 	if err != nil {
 		if os.IsNotExist(err) {
-			return fmt.Errorf("Expected file %s does not exist", path)
+			return fmt.Errorf("Expected file %s does not exist", shortFilePath)
 		}
 
-		return fmt.Errorf("Failed to check file %s: %v", path, err)
+		return fmt.Errorf("Failed to check file %s: %v", shortFilePath, err)
 	}
 
-	contents, err := os.ReadFile(path)
+	contents, err := os.ReadFile(absolutePath)
 
 	if err != nil {
-		return fmt.Errorf("Failed to read file %s: %v", path, err)
+		return fmt.Errorf("Failed to read file %s: %v", shortFilePath, err)
 	}
 
 	// Trim space from the right (File could have an extra \n: That's fine)
 	fileContentsTrimmed := strings.TrimRightFunc(string(contents), unicode.IsSpace)
-	fileName := filepath.Base(path)
 
 	if fileContentsTrimmed != a.ExpectedContents {
 		logger.Plainf("Expected contents:")
-		logger.WithAdditionalSecondaryPrefix(fileName, func() {
+		logger.WithAdditionalSecondaryPrefix(shortFilePath, func() {
 			logger.Plainf("%s", a.ExpectedContents)
 		})
 
 		logger.Errorf("Actual contents:")
-		logger.WithAdditionalSecondaryPrefix(fileName, func() {
+		logger.WithAdditionalSecondaryPrefix(shortFilePath, func() {
 			logger.Errorf("%s", fileContentsTrimmed)
 		})
 
 		return errors.New("Expected file contents differ from actual contents")
 	}
 
-	logger.Successf("✔ File %s exists with contents:", path)
-
-	logger.WithAdditionalSecondaryPrefix(filepath.Base(path), func() {
+	logger.WithAdditionalSecondaryPrefix(shortFilePath, func() {
 		logger.Successf("%s", fileContentsTrimmed)
 	})
 

internal/assertions/filesystem_assertion/file_does_not_exist_assertion.go

@@ -12,17 +12,18 @@ import (
 type FileDoesNotExistAssertion struct {
 }
 
-func (a FileDoesNotExistAssertion) Run(filePath string, logger *logger.Logger) error {
-	_, err := os.Stat(filePath)
+func (a FileDoesNotExistAssertion) Run(absolutePath string, logger *logger.Logger, shortFilePathConverter func(string) string) error {
+	_, err := os.Stat(absolutePath)
+	shortFilePath := shortFilePathConverter(absolutePath)
 
 	if err == nil {
-		return fmt.Errorf("Expected file %s to not exist, but it exists", filePath)
+		return fmt.Errorf("Expected file %s to not exist, but it exists", shortFilePath)
 	}
 
 	if !errors.Is(err, fs.ErrNotExist) {
-		return fmt.Errorf("Failed to check existence of %s: %v", filePath, err)
+		return fmt.Errorf("Failed to check existence of %s: %v", shortFilePath, err)
 	}
 
-	logger.Successf("✔ File %s does not exist", filePath)
+	logger.Successf("✔ File %s does not exist", shortFilePath)
 	return nil
 }

internal/assertions/filesystem_assertion/filesystem_assertion.go

@@ -3,5 +3,9 @@ package filesystem_assertion
 import "github.com/codecrafters-io/tester-utils/logger"
 
 type FileSystemAssertion interface {
-	Run(filePath string, logger *logger.Logger) error
+	// Run takes absFilePath, logger, and shortFilePathGetter
+	// absPath is the absolute path of the file
+	// logger is the logger object using which the success/failure logs are logged
+	// shortFilePathGetter is a function that converts absolute path to a short file path suitable for logging
+	Run(absFilePath string, logger *logger.Logger, shortFilePathConverter func(string) string) error
 }

internal/stage_test_advertise_read_tool.go

@@ -12,9 +12,10 @@ import (
 
 func testAdvertiseReadTool(stageHarness *test_case_harness.TestCaseHarness) error {
 	proxy_server.StartProxyServer(stageHarness)
-	workspace_manager.BootstrapExecutableWorkspace(stageHarness)
 	settings_manager.InitializeBypassPermissionSettings(stageHarness)
 	stageHarness.Executable.TimeoutInMilliseconds = 30 * 1000
+	workspaceManager := workspace_manager.NewWorkspaceManager()
+	workspaceManager.BootstrapExecutableWorkspace(stageHarness)
 
 	prompt := utils.GetPromptWithGuardRailPrompt(
 		[]string{

internal/stage_test_agent_loop.go

@@ -2,8 +2,6 @@ package internal
 
 import (
 	"fmt"
-	"path/filepath"
-	"strings"
 
 	"github.com/codecrafters-io/claude-code-tester/internal/assertions/string_assertion"
 	"github.com/codecrafters-io/claude-code-tester/internal/settings_manager"
@@ -17,53 +15,56 @@ import (
 
 func testAgentLoop(stageHarness *test_case_harness.TestCaseHarness) error {
 	proxy_server.StartProxyServer(stageHarness)
-	workspace_manager.BootstrapExecutableWorkspace(stageHarness)
 	settings_manager.InitializeBypassPermissionSettings(stageHarness)
 	stageHarness.Executable.TimeoutInMilliseconds = 30 * 1000
-	workspaceDirPath := stageHarness.Executable.WorkingDir
 
-	appDirPath := filepath.Join(workspaceDirPath, "app")
-	utils.MustCreateDirWithLogging(appDirPath, stageHarness.Logger)
+	workspaceManager := workspace_manager.NewWorkspaceManager()
+	workspaceManager.BootstrapExecutableWorkspace(stageHarness)
 
-	// Create supporting file
-	extraFilePath := filepath.Join(appDirPath, random.RandomElementFromArray([]string{"chemical.py", "substance.py", "expiry.py", "duration.py"}))
-	chemicalExpiryPeriod := random.RandomInt(6, 36) // Random value between 6 and 36 months
-	extraFileContent := fmt.Sprintf("chemical_expiry_period = %d  # months", chemicalExpiryPeriod)
-	utils.MustCreateFileWithContentsWithLogger(extraFilePath, extraFileContent, stageHarness.Logger)
+	mainFileName := random.RandomElementFromArray([]string{"main.py", "init.py", "start.py"})
+	extraFileNameWithoutExtension := random.RandomElementFromArray([]string{"chemical", "substance", "expiry", "duration"})
+	extraFileName := extraFileNameWithoutExtension + ".py"
+	readmeFileName := "README.md"
 
-	// Create main file
-	mainFilePath := filepath.Join(
-		appDirPath,
-		random.RandomElementFromArray([]string{"main.py", "init.py", "start.py"}),
-	)
-
-	extraFileBaseNameWithoutExtension := strings.TrimSuffix(filepath.Base(extraFilePath), ".py")
-	mainContent := fmt.Sprintf(`from %s import chemical_expiry_period
+	mainFileContent := fmt.Sprintf(`from %s import chemical_expiry_period
 
-def main():
-    print(f"Chemical expiry period: {chemical_expiry_period} months")
+	def main():
+		print(f"Chemical expiry period: {chemical_expiry_period} months")
+	
+	if __name__ == "__main__":
+		main()
+`, extraFileNameWithoutExtension)
 
-if __name__ == "__main__":
-    main()
-`, extraFileBaseNameWithoutExtension)
+	chemicalExpiryPeriod := random.RandomInt(6, 36)
 
-	utils.MustCreateFileWithContentsWithLogger(mainFilePath, mainContent, stageHarness.Logger)
-
-	// Create README.md
-	readmePath := filepath.Join(workspaceDirPath, "README.md")
 	readmeContent := fmt.Sprintf(`This is a simple python project.
-The starting point of this project is app/%s.`, filepath.Base(mainFilePath))
-	utils.MustCreateFileWithContentsWithLogger(readmePath, readmeContent, stageHarness.Logger)
+- The starting point of this project is app/%s.
+- The file app/%s contains chemical properties.`, mainFileName, extraFileName)
 
-	expectedOutput := fmt.Sprintf("%d", chemicalExpiryPeriod)
+	workspaceManager.MustCreateFilesWithLogger([]workspace_manager.WorkspaceFile{
+		{
+			RelativePath: readmeFileName,
+			Content:      readmeContent,
+			FileMode:     0644,
+		},
+		{
+
+			RelativePath: fmt.Sprintf("app/%s", extraFileName),
+			Content:      fmt.Sprintf("chemical_expiry_period = %d  # months", chemicalExpiryPeriod),
+			FileMode:     0644,
+		},
+		{
+			RelativePath: fmt.Sprintf("app/%s", mainFileName),
+			Content:      mainFileContent,
+			FileMode:     0644,
+		},
+	}, stageHarness.Logger)
 
 	prompt := utils.GetPromptWithGuardRailPrompt(
 		[]string{
-			"Read the README.md, figure out the file that contains the chemical expiry period in months, and get me that value.",
-			"Read README.md, determine which file contains the chemical expiry period in months, and get me that value.",
-			"Read the README.md file, find the file that contains the chemical expiry period in months, and get me that value.",
-			"Read README.md, figure out which file has the chemical expiry period in months, and get me that value.",
-			"Read the README.md, identify the file containing the chemical expiry period in months, and get me that value.",
+			"Use README.md to determine the chemical expiry period in months.",
+			"Find the chemical expiry period in months from README.md.",
+			"Determine in how many months the chemical expires by reading README.md.",
 		},
 		"Number only.",
 	)
@@ -72,7 +73,7 @@ The starting point of this project is app/%s.`, filepath.Base(mainFilePath))
 		InputPrompt:      prompt,
 		ExpectedExitCode: 0,
 		StdoutAssertion: string_assertion.ExactMatchAssertion{
-			ExpectedValue: expectedOutput,
+			ExpectedValue: fmt.Sprintf("%d", chemicalExpiryPeriod),
 		},
 	}
 

internal/stage_test_bash_tool.go

@@ -1,10 +1,7 @@
 package internal
 
 import (
-	"path/filepath"
-
 	"github.com/codecrafters-io/claude-code-tester/internal/assertions/filesystem_assertion"
-	"github.com/codecrafters-io/claude-code-tester/internal/assertions/string_assertion"
 	"github.com/codecrafters-io/claude-code-tester/internal/settings_manager"
 	"github.com/codecrafters-io/claude-code-tester/internal/test_cases"
 	"github.com/codecrafters-io/claude-code-tester/internal/utils"
@@ -15,75 +12,85 @@ import (
 
 func testBashTool(stageHarness *test_case_harness.TestCaseHarness) error {
 	proxy_server.StartProxyServer(stageHarness)
-	workspace_manager.BootstrapExecutableWorkspace(stageHarness)
 	settings_manager.InitializeBypassPermissionSettings(stageHarness)
 	stageHarness.Executable.TimeoutInMilliseconds = 30 * 1000
-	workspaceDirPath := stageHarness.Executable.WorkingDir
+	stageLogger := stageHarness.Logger
 
-	appDirPath := filepath.Join(workspaceDirPath, "app")
-	utils.MustCreateDirWithLogging(appDirPath, stageHarness.Logger)
+	workspaceManager := workspace_manager.NewWorkspaceManager()
+	workspaceManager.BootstrapExecutableWorkspace(stageHarness)
+
+	// Store file contents in variables
+	mainJsContent := `async function main() {
+  const response = await fetch('https://jsonplaceholder.typicode.com/posts/1');
+  const data = await response.json();
+  console.log(data);
+}
+
+main();`
 
-	readmePath := filepath.Join(workspaceDirPath, "README.md")
 	readmeContent := `# My Project
 Uses async js to demonstrate web fetch.
 Entry point: app/`
-	utils.MustCreateFileWithContentsWithLogger(readmePath, readmeContent, stageHarness.Logger)
 
-	readmeOldPath := filepath.Join(workspaceDirPath, "README_old.md")
 	readmeOldContent := `# My project
 Uses javascript promise api to demonstrate web fetch.
 Entry point: app/`
-	utils.MustCreateFileWithContentsWithLogger(readmeOldPath, readmeOldContent, stageHarness.Logger)
-
-	mainFilePath := filepath.Join(appDirPath, "main.js")
-	mainContent := `async function main() {
-  const response = await fetch('https://jsonplaceholder.typicode.com/posts/1');
-  const data = await response.json();
-  console.log(data);
-}
 
-main();`
-	utils.MustCreateFileWithContentsWithLogger(mainFilePath, mainContent, stageHarness.Logger)
+	// Create files using MustCreateFiles
+	workspaceManager.MustCreateFilesWithLogger([]workspace_manager.WorkspaceFile{
+		{
+			RelativePath: "app/main.js",
+			Content:      mainJsContent,
+			FileMode:     0644,
+		},
+		{
+			RelativePath: "README.md",
+			Content:      readmeContent,
+			FileMode:     0644,
+		},
+		{
+			RelativePath: "README_old.md",
+			Content:      readmeOldContent,
+			FileMode:     0644,
+		},
+	}, stageLogger)
 
 	promptTestCase := test_cases.NonInteractiveTestCase{
 		InputPrompt: utils.GetPromptWithGuardRailPrompt(
 			[]string{
 				"Delete the old readme file.",
 				"Remove the old readme from the project.",
 			},
-			"Always respond with `Done`",
+			"Always respond with `Deleted README_old.md`",
 		),
-		StdoutAssertion: string_assertion.ExactMatchAssertion{
-			ExpectedValue: "Done",
-		},
 		ExpectedExitCode: 0,
 	}
 
 	if err := promptTestCase.Run(stageHarness); err != nil {
 		return err
 	}
 
-	// main.js should be intact
-	mainJsAssertion := filesystem_assertion.FileContentsAssertion{
-		ExpectedContents: mainContent,
-	}
-	if err := mainJsAssertion.Run(mainFilePath, stageHarness.Logger); err != nil {
+	stageLogger.Infof("Checking workspace contents")
+
+	// Assert that main file is intact
+	mainFileAbsPath := workspaceManager.ConvertToAbsPath("app/main.js")
+	mainJsAssertion := filesystem_assertion.FileContentsAssertion{ExpectedContents: mainJsContent}
+
+	if err := mainJsAssertion.Run(mainFileAbsPath, stageLogger, workspaceManager.GetRelPathConverter()); err != nil {
 		return err
 	}
 
-	// New readme should be intact
-	newReadmeAssertion := filesystem_assertion.FileContentsAssertion{
-		ExpectedContents: readmeContent,
-	}
-	if err := newReadmeAssertion.Run(readmePath, stageHarness.Logger); err != nil {
+	// Assert that readme is intact
+	readmePath := workspaceManager.ConvertToAbsPath("README.md")
+	readmeAssertion := filesystem_assertion.FileContentsAssertion{ExpectedContents: readmeContent}
+
+	if err := readmeAssertion.Run(readmePath, stageLogger, workspaceManager.GetRelPathConverter()); err != nil {
 		return err
 	}
 
-	// Old readme should be deleted
+	// Assert that old readme is deleted
+	oldReadmeAbsPath := workspaceManager.ConvertToAbsPath("README_old.md")
 	oldReadmeAssertion := filesystem_assertion.FileDoesNotExistAssertion{}
-	if err := oldReadmeAssertion.Run(readmeOldPath, stageHarness.Logger); err != nil {
-		return err
-	}
 
-	return nil
+	return oldReadmeAssertion.Run(oldReadmeAbsPath, stageLogger, workspaceManager.GetRelPathConverter())
 }