test: improve config coverage and add mock return validation tests

- Add tests for DSN missing with SQL query
- Add tests for ParseFile (success and file not found)
- Add tests for mock validation errors (type one/many mismatch)
- Add tests for invalid mock JS return values (array_js returning
  scalar/object, object_js returning array/scalar)
- Add test for 204 No Content response
- Remove dead code in errors.go (findUsedArraySource, unreachable branches)

Config package coverage: 72.9% -> 94.6%

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mpyw

e2e/invalid_mock_return_test.go

@@ -0,0 +1,52 @@
+package e2e
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInvalidMockReturn(t *testing.T) {
+	cfg := loadConfig(t, "invalid_mock_return_test.yaml")
+	handler := createHandler(t, nil, cfg)
+
+	t.Run("array_js returns scalar", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/array-returns-scalar", nil)
+		w := httptest.NewRecorder()
+		handler.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusInternalServerError, w.Code)
+		assert.Contains(t, w.Body.String(), "array")
+	})
+
+	t.Run("array_js returns object", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/array-returns-object", nil)
+		w := httptest.NewRecorder()
+		handler.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusInternalServerError, w.Code)
+		assert.Contains(t, w.Body.String(), "array")
+	})
+
+	t.Run("object_js returns array", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/object-returns-array", nil)
+		w := httptest.NewRecorder()
+		handler.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusInternalServerError, w.Code)
+		// Error message mentions type validation
+		assert.Contains(t, w.Body.String(), "error")
+	})
+
+	t.Run("object_js returns scalar", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/object-returns-scalar", nil)
+		w := httptest.NewRecorder()
+		handler.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusInternalServerError, w.Code)
+		// Error message mentions type validation
+		assert.Contains(t, w.Body.String(), "error")
+	})
+}

e2e/invalid_mock_return_test.yaml

@@ -0,0 +1,28 @@
+queries:
+  # array_js returning a scalar (should error)
+  - type: many
+    path: /array-returns-scalar
+    mock:
+      array_js: |
+        return "not an array";
+
+  # array_js returning an object (should error)
+  - type: many
+    path: /array-returns-object
+    mock:
+      array_js: |
+        return { id: 1 };
+
+  # object_js returning an array (should error)
+  - type: one
+    path: /object-returns-array
+    mock:
+      object_js: |
+        return [{ id: 1 }];
+
+  # object_js returning a scalar (should error)
+  - type: one
+    path: /object-returns-scalar
+    mock:
+      object_js: |
+        return "not an object";

e2e/request_response_test.go

@@ -218,6 +218,15 @@ func TestResponseObject(t *testing.T) {
 			"after202": 202
 		}`, rec.Body.String())
 	})
+
+	t.Run("response.status 204 No Content returns empty body", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "/test/response/204", nil)
+		rec := httptest.NewRecorder()
+
+		mux.ServeHTTP(rec, req)
+		require.Equal(t, http.StatusNoContent, rec.Code)
+		require.Empty(t, rec.Body.String())
+	})
 }
 
 func TestRequestInDifferentContexts(t *testing.T) {

e2e/request_response_test.yaml

@@ -193,6 +193,16 @@ queries:
         const after202 = response.status;
         return { before, after99, after600, after202 };
 
+  # Test 204 No Content returns empty body
+  - type: one
+    path: /test/response/204
+    mock:
+      object: { id: 1 }
+    transform:
+      post: |
+        response.status = 204;
+        return output;
+
   # ==========================================================================
   # Request in Different Contexts
   # ==========================================================================

internal/config/config_test.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -349,4 +350,141 @@ queries:
 
 	// Note: Transform JS validation happens at server startup via ValidateTransforms,
 	// not during Parse. Parse only validates the YAML schema structure.
+
+	t.Run("schema validation error - type one with array source without filter", func(t *testing.T) {
+		yaml := `
+queries:
+  - type: one
+    path: /user
+    mock:
+      array:
+        - id: 1
+        - id: 2
+`
+		_, err := Parse([]byte(yaml))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "filter")
+		assert.Contains(t, err.Error(), "array")
+	})
+
+	t.Run("schema validation error - type many with object source", func(t *testing.T) {
+		yaml := `
+queries:
+  - type: many
+    path: /users
+    mock:
+      object:
+        id: 1
+`
+		_, err := Parse([]byte(yaml))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "object")
+		assert.Contains(t, err.Error(), "many")
+	})
+
+	t.Run("schema validation error - type none with mock", func(t *testing.T) {
+		yaml := `
+mutations:
+  - type: none
+    path: /delete
+    mock:
+      object:
+        id: 1
+`
+		_, err := Parse([]byte(yaml))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "none")
+		assert.Contains(t, err.Error(), "mock")
+	})
+
+	t.Run("schema validation error - multiple mock sources", func(t *testing.T) {
+		yaml := `
+queries:
+  - type: many
+    path: /users
+    mock:
+      array:
+        - id: 1
+      array_js: "return [{id: 1}]"
+`
+		_, err := Parse([]byte(yaml))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "one source")
+	})
+
+	t.Run("schema validation error - type one with csv without filter", func(t *testing.T) {
+		yaml := `
+queries:
+  - type: one
+    path: /user
+    mock:
+      csv: |
+        id,name
+        1,Alice
+        2,Bob
+`
+		_, err := Parse([]byte(yaml))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "filter")
+		assert.Contains(t, err.Error(), "csv")
+	})
+}
+
+func TestParseFile(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		// Create a temporary file
+		tmpFile, err := os.CreateTemp("", "config-*.yaml")
+		require.NoError(t, err)
+		defer os.Remove(tmpFile.Name())
+
+		content := `
+queries:
+  - type: one
+    path: /user
+    mock:
+      object:
+        id: 1
+`
+		_, err = tmpFile.WriteString(content)
+		require.NoError(t, err)
+		tmpFile.Close()
+
+		cfg, err := ParseFile(tmpFile.Name())
+		require.NoError(t, err)
+		assert.Len(t, cfg.Queries, 1)
+	})
+
+	t.Run("file not found", func(t *testing.T) {
+		_, err := ParseFile("/nonexistent/path/config.yaml")
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "failed to open file")
+	})
+}
+
+func TestParse_DSNValidation(t *testing.T) {
+	t.Run("missing DSN with SQL query", func(t *testing.T) {
+		yaml := `
+queries:
+  - type: one
+    path: /user
+    sql: SELECT * FROM users WHERE id = :id
+`
+		_, err := Parse([]byte(yaml))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "missing dsn")
+	})
+
+	t.Run("missing DSN with mock only is allowed", func(t *testing.T) {
+		yaml := `
+queries:
+  - type: one
+    path: /user
+    mock:
+      object:
+        id: 1
+`
+		cfg, err := Parse([]byte(yaml))
+		require.NoError(t, err)
+		assert.Empty(t, cfg.DSN)
+	})
 }

internal/config/errors.go

@@ -108,47 +108,11 @@ func findMockSourceError(errors []errorWithPath) string {
 		}
 	}
 
-	// Look for missing filter error (array source with type: one without filter)
-	for _, e := range errors {
-		if !isMockPath(e.path) {
-			continue
-		}
-
-		if req, ok := e.err.ErrorKind.(*kind.Required); ok {
-			if slices.Contains(req.Missing, "filter") {
-				if usedSource := findUsedArraySource(errors, e.path); usedSource != "" {
-					parentPath := getParentPath(e.path)
-					return fmt.Sprintf("at '%s': type 'one' with '%s' source requires 'filter' to select a single row",
-						formatPath(parentPath), usedSource)
-				}
-			}
-		}
-	}
-
-	// Look for multiple sources error
-	for _, e := range errors {
-		if !isMockPath(e.path) {
-			continue
-		}
-
-		if addl, ok := e.err.ErrorKind.(*kind.AdditionalProperties); ok {
-			if len(addl.Properties) > 1 {
-				parentPath := getParentPath(e.path)
-				return fmt.Sprintf("at '%s': mock must have exactly one source, found multiple: %s",
-					formatPath(parentPath), strings.Join(addl.Properties, ", "))
-			}
-		}
-	}
-
 	return ""
 }
 
 // formatMockSourceMismatchError creates a helpful message for source/type mismatches.
 func formatMockSourceMismatchError(parentPath string, typeName string, invalidSources []string) string {
-	if len(invalidSources) == 0 {
-		return ""
-	}
-
 	source := invalidSources[0]
 
 	// Check if multiple sources
@@ -157,7 +121,7 @@ func formatMockSourceMismatchError(parentPath string, typeName string, invalidSo
 			formatPath(parentPath), strings.Join(invalidSources, ", "))
 	}
 
-	// type: one with array source (without filter - but we should have caught this above)
+	// type: one with array source without filter
 	if typeName == "one" && isArraySource(source) {
 		return fmt.Sprintf("at '%s': type 'one' with '%s' requires 'filter' to select a single row, or use object/object_js for a single object",
 			formatPath(parentPath), source)
@@ -169,13 +133,7 @@ func formatMockSourceMismatchError(parentPath string, typeName string, invalidSo
 			formatPath(parentPath), source)
 	}
 
-	// type: none with mock
-	if typeName == "none" {
-		return fmt.Sprintf("at '%s': type 'none' does not support mock - use 'sql' instead",
-			formatPath(parentPath))
-	}
-
-	// Generic message
+	// Generic message for other cases
 	return fmt.Sprintf("at '%s': invalid mock source '%s' for type '%s'",
 		formatPath(parentPath), source, typeName)
 }
@@ -235,22 +193,6 @@ func isTypeNone(errors []errorWithPath, parentPath string) bool {
 	return foundOne && foundMany
 }
 
-// findUsedArraySource finds which array source was used from error messages.
-func findUsedArraySource(errors []errorWithPath, mockPath string) string {
-	for _, e := range errors {
-		if e.path == mockPath {
-			if addl, ok := e.err.ErrorKind.(*kind.AdditionalProperties); ok {
-				for _, prop := range addl.Properties {
-					if isArraySource(prop) {
-						return prop
-					}
-				}
-			}
-		}
-	}
-	return ""
-}
-
 // isSqlMockOneOfError checks if the oneOf error is specifically about sql/mock.
 func isSqlMockOneOfError(err *jsonschema.ValidationError) bool {
 	if err == nil {