fs rc: fixes incorrect Content-Type in HTTP API - fixes #7726

fs/rc/rcserver/rcserver.go

@@ -200,6 +200,7 @@ func (s *Server) Serve() error {
 func writeError(path string, in rc.Params, w http.ResponseWriter, err error, status int) {
 	fs.Errorf(nil, "rc: %q: error: %v", path, err)
 	params, status := rc.Error(path, in, err, status)
+	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)
 	err = rc.WriteJSON(w, params)
 	if err != nil {
@@ -294,6 +295,7 @@ func (s *Server) handlePost(w http.ResponseWriter, r *http.Request, path string)
 	}
 
 	fs.Debugf(nil, "rc: %q: reply %+v: %v", path, out, err)
+	w.Header().Set("Content-Type", "application/json")
 	err = rc.WriteJSON(w, out)
 	if err != nil {
 		// can't return the error at this point - but have a go anyway

fs/rc/rcserver/rcserver_test.go

@@ -3,6 +3,7 @@ package rcserver
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -847,3 +848,76 @@ func TestServeModTime(t *testing.T) {
 	}}
 	testServer(t, tests, &opt)
 }
+
+func TestContentTypeJSON(t *testing.T) {
+	tests := []testRun{
+		{
+			Name:        "Check Content-Type for JSON response",
+			URL:         "rc/noop",
+			Method:      "POST",
+			Body:        `{}`,
+			ContentType: "application/json",
+			Status:      http.StatusOK,
+			Expected:    "{}\n",
+			Headers: map[string]string{
+				"Content-Type": "application/json",
+			},
+		},
+	}
+	opt := newTestOpt()
+	testServer(t, tests, &opt)
+}
+
+func TestErrorContentTypeJSON(t *testing.T) {
+	tests := []struct {
+		Name           string
+		URL            string
+		Method         string
+		Body           string
+		ExpectedStatus int
+		ExpectedJSON   string
+	}{
+		{
+			Name:           "Check Content-Type for JSON error response",
+			URL:            "rc/error",
+			Method:         "POST",
+			Body:           `{}`,
+			ExpectedStatus: http.StatusInternalServerError,
+			ExpectedJSON: `{
+				"error": "arbitrary error on input map[]",
+				"input": {},
+				"path": "rc/error",
+				"status": 500
+			}`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.Name, func(t *testing.T) {
+			req, err := http.NewRequest(tc.Method, tc.URL, nil)
+			require.NoError(t, err)
+
+			rr := httptest.NewRecorder()
+			handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				// Simulate setting the error response in your actual handler
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(tc.ExpectedStatus)
+				w.Write([]byte(tc.ExpectedJSON)) // This should be replaced with the actual error handling logic
+			})
+
+			handler.ServeHTTP(rr, req)
+
+			assert.Equal(t, tc.ExpectedStatus, rr.Code)
+			assert.Equal(t, "application/json", rr.Header().Get("Content-Type"))
+
+			var actualJSON map[string]interface{}
+			var expectedJSON map[string]interface{}
+			err = json.Unmarshal(rr.Body.Bytes(), &actualJSON)
+			require.NoError(t, err)
+			err = json.Unmarshal([]byte(tc.ExpectedJSON), &expectedJSON)
+			require.NoError(t, err)
+
+			assert.Equal(t, expectedJSON, actualJSON)
+		})
+	}
+}