feat: add XML methods to context (#25)

Author: mojixcoder

context.go

@@ -80,17 +80,17 @@ func (c *Context) QueryParams() url.Values {
 
 // JSON sends JSON response with the given status code.
 //
-// Returns an error happenedd during sending response.
+// Returns an error if an error happened during sending response otherwise returns nil.
 func (c *Context) JSON(code int, obj any) error {
 	c.writeContentType("application/json")
 	c.response.WriteHeader(code)
 	return c.kid.jsonSerializer.Write(c.Response(), obj, "")
 }
 
 // JSONIndent sends JSON response with the given status code.
-// Creates response with the given indent.
+// Sends response with the given indent.
 //
-// Returns an error happenedd during sending response.
+// Returns an error if an error happened during sending response otherwise returns nil.
 func (c *Context) JSONIndent(code int, obj any, indent string) error {
 	c.writeContentType("application/json")
 	c.response.WriteHeader(code)
@@ -112,12 +112,47 @@ func (c *Context) ReadJSON(out any) error {
 	return c.kid.jsonSerializer.Read(c.Request(), out)
 }
 
+// XML sends XML response with the given status code.
+//
+// Returns an error if an error happened during sending response otherwise returns nil.
+func (c *Context) XML(code int, obj any) error {
+	c.writeContentType("application/xml")
+	c.response.WriteHeader(code)
+	return c.kid.xmlSerializer.Write(c.Response(), obj, "")
+}
+
+// XMLIndent sends XML response with the given status code.
+// Sends response with the given indent.
+//
+// Returns an error if an error happened during sending response otherwise returns nil.
+func (c *Context) XMLIndent(code int, obj any, indent string) error {
+	c.writeContentType("application/xml")
+	c.response.WriteHeader(code)
+	return c.kid.xmlSerializer.Write(c.Response(), obj, indent)
+}
+
+// XMLByte sends XML response with the given status code.
+// Writes JSON blob untouched to response.
+func (c *Context) XMLByte(code int, blob []byte) error {
+	c.writeContentType("application/xml")
+	c.response.WriteHeader(code)
+	_, err := c.Response().Write(blob)
+	return err
+}
+
+// ReadXML reads request's body as XML and stores it in the given object.
+// The object must be a pointer.
+func (c *Context) ReadXML(out any) error {
+	return c.kid.xmlSerializer.Read(c.Request(), out)
+}
+
 // NoContent returns an empty response with the given status code.
 func (c *Context) NoContent(code int) {
 	c.response.WriteHeader(code)
 }
 
-// writeContentType sets content type of response.
+// writeContentType sets content type header for response.
+// It won't overwrite content type if it's already set.
 func (c *Context) writeContentType(contentType string) {
 	contentTypeHeader := "Content-Type"
 	header := c.response.Header()

context_test.go

@@ -2,6 +2,7 @@ package kid
 
 import (
 	"encoding/json"
+	"encoding/xml"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@@ -247,6 +248,7 @@ func TestContextJSON(t *testing.T) {
 	err := ctx.JSON(http.StatusCreated, &p)
 
 	assert.NoError(t, err)
+	assert.Equal(t, http.StatusCreated, res.Code)
 	assert.Equal(t, "application/json", res.Header().Get("Content-Type"))
 	assert.Equal(t, "{\"name\":\"foo\",\"age\":1999}\n", res.Body.String())
 
@@ -272,6 +274,7 @@ func TestContextJSONIndent(t *testing.T) {
 	err := ctx.JSONIndent(http.StatusCreated, &p, "    ")
 
 	assert.NoError(t, err)
+	assert.Equal(t, http.StatusCreated, res.Code)
 	assert.Equal(t, "application/json", res.Header().Get("Content-Type"))
 	assert.Equal(t, "{\n    \"name\": \"foo\",\n    \"age\": 1999\n}\n", res.Body.String())
 
@@ -301,6 +304,104 @@ func TestContextJSONByte(t *testing.T) {
 	err = ctx.JSONByte(http.StatusOK, blob)
 
 	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, res.Code)
 	assert.Equal(t, "application/json", res.Header().Get("Content-Type"))
 	assert.Equal(t, "{\"name\":\"foo\",\"age\":1999}", res.Body.String())
 }
+
+func TestContextReadXML(t *testing.T) {
+	ctx := newContext(New())
+
+	req := httptest.NewRequest(http.MethodGet, "/", strings.NewReader("<person><name>Mojix</name><age>22</age></person>"))
+
+	ctx.reset(req, nil)
+
+	var p person
+	err := ctx.ReadXML(&p)
+	assert.NoError(t, err)
+
+	assert.Equal(t, person{Name: "Mojix", Age: 22}, p)
+
+	req = httptest.NewRequest(http.MethodGet, "/", strings.NewReader("<person><name>Mojix</name><age>22</age></person"))
+
+	ctx.reset(req, nil)
+
+	var p2 person
+	httpErr := ctx.ReadXML(&p2).(*errors.HTTPError)
+
+	assert.Error(t, httpErr)
+	assert.Error(t, httpErr.Err)
+	assert.Equal(t, http.StatusBadRequest, httpErr.Code)
+}
+
+func TestContextXML(t *testing.T) {
+	ctx := newContext(New())
+
+	res := httptest.NewRecorder()
+
+	ctx.reset(nil, res)
+
+	p := person{Name: "foo", Age: 1999}
+	err := ctx.XML(http.StatusCreated, &p)
+
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusCreated, res.Code)
+	assert.Equal(t, "application/xml", res.Header().Get("Content-Type"))
+	assert.Equal(t, "<person><name>foo</name><age>1999</age></person>", res.Body.String())
+
+	res = httptest.NewRecorder()
+
+	ctx.reset(nil, res)
+
+	httpErr := ctx.XML(http.StatusCreated, make(chan bool)).(*errors.HTTPError)
+
+	assert.Error(t, httpErr)
+	assert.Error(t, httpErr.Err)
+	assert.Equal(t, http.StatusInternalServerError, httpErr.Code)
+}
+
+func TestContextXMLIndent(t *testing.T) {
+	ctx := newContext(New())
+
+	res := httptest.NewRecorder()
+
+	ctx.reset(nil, res)
+
+	p := person{Name: "foo", Age: 1999}
+	err := ctx.XMLIndent(http.StatusCreated, &p, "    ")
+
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusCreated, res.Code)
+	assert.Equal(t, "application/xml", res.Header().Get("Content-Type"))
+	assert.Equal(t, "<person>\n    <name>foo</name>\n    <age>1999</age>\n</person>", res.Body.String())
+
+	res = httptest.NewRecorder()
+
+	ctx.reset(nil, res)
+
+	httpErr := ctx.XMLIndent(http.StatusCreated, make(chan bool), "    ").(*errors.HTTPError)
+
+	assert.Error(t, httpErr)
+	assert.Error(t, httpErr.Err)
+	assert.Equal(t, http.StatusInternalServerError, httpErr.Code)
+}
+
+func TestContextXMLByte(t *testing.T) {
+	ctx := newContext(New())
+
+	res := httptest.NewRecorder()
+
+	ctx.reset(nil, res)
+
+	p := person{Name: "foo", Age: 1999}
+
+	blob, err := xml.Marshal(p)
+	assert.NoError(t, err)
+
+	err = ctx.XMLByte(http.StatusOK, blob)
+
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, res.Code)
+	assert.Equal(t, "application/xml", res.Header().Get("Content-Type"))
+	assert.Equal(t, "<person><name>foo</name><age>1999</age></person>", res.Body.String())
+}

kid.go

@@ -30,6 +30,7 @@ type (
 		methodNotAllowedHandler HandlerFunc
 		errorHandler            ErrorHandler
 		jsonSerializer          serializer.Serializer
+		xmlSerializer           serializer.Serializer
 		pool                    sync.Pool
 	}
 )
@@ -43,6 +44,7 @@ func New() *Kid {
 		methodNotAllowedHandler: defaultMethodNotAllowedHandler,
 		errorHandler:            defaultErrorHandler,
 		jsonSerializer:          serializer.NewJSONSerializer(),
+		xmlSerializer:           serializer.NewXMLSerializer(),
 	}
 
 	kid.pool.New = func() any {

kid_test.go

@@ -18,6 +18,7 @@ func TestNew(t *testing.T) {
 	assert.Equal(t, newRouter(), k.router)
 	assert.Equal(t, 0, len(k.middlewares))
 	assert.Equal(t, serializer.NewJSONSerializer(), k.jsonSerializer)
+	assert.Equal(t, serializer.NewXMLSerializer(), k.xmlSerializer)
 	assert.True(t, funcsAreEqual(defaultErrorHandler, k.errorHandler))
 	assert.True(t, funcsAreEqual(defaultNotFoundHandler, k.notFoundHandler))
 	assert.True(t, funcsAreEqual(defaultMethodNotAllowedHandler, k.methodNotAllowedHandler))