Received unexpected error when testing endpoints

[Geronaso]

Hello everyone, I am learning go and I have picked up echo to learn web develop with it, so please be patient with me. I have two questions I will separate them to make things easier

1. Testing errors:

So let me illustrate the scenario, I have a endpoint that store messages in the database and associate it to a user, when there is no user it returns to me:

echo.NewHTTPError(http.StatusBadRequest, "Database Error")

I am trying to write a test for this behavior, I tried following the documentation, but could not find a way to test it. I will paste my test here:

var postJson = `{"title":"Hello","message":"Good Morning!"}`

type postParam struct {
	status                      int
	response, payload, username string
}

var postParams = []postParam{
	{200, "Post Received", postJson, "Paulo"},
	{200, "Post Received", postJson, "Camila"},
	{400, "Database Error", postJson, "Camsasa"},  // A name that is not on the database
}

func TestPostUser(t *testing.T) {

	for _, value := range postParams {
		e := echo.New()
		e.Validator = &CustomValidator{validator: validator.New()}
		req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(value.payload))
		req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
		rec := httptest.NewRecorder()
		c := e.NewContext(req, rec)
		c.SetPath("/profile/:user")
		c.SetParamNames("user")
		c.SetParamValues(value.username)

		// Assertions
		if assert.NoError(t, handler.PostUser(c)) {
			assert.Equal(t, value.status, rec.Code)
			assert.Equal(t, value.response, rec.Body.String())
		}
	}
 }

The test pass on the first two iterations which is configured to return this on the code:
c.String(http.StatusOK, "Post Received")
but it always fails on the third iteration with the following error:

                Error:          Received unexpected error:
                                code=400, message=Database Error

I am pretty sure I am handing it the wrong way, since one is c.String and the other is echo.NewHTTPError. But I am not sure how to handle it.

2. Testing the key from a Body in POST request

This is another thing I am struggling, I wrote a validator per as documentation: https://echo.labstack.com/guide/request/#validate-data

However, I would like to give an error with the key value is incorrect in a POST request, for example:

curl -X POST http://localhost:1323/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Joe","email":"joe@invalid-domain", "nsada": "just some extra data that is not used"}'

This kind of request validate can not validate, since it binds the correct values to the struct.

To be honest, I am not sure while building an API I should give Bad Requests to this kind of extra information or just accept it.

These are my questions,
I thank you in advance for your time on answering them!

[aldas]

If you are testing handlers directly ala handler.PostUser(c) then you need to have IF block to check if result was an error and if it is - check it against expected error. You could use e.ServeHTTP(rec, req) to test whole flow including middlewares (if they are set)

type CustomValidator struct {
	validator *validator.Validate
}

func (cv *CustomValidator) Validate(i interface{}) error {
	if err := cv.validator.Struct(i); err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, err.Error())
	}
	return nil
}

type User struct {
	Name  string `json:"name" validate:"required"`
	Email string `json:"email" validate:"required,email"`
}

type handler struct {
}

func (h *handler) create(c echo.Context) error {
	u := new(User)

	if err := c.Bind(u); err != nil {
		return err
	}
	if err := c.Validate(u); err != nil {
		return err
	}
	return c.JSON(http.StatusOK, u)
}

func TestHandler_create1(t *testing.T) {
	var testCases = []struct {
		name         string
		whenURL      string
		whenBody     string
		expectBody   string
		expectStatus int
	}{
		{
			name:         "ok",
			whenURL:      "/123",
			whenBody:     `{"name":"John Doe","email":"jd@test.com"}`,
			expectStatus: http.StatusOK,
			expectBody:   "{\"name\":\"John Doe\",\"email\":\"jd@test.com\"}\n",
		},
		{
			name:         "nok",
			whenURL:      "/123",
			whenBody:     `{"name":"John Doe","email":"x"}`,
			expectStatus: http.StatusBadRequest,
			expectBody:   "{\"message\":\"Key: 'User.Email' Error:Field validation for 'Email' failed on the 'email' tag\"}\n",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			e := echo.New()
			e.Validator = &CustomValidator{validator: validator.New()}

			h := handler{}

			e.POST("/:uid", h.create)

			req := httptest.NewRequest(http.MethodPost, tc.whenURL, strings.NewReader(tc.whenBody))
			req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
			rec := httptest.NewRecorder()

			e.ServeHTTP(rec, req)

			assert.Equal(t, tc.expectStatus, rec.Code)
			assert.Equal(t, tc.expectBody, rec.Body.String())
		})
	}
}

func TestHandler_create2(t *testing.T) {
	var testCases = []struct {
		name         string
		whenURL      string
		whenBody     string
		expectBody   string
		expectStatus int
		expectError  error
	}{
		{
			name:         "ok",
			whenURL:      "/123",
			whenBody:     `{"name":"John Doe","email":"jd@test.com"}`,
			expectError:  nil,
			expectStatus: http.StatusOK,
			expectBody:   "{\"name\":\"John Doe\",\"email\":\"jd@test.com\"}\n",
		},
		{
			name:         "nok",
			whenURL:      "/123",
			whenBody:     `{"name":"John Doe","email":"x"}`,
			expectError:  echo.NewHTTPError(http.StatusBadRequest, "Key: 'User.Email' Error:Field validation for 'Email' failed on the 'email' tag"),
			expectStatus: http.StatusOK, // is also 200 because this is default code
			expectBody:   ``,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			e := echo.New()
			e.Validator = &CustomValidator{validator: validator.New()}

			req := httptest.NewRequest(http.MethodPost, tc.whenURL, strings.NewReader(tc.whenBody))
			req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
			rec := httptest.NewRecorder()
			c := e.NewContext(req, rec)

			h := handler{}
			err := h.create(c)

			if tc.expectError != nil {
				assert.EqualError(t, err, tc.expectError.Error())
			} else {
				assert.NoError(t, err)
			}
			assert.Equal(t, tc.expectBody, rec.Body.String())
			assert.Equal(t, tc.expectStatus, rec.Code)
		})
	}
}

[Geronaso]

Thank you for your answers, it worked. What I do not understand is why in the second test case you showed me, the status code is 200 and the expected body is empty.

[aldas]

This is because in case of error you return error object from handler, that error bubbles up in middleware chain and it is not handled in middleware, ends eventually in global error handler where it is "turned" into response and sent to the client. But in second example we call handler directly so there is nothing to turn to that error object into response.