Align local grading and assertion descriptions with backend behavior

Author: skovranek

checks/cli.go

@@ -148,12 +148,13 @@ func parseStdoutVariables(stdout string, vardefs []api.CLICommandStdoutVariable,
 }
 
 func prettyPrintCLICommand(test api.CLICommandTest, variables map[string]string) string {
+	var descriptions []string
 	if test.ExitCode != nil {
-		return fmt.Sprintf("Expect exit code %d", *test.ExitCode)
+		descriptions = append(descriptions, fmt.Sprintf("Expect exit code %d", *test.ExitCode))
 	}
 
 	if test.StdoutLinesGT != nil {
-		return fmt.Sprintf("Expect > %d lines on stdout", *test.StdoutLinesGT)
+		descriptions = append(descriptions, fmt.Sprintf("Expect > %d lines on stdout", *test.StdoutLinesGT))
 	}
 
 	if test.StdoutContainsAll != nil {
@@ -163,7 +164,7 @@ func prettyPrintCLICommand(test api.CLICommandTest, variables map[string]string)
 			interpolatedContains := InterpolateVariables(contains, variables)
 			fmt.Fprintf(&str, "\n      - '%s'", interpolatedContains)
 		}
-		return str.String()
+		descriptions = append(descriptions, str.String())
 	}
 
 	if test.StdoutContainsNone != nil {
@@ -173,12 +174,12 @@ func prettyPrintCLICommand(test api.CLICommandTest, variables map[string]string)
 			interpolatedContainsNone := InterpolateVariables(containsNone, variables)
 			fmt.Fprintf(&str, "\n      - '%s'", interpolatedContainsNone)
 		}
-		return str.String()
+		descriptions = append(descriptions, str.String())
 	}
 
 	if test.StdoutJq != nil {
-		return prettyPrintStdoutJqTest(*test.StdoutJq, variables)
+		descriptions = append(descriptions, prettyPrintStdoutJqTest(*test.StdoutJq, variables))
 	}
 
-	return ""
+	return strings.Join(descriptions, "\n")
 }

checks/http.go

@@ -146,44 +146,35 @@ func interpolateJSONStrings(value any, variables map[string]string) any {
 }
 
 func prettyPrintHTTPTest(test api.HTTPRequestTest, variables map[string]string) string {
+	var descriptions []string
 	if test.StatusCode != nil {
-		return fmt.Sprintf("Expecting status code: %d", *test.StatusCode)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting status code: %d", *test.StatusCode))
 	}
 	if test.BodyContains != nil {
-		interpolated := InterpolateVariables(*test.BodyContains, variables)
-		return fmt.Sprintf("Expecting response body to contain: %s", interpolated)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting response body to contain: %s", *test.BodyContains))
 	}
 	if test.BodyContainsNone != nil {
-		interpolated := InterpolateVariables(*test.BodyContainsNone, variables)
-		return fmt.Sprintf("Expecting response body to not contain: %s", interpolated)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting response body to not contain: %s", *test.BodyContainsNone))
 	}
 	if test.HeadersEqual != nil {
-		interpolatedKey := InterpolateVariables(test.HeadersEqual.Key, variables)
-		interpolatedValue := InterpolateVariables(test.HeadersEqual.Value, variables)
-		return fmt.Sprintf("Expecting header to equal: '%s: %v'", interpolatedKey, interpolatedValue)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting header to equal: '%s: %v'", test.HeadersEqual.Key, test.HeadersEqual.Value))
 	}
 	if test.HeadersContain != nil {
-		interpolatedKey := InterpolateVariables(test.HeadersContain.Key, variables)
-		interpolatedValue := InterpolateVariables(test.HeadersContain.Value, variables)
-		return fmt.Sprintf("Expecting header to contain: '%s: %v'", interpolatedKey, interpolatedValue)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting header to contain: '%s: %v'", test.HeadersContain.Key, test.HeadersContain.Value))
 	}
 	if test.TrailersEqual != nil {
-		interpolatedKey := InterpolateVariables(test.TrailersEqual.Key, variables)
-		interpolatedValue := InterpolateVariables(test.TrailersEqual.Value, variables)
-		return fmt.Sprintf("Expecting trailer to equal: '%s: %v'", interpolatedKey, interpolatedValue)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting trailer to equal: '%s: %v'", test.TrailersEqual.Key, test.TrailersEqual.Value))
 	}
 	if test.TrailersContain != nil {
-		interpolatedKey := InterpolateVariables(test.TrailersContain.Key, variables)
-		interpolatedValue := InterpolateVariables(test.TrailersContain.Value, variables)
-		return fmt.Sprintf("Expecting trailer to contain: '%s: %v'", interpolatedKey, interpolatedValue)
+		descriptions = append(descriptions, fmt.Sprintf("Expecting trailer to contain: '%s: %v'", test.TrailersContain.Key, test.TrailersContain.Value))
 	}
 	if test.JSONValue != nil {
 		var val any
 		switch {
 		case test.JSONValue.IntValue != nil:
 			val = *test.JSONValue.IntValue
 		case test.JSONValue.StringValue != nil:
-			val = *test.JSONValue.StringValue
+			val = InterpolateVariables(*test.JSONValue.StringValue, variables)
 		case test.JSONValue.BoolValue != nil:
 			val = *test.JSONValue.BoolValue
 		}
@@ -201,9 +192,9 @@ func prettyPrintHTTPTest(test api.HTTPRequestTest, variables map[string]string)
 		}
 
 		expecting := fmt.Sprintf("Expecting JSON at %v %s %v", test.JSONValue.Path, op, val)
-		return InterpolateVariables(expecting, variables)
+		descriptions = append(descriptions, expecting)
 	}
-	return ""
+	return strings.Join(descriptions, "\n")
 }
 
 // Return a capped string representation of the response body.
@@ -267,7 +258,7 @@ func parseVariables(body []byte, vardefs []api.HTTPRequestResponseVariable, vari
 func parseHeaderVariables(headers map[string]string, vardefs []api.HTTPRequestResponseHeaderVariable, variables map[string]string) error {
 	for _, vardef := range vardefs {
 		headerValue, ok := findHeaderValue(headers, vardef.Header)
-		if !ok || headerValue == "" {
+		if !ok {
 			continue
 		}
 

checks/jq.go

@@ -2,19 +2,19 @@ package checks
 
 import (
 	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"strings"
 
 	api "github.com/bootdotdev/bootdev/client"
-	"github.com/goccy/go-json"
 	"github.com/itchyny/gojq"
 	"github.com/tailscale/hujson"
 )
 
 func prettyPrintStdoutJqTest(test api.StdoutJqTest, variables map[string]string) string {
-	queryText := InterpolateVariables(test.Query, variables)
+	queryText := test.Query
 	var str strings.Builder
 	fmt.Fprintf(&str, "Expect jq query '%s' to yield values satisfying:", queryText)
 	if len(test.ExpectedResults) == 0 {
@@ -30,11 +30,6 @@ func prettyPrintStdoutJqTest(test api.StdoutJqTest, variables map[string]string)
 
 func formatJqExpectedValue(expected api.JqExpectedResult, variables map[string]string) string {
 	value := expected.Value
-	if expected.Type == api.JqTypeString {
-		if stringValue, ok := expected.Value.(string); ok {
-			value = InterpolateVariables(stringValue, variables)
-		}
-	}
 	encoded, err := json.Marshal(value)
 	if err != nil {
 		return fmt.Sprintf("%v", value)
@@ -54,7 +49,7 @@ func collectStdoutJqOutputs(cmd api.CLIStepCLICommand, result api.CLICommandResu
 }
 
 func runStdoutJqQuery(stdout string, test api.StdoutJqTest, variables map[string]string) api.CLICommandJqOutput {
-	queryText := InterpolateVariables(test.Query, variables)
+	queryText := test.Query
 	input, err := parseJqInput(stdout, test.InputMode)
 	if err != nil {
 		return api.CLICommandJqOutput{Query: queryText, Error: err.Error()}

checks/jq_test.go

@@ -17,19 +17,19 @@ func TestRunStdoutJqQuery(t *testing.T) {
 		wantError bool
 	}{
 		{
-			name: "queries json with interpolated query",
+			name: "queries JSON with comments using a literal query",
 			stdout: `{
-				// Users to query
-				"users": [/* users */ {"name":"Lane"},{"name":"Theo",},],
-			}`,
+                // Users to query
+                "users": [/* users */ {"name":"Lane"},{"name":"Theo",},],
+            }`,
 			test: api.StdoutJqTest{
 				InputMode: "json",
 				Query:     `.users[] | select(.name == "${name}") | .name`,
 			},
 			variables: map[string]string{"name": "Theo"},
 			want: api.CLICommandJqOutput{
-				Query:   `.users[] | select(.name == "Theo") | .name`,
-				Results: []string{`"Theo"`},
+				Query:   `.users[] | select(.name == "${name}") | .name`,
+				Results: nil,
 			},
 		},
 		{