Testing

Testing Handler

GET /users/:id

Handler below retrieves user by id from the database. If user is not found it returns404 error with a message.

CreateUser

POST /users

  • Accepts JSON payload
  • On success 201 - Created
  • On error 500 - Internal Server Error

GetUser

GET /users/:email

  • On success 200 - OK
  • On error 404 - Not Found if user is not found otherwise 500 - Internal Server Error

handler.go

  1. package handler
  3. import (
  4.     "net/http"
  6.     "github.com/labstack/echo"
  7. )
  9. type (
  10.     User struct {
  11.         Name  string `json:"name" form:"name"`
  12.         Email string `json:"email" form:"email"`
  13.     }
  14.     handler struct {
  15.         db map[string]*User
  16.     }
  17. )
  19. func (h *handler) createUser(c echo.Context) error {
  20.     u := new(User)
  21.     if err := c.Bind(u); err != nil {
  22.         return err
  23.     }
  24.     return c.JSON(http.StatusCreated, u)
  25. }
  27. func (h *handler) getUser(c echo.Context) error {
  28.     email := c.Param("email")
  29.     user := h.db[email]
  30.     if user == nil {
  31.         return echo.NewHTTPError(http.StatusNotFound, "user not found")
  32.     }
  33.     return c.JSON(http.StatusOK, user)
  34. }

handler_test.go

  1. package handler
  3. import (
  4.     "net/http"
  5.     "net/http/httptest"
  6.     "strings"
  7.     "testing"
  9.     "github.com/labstack/echo"
  10.     "github.com/stretchr/testify/assert"
  11. )
  13. var (
  14.     mockDB = map[string]*User{
  15.         "[email protected]": &User{"Jon Snow", "[email protected]"},
  16.     }
  17.     userJSON = `{"name":"Jon Snow","email":"[email protected]"}`
  18. )
  20. func TestCreateUser(t *testing.T) {
  21.     // Setup
  22.     e := echo.New()
  23.     req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(userJSON))
  24.     req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
  25.     rec := httptest.NewRecorder()
  26.     c := e.NewContext(req, rec)
  27.     h := &handler{mockDB}
  29.     // Assertions
  30.     if assert.NoError(t, h.createUser(c)) {
  31.         assert.Equal(t, http.StatusCreated, rec.Code)
  32.         assert.Equal(t, userJSON, rec.Body.String())
  33.     }
  34. }
  36. func TestGetUser(t *testing.T) {
  37.     // Setup
  38.     e := echo.New()
  39.     req := httptest.NewRequest(http.MethodGet, "/", nil)
  40.     rec := httptest.NewRecorder()
  41.     c := e.NewContext(req, rec)
  42.     c.SetPath("/users/:email")
  43.     c.SetParamNames("email")
  44.     c.SetParamValues("[email protected]")
  45.     h := &handler{mockDB}
  47.     // Assertions
  48.     if assert.NoError(t, h.getUser(c)) {
  49.         assert.Equal(t, http.StatusOK, rec.Code)
  50.         assert.Equal(t, userJSON, rec.Body.String())
  51.     }
  52. }

Using Form Payload

  1. f := make(url.Values)
  2. f.Set("name", "Jon Snow")
  3. f.Set("email", "[email protected]")
  4. req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(f.Encode()))
  5. req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationForm)

Setting Path Params

  1. c.SetParamNames("id", "email")
  2. c.SetParamValues("1", "[email protected]")

Setting Query Params

  1. q := make(url.Values)
  2. q.Set("email", "[email protected]")
  3. req := httptest.NewRequest(http.MethodPost, "/?"+q.Encode(), nil)

Testing Middleware

TBD

For now you can look into built-in middleware test cases.