rename assignment -> lesson

Author: cgsdev0

checks/command.go

@@ -8,10 +8,10 @@ import (
 )
 
 func CLICommand(
-	assignment api.Assignment,
+	lesson api.Lesson,
 	optionalPositionalArgs []string,
 ) []api.CLICommandResult {
-	data := assignment.Assignment.AssignmentDataCLICommand.CLICommandData
+	data := lesson.Lesson.LessonDataCLICommand.CLICommandData
 	responses := make([]api.CLICommandResult, len(data.Commands))
 	for i, command := range data.Commands {
 		finalCommand := args.InterpolateCommand(command.Command, optionalPositionalArgs)

checks/http.go

@@ -24,13 +24,13 @@ type HttpTestResult struct {
 }
 
 func HttpTest(
-	assignment api.Assignment,
+	lesson api.Lesson,
 	baseURL *string,
 ) (
 	responses []HttpTestResult,
 	finalBaseURL string,
 ) {
-	data := assignment.Assignment.AssignmentDataHTTPTests
+	data := lesson.Lesson.LessonDataHTTPTests
 	client := &http.Client{}
 	variables := make(map[string]string)
 	responses = make([]HttpTestResult, len(data.HttpTests.Requests))

client/assignments.go renamed to client/lessons.go

@@ -38,7 +38,7 @@ type HTTPTestHeader struct {
 	Value string
 }
 
-type AssignmentDataHTTPTests struct {
+type LessonDataHTTPTests struct {
 	HttpTests struct {
 		BaseURL             *string
 		ContainsCompleteDir bool
@@ -70,7 +70,7 @@ type CLICommandTestCase struct {
 	StdoutLinesGt      *int
 }
 
-type AssignmentDataCLICommand struct {
+type LessonDataCLICommand struct {
 	CLICommandData struct {
 		Commands []struct {
 			Command string
@@ -79,21 +79,21 @@ type AssignmentDataCLICommand struct {
 	}
 }
 
-type Assignment struct {
-	Assignment struct {
+type Lesson struct {
+	Lesson struct {
 		Type                     string
-		AssignmentDataHTTPTests  *AssignmentDataHTTPTests
-		AssignmentDataCLICommand *AssignmentDataCLICommand
+		LessonDataHTTPTests  *LessonDataHTTPTests
+		LessonDataCLICommand *LessonDataCLICommand
 	}
 }
 
-func FetchAssignment(uuid string) (*Assignment, error) {
-	resp, err := fetchWithAuth("GET", "/v1/assignments/"+uuid)
+func FetchLesson(uuid string) (*Lesson, error) {
+	resp, err := fetchWithAuth("GET", "/v1/lessons/"+uuid)
 	if err != nil {
 		return nil, err
 	}
 
-	var data Assignment
+	var data Lesson
 	err = json.Unmarshal(resp, &data)
 	if err != nil {
 		return nil, err
@@ -111,12 +111,12 @@ type submitHTTPTestRequest struct {
 	ActualHTTPRequests any `json:"actualHTTPRequests"`
 }
 
-func SubmitHTTPTestAssignment(uuid string, results any) error {
+func SubmitHTTPTestLesson(uuid string, results any) error {
 	bytes, err := json.Marshal(submitHTTPTestRequest{ActualHTTPRequests: results})
 	if err != nil {
 		return err
 	}
-	resp, code, err := fetchWithAuthAndPayload("POST", "/v1/assignments/"+uuid+"/http_tests", bytes)
+	resp, code, err := fetchWithAuthAndPayload("POST", "/v1/lessons/"+uuid+"/http_tests", bytes)
 	if err != nil {
 		return err
 	}
@@ -141,12 +141,12 @@ type CLICommandResult struct {
 	Stdout   string
 }
 
-func SubmitCLICommandAssignment(uuid string, results []CLICommandResult) (*StructuredErrCLICommand, error) {
+func SubmitCLICommandLesson(uuid string, results []CLICommandResult) (*StructuredErrCLICommand, error) {
 	bytes, err := json.Marshal(submitCLICommandRequest{CLICommandResults: results})
 	if err != nil {
 		return nil, err
 	}
-	resp, code, err := fetchWithAuthAndPayload("POST", "/v1/assignments/"+uuid+"/cli_command", bytes)
+	resp, code, err := fetchWithAuthAndPayload("POST", "/v1/lessons/"+uuid+"/cli_command", bytes)
 	if err != nil {
 		return nil, err
 	}

cmd/run.go

@@ -13,7 +13,7 @@ func init() {
 var runCmd = &cobra.Command{
 	Use:    "run UUID",
 	Args:   cobra.MatchAll(cobra.RangeArgs(1, 10)),
-	Short:  "Run an assignment without submitting",
+	Short:  "Run an lesson without submitting",
 	PreRun: compose(requireUpdated, requireAuth),
 	RunE:   submissionHandler,
 }

cmd/submit.go

@@ -21,40 +21,40 @@ func init() {
 var submitCmd = &cobra.Command{
 	Use:    "submit UUID",
 	Args:   cobra.MatchAll(cobra.RangeArgs(1, 10)),
-	Short:  "Submit an assignment",
+	Short:  "Submit an lesson",
 	PreRun: compose(requireUpdated, requireAuth),
 	RunE:   submissionHandler,
 }
 
 func submissionHandler(cmd *cobra.Command, args []string) error {
 	cmd.SilenceUsage = true
 	isSubmit := cmd.Name() == "submit"
-	assignmentUUID := args[0]
+	lessonUUID := args[0]
 	optionalPositionalArgs := []string{}
 	if len(args) > 1 {
 		optionalPositionalArgs = args[1:]
 	}
 
-	assignment, err := api.FetchAssignment(assignmentUUID)
+	lesson, err := api.FetchLesson(lessonUUID)
 	if err != nil {
 		return err
 	}
-	switch assignment.Assignment.Type {
+	switch lesson.Lesson.Type {
 	case "type_http_tests":
-		results, finalBaseURL := checks.HttpTest(*assignment, &submitBaseURL)
-		render.PrintHTTPResults(results, assignment, finalBaseURL)
+		results, finalBaseURL := checks.HttpTest(*lesson, &submitBaseURL)
+		render.PrintHTTPResults(results, lesson, finalBaseURL)
 		if isSubmit {
-			err := api.SubmitHTTPTestAssignment(assignmentUUID, results)
+			err := api.SubmitHTTPTestLesson(lessonUUID, results)
 			if err != nil {
 				return err
 			}
 			fmt.Println("\nSubmitted! Check the lesson on Boot.dev for results")
 		}
 	case "type_cli_command":
-		results := checks.CLICommand(*assignment, optionalPositionalArgs)
-		data := *assignment.Assignment.AssignmentDataCLICommand
+		results := checks.CLICommand(*lesson, optionalPositionalArgs)
+		data := *lesson.Lesson.LessonDataCLICommand
 		if isSubmit {
-			failure, err := api.SubmitCLICommandAssignment(assignmentUUID, results)
+			failure, err := api.SubmitCLICommandLesson(lessonUUID, results)
 			if err != nil {
 				return err
 			}
@@ -63,7 +63,7 @@ func submissionHandler(cmd *cobra.Command, args []string) error {
 			render.CommandRun(data, results, optionalPositionalArgs)
 		}
 	default:
-		return errors.New("unsupported assignment type")
+		return errors.New("unsupported lesson type")
 	}
 	return nil
 }

render/command.go

@@ -213,15 +213,15 @@ func pointerToBool(a bool) *bool {
 }
 
 func CommandRun(
-	data api.AssignmentDataCLICommand,
+	data api.LessonDataCLICommand,
 	results []api.CLICommandResult,
 	optionalPositionalArgs []string,
 ) {
 	commandRenderer(data, results, nil, false, optionalPositionalArgs)
 }
 
 func CommandSubmission(
-	data api.AssignmentDataCLICommand,
+	data api.LessonDataCLICommand,
 	results []api.CLICommandResult,
 	failure *api.StructuredErrCLICommand,
 	optionalPositionalArgs []string,
@@ -230,7 +230,7 @@ func CommandSubmission(
 }
 
 func commandRenderer(
-	data api.AssignmentDataCLICommand,
+	data api.LessonDataCLICommand,
 	results []api.CLICommandResult,
 	failure *api.StructuredErrCLICommand,
 	isSubmit bool,

render/http.go

@@ -8,17 +8,17 @@ import (
 	api "github.com/bootdotdev/bootdev/client"
 )
 
-func PrintHTTPResults(results []checks.HttpTestResult, assignment *api.Assignment, finalBaseURL string) {
+func PrintHTTPResults(results []checks.HttpTestResult, lesson *api.Lesson, finalBaseURL string) {
 	fmt.Println("=====================================")
 	defer fmt.Println("=====================================")
 	fmt.Printf("Running requests against: %s\n", finalBaseURL)
 	for i, result := range results {
-		printHTTPResult(result, i, assignment)
+		printHTTPResult(result, i, lesson)
 	}
 }
 
-func printHTTPResult(result checks.HttpTestResult, i int, assignment *api.Assignment) {
-	req := assignment.Assignment.AssignmentDataHTTPTests.HttpTests.Requests[i]
+func printHTTPResult(result checks.HttpTestResult, i int, lesson *api.Lesson) {
+	req := lesson.Lesson.LessonDataHTTPTests.HttpTests.Requests[i]
 	fmt.Printf("%v. %v %v\n", i+1, req.Request.Method, req.Request.Path)
 	if result.Err != "" {
 		fmt.Printf("  Err: %v\n", result.Err)