Added lots of httprequest and response

Author: djthorpe

pkg/httprequest/body.go

@@ -0,0 +1,133 @@
+package httprequest
+
+import (
+	"encoding/json"
+	"io"
+	"mime"
+	"mime/multipart"
+	"net/http"
+	"reflect"
+	"slices"
+	"strings"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	ContentTypeJson           = "application/json"
+	ContentTypeTextXml        = "text/xml"
+	ContentTypeApplicationXml = "application/xml"
+	ContentTypeText           = "text/"
+	ContentTypeBinary         = "application/octet-stream"
+	ContentTypeFormData       = "multipart/form-data"
+	ContentTypeUrlEncoded     = "application/x-www-form-urlencoded"
+)
+
+const (
+	maxMemory = 10 << 20 // 10 MB in-memory cache for multipart form
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Body reads the body of an HTTP request and decodes it into v.
+// You can include the mimetypes that are acceptable, otherwise it will read
+// the body based on the content type. If does not close the body of the
+// request, which should be done by the caller.
+// v can be a io.Writer, in which case the body is copied into it.
+// v can be a struct, in which case the body is decoded into it.
+func Body(v any, r *http.Request, accept ...string) error {
+	// Parse the content type
+	contentType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if err != nil {
+		return err
+	} else {
+		contentType = strings.ToLower(contentType)
+	}
+
+	// Check whether we'll accept it
+	if len(accept) > 0 && !slices.Contains(accept, contentType) {
+		return ErrBadParameter.Withf("unexpected content type %q", contentType)
+	}
+
+	// If v is an io.Writer, then copy the body into it
+	if v, ok := v.(io.Writer); ok {
+		if _, err := io.Copy(v, r.Body); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	// Read the body - we can read JSON, form data or url encoded data
+	// TODO: We should also be able to read XML
+	switch {
+	case contentType == ContentTypeJson:
+		return readJson(v, r)
+	case contentType == ContentTypeFormData:
+		return readFormData(v, r)
+	case contentType == ContentTypeUrlEncoded:
+		return readForm(v, r)
+	case strings.HasPrefix(contentType, ContentTypeText):
+		return readText(v, r)
+	}
+
+	// Report error
+	return ErrBadParameter.Withf("unsupported content type %q", contentType)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func readJson(v any, r *http.Request) error {
+	return json.NewDecoder(r.Body).Decode(v)
+}
+
+func readForm(v any, r *http.Request) error {
+	if err := r.ParseForm(); err != nil {
+		return err
+	} else {
+		return Query(v, r.Form)
+	}
+}
+
+func readFormData(v any, r *http.Request) error {
+	if err := r.ParseMultipartForm(maxMemory); err != nil {
+		return err
+	} else if err := readFiles(v, r.MultipartForm.File); err != nil {
+		return err
+	} else {
+		return Query(v, r.MultipartForm.Value)
+	}
+}
+
+func readFiles(v any, files map[string][]*multipart.FileHeader) error {
+	return mapFields(v, func(key string, value reflect.Value) error {
+		src, exists := files[key]
+		if !exists || len(src) == 0 {
+			setZeroValue(value)
+			return nil
+		}
+		// Set a *multipart.FileHeader or []*multipart.FileHeader with the source
+		return setFile(value, src)
+	})
+}
+
+func readText(v any, r *http.Request) error {
+	switch v := v.(type) {
+	case *string:
+		data, err := io.ReadAll(r.Body)
+		if err != nil {
+			return err
+		}
+		*v = string(data)
+	default:
+		return ErrBadParameter.Withf("unsupported type: %T", v)
+	}
+
+	// Return success
+	return nil
+}

pkg/httprequest/body_test.go

@@ -0,0 +1,139 @@
+package httprequest_test
+
+import (
+	"bytes"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+	"testing"
+
+	"github.com/mutablelogic/go-server/pkg/httprequest"
+	"github.com/mutablelogic/go-server/pkg/httpresponse"
+	"github.com/stretchr/testify/assert"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+func Test_body_00(t *testing.T) {
+	assert := assert.New(t)
+
+	t.Run("EOF", func(t *testing.T) {
+		// We should receive an EOF error here - no body
+		req := httptest.NewRequest("GET", "/", nil)
+		req.Header.Set("Content-Type", "application/json")
+		err := httprequest.Body(nil, req)
+		assert.ErrorIs(err, io.EOF)
+	})
+
+	t.Run("ContentType1", func(t *testing.T) {
+		// We should receive a badparameter error - invalid content type
+		req := httptest.NewRequest("GET", "/", nil)
+		req.Header.Set("Content-Type", "application/test")
+		err := httprequest.Body(nil, req)
+		assert.ErrorIs(err, ErrBadParameter)
+	})
+
+	t.Run("ContentType2", func(t *testing.T) {
+		// We should receive a badparameter error - invalid content type
+		req := httptest.NewRequest("GET", "/", nil)
+		req.Header.Set("Content-Type", "text/plain")
+		err := httprequest.Body(nil, req, httpresponse.ContentTypeJSON)
+		assert.ErrorIs(err, ErrBadParameter)
+	})
+
+	t.Run("Writer", func(t *testing.T) {
+		var in, out bytes.Buffer
+		in.WriteString("Hello, World!")
+
+		// We should receive the text
+		req := httptest.NewRequest("GET", "/", &in)
+		req.Header.Set("Content-Type", "text/plain")
+		err := httprequest.Body(&out, req)
+		assert.NoError(err)
+		assert.Equal("Hello, World!", out.String())
+	})
+
+	t.Run("Text", func(t *testing.T) {
+		var in bytes.Buffer
+		var out string
+		in.WriteString("Hello, World!")
+
+		// We should receive the text
+		req := httptest.NewRequest("GET", "/", &in)
+		req.Header.Set("Content-Type", "text/plain")
+		err := httprequest.Body(&out, req)
+		assert.NoError(err)
+		assert.Equal("Hello, World!", out)
+	})
+
+	t.Run("JSON", func(t *testing.T) {
+		var in bytes.Buffer
+		var out string
+		in.WriteString(strconv.Quote("Hello, World!"))
+
+		// We should receive the JSON and decode it
+		req := httptest.NewRequest("GET", "/", &in)
+		req.Header.Set("Content-Type", "application/json")
+		err := httprequest.Body(&out, req)
+		assert.NoError(err)
+		assert.Equal("Hello, World!", out)
+	})
+
+	t.Run("Form", func(t *testing.T) {
+		values := url.Values{
+			"key1": []string{"Hello, World!"},
+		}
+		var in bytes.Buffer
+		var out struct {
+			Key1 string `json:"key1"`
+		}
+		in.WriteString(values.Encode())
+
+		// POST form data
+		req := httptest.NewRequest("POST", "/", &in)
+		req.Header.Set("Content-Type", httprequest.ContentTypeUrlEncoded)
+		err := httprequest.Body(&out, req)
+		assert.NoError(err)
+		assert.Equal("Hello, World!", out.Key1)
+	})
+
+	t.Run("File", func(t *testing.T) {
+		var in bytes.Buffer
+		var out struct {
+			File *multipart.FileHeader `json:"file"`
+		}
+
+		// instantiate multipart request
+		multipartWriter := multipart.NewWriter(&in)
+
+		// add form field
+		filePart, _ := multipartWriter.CreateFormFile("file", "file.txt")
+		filePart.Write([]byte("Hello, World!"))
+
+		// Close the body - so it can be read
+		multipartWriter.Close()
+
+		// Create the request
+		req := httptest.NewRequest(http.MethodPost, "/file", &in)
+		req.Header.Set("Content-Type", multipartWriter.FormDataContentType())
+
+		// Parse the request body
+		err := httprequest.Body(&out, req)
+		assert.NoError(err)
+		assert.NotNil(out.File)
+
+		// Let's read the contents of the file
+		file, err := out.File.Open()
+		assert.NoError(err)
+		defer file.Close()
+
+		// Read the contents of the file
+		data, err := io.ReadAll(file)
+		assert.NoError(err)
+		assert.Equal("Hello, World!", string(data))
+	})
+}