 RESTful API - Route Handlers and Middleware (Part 2)

 - If you are unfamiliar with writing a simple unit test for a route handler of a Go and 

 library package provides many utilities for automating the testing of Go code. To write robust tests for Go code, you must already understand how to write a basic Go test suite that contains several 

Writing tests for code, especially within the context of test-driven development (TDD), prioritizes the code's correctness over the code's flexibility to adapt to new/updated requirements. The guarantee of less unexpected regressions offsets the upfront cost of spending more time to write tests alongside application code. In a fast-paced, high-pressure environment, it can be difficult to convince other team members and stakeholders of the value in testing code when time is an extremely limited resource. 

Another factor that must be considered is the amount of code covered by the tests. If the tests cover only a small percentage of the application code (or a small subset of use cases), then the benefits of having these tests probably won't outweigh the benefits of adding new features or improving existing features. Plus, anytime you decide to refactor the application code, you will also have to update the corresponding tests to reflect these changes. When time is so valuable, the time spent on writing tests could have been spent elsewhere. Therefore, to fully benefit from tests, you must write enough tests such that they cover a large percentage of the application code.

If a RESTful API exposes multiple endpoints, then testing a single route handler won't bring much value for the time spent writing it. Testing RESTful APIs built with Go and 

 requires testing not only all of the route handlers, but also, the 

 RESTful API (with a basic test for a single endpoint) from GitHub to you machine:

git clone --branch basic-tests https://github.com/newline-sandbox/go-chi-restful-api/tree/basic-tests

This RESTful API specifies five endpoints for performing operations on posts:

If you would like to learn how to build this RESTful API, then please visit this 

Run the following command to install the project's dependencies:

: If you run into installation issues, then verify that the version of Go running on your machine is 

 function called by the route handler to avoid sending a network request to the 

 requests, testing route handlers for other HTTP methods (e.g., 

) involves slightly more code to test requests that carry data in the form of an optional request body:

Before starting, we must first review the route handler for this endpoint (

// ...

func (*JsonPlaceholder) CreatePost(body io.ReadCloser) (*http.Response, error) {
  resp, err := http.Post("https://jsonplaceholder.typicode.com/posts", "application/json", body)

  if err != nil {
    return &http.Response{
      Body: ioutil.NopCloser(bytes.NewBuffer(nil)),
    }, err
  }

  return resp, err
}

// ...

func (rs PostsResource) Create(w http.ResponseWriter, r *http.Request) {
  resp, err := CreatePost(r.Body)

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }

  defer resp.Body.Close()

  w.Header().Set("Content-Type", "application/json")

  if _, err := io.Copy(w, resp.Body); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }
}

 function to avoid sending a network request to the JSONPlaceholder API when executing tests. 

 accepts a request body and returns an HTTP response and error (if encountered). Therefore, the mock function must follow the same function signature as 

func (*JsonPlaceholderMock) CreatePost(body io.ReadCloser) (*http.Response, error) {
  // ...
}

The request body must contain the following information:

Since this request body (JSON data) must be passed as type 

, it must be read into a buffer, converted into a byte slice and then decoded into a Go struct so the data can be accessed normally.

func (*JsonPlaceholderMock) CreatePost(body io.ReadCloser) (*http.Response, error) {
  buffer := new(bytes.Buffer)
  buffer.ReadFrom(body)
  bodyBytes := buffer.Bytes()

  var reqPost PostWithoutId

  if err := json.Unmarshal(bodyBytes, &reqPost); err != nil {
    log.Panicf("Error reading mocked data: %v", err)
  }

  // ...
}

 request is sent to the JSONPlaceholder API, it returns a response that contains the newly created post. This post contains the exact same information as the request body with an additional 

 to imply that a new post was added since there is a total of 

. The JSONPlaceholder API doesn't actually create this new resource, but rather, fakes it. So anytime you send a request to 

, the response returned will have a newly created post with an 

. In our mock function, let's create this dummy data to send back in the response.

func (*JsonPlaceholderMock) CreatePost(body io.ReadCloser) (*http.Response, error) {
  // ...

  newPost := Post{
    Id: 101,
    UserId: reqPost.UserId,
    Title: reqPost.Title,
    Body: reqPost.Body,
  }

  // ...
}

 method and return it within the body of a HTTP response. This HTTP response should return with a 

 status code to indicate a successful request. 

func (*JsonPlaceholderMock) CreatePost(body io.ReadCloser) (*http.Response, error) {
  // ...

  respBody, err := json.Marshal(newPost)

  if err != nil {
    log.Panicf("Error reading mocked data: %v", err)
  }

  return &http.Response{
    StatusCode: http.StatusOK,
    Body: ioutil.NopCloser(bytes.NewBuffer(respBody)),
  }, nil
}

: This HTTP response returned must adhere to the 

, which accepts an integer value for its 

func (*JsonPlaceholderMock) CreatePost(body io.ReadCloser) (*http.Response, error) {
  buffer := new(bytes.Buffer)
  buffer.ReadFrom(body)
  bodyBytes := buffer.Bytes()

  var reqPost PostWithoutId

  if err := json.Unmarshal(bodyBytes, &reqPost); err != nil {
    log.Panicf("Error reading mocked data: %v", err)
  }

  newPost := Post{
    Id: 101,
    UserId: reqPost.UserId,
    Title: reqPost.Title,
    Body: reqPost.Body,
  }

  respBody, err := json.Marshal(newPost)

  if err != nil {
    log.Panicf("Error reading mocked data: %v", err)
  }

  return &http.Response{
    StatusCode: http.StatusOK,
    Body: ioutil.NopCloser(bytes.NewBuffer(respBody)),
  }, nil
}

With the mock function now implemented, let's write the test for the route handler 

func TestCreatePostHandler(t *testing.T) {
  // ...
}

 test, but with several adjustments to account for it testing a 

GetPosts = (&JsonPlaceholderMock{}).GetPosts

postWithoutId := PostWithoutId{
  UserId: 2,
  Title: "Hello World",
  Body: "Foo Bar",
}

reqBody, err := json.Marshal(postWithoutId)

if err != nil {
  log.Panicf("Error reading mocked request data: %v", err)
}

req, err := http.NewRequest("POST", "/posts", bytes.NewBuffer(reqBody))

if err != nil {
  t.Errorf("Error creating a new request: %v", err)
}

req.Header.Set("Content-Type", "application/json")

rr := httptest.NewRecorder()
handler := http.HandlerFunc(PostsResource{}.Create)
handler.ServeHTTP(rr, req)

if status := rr.Code; status != http.StatusOK {
  t.Errorf("Handler returned wrong status code. Expected: %d. Got: %d.", http.StatusOK, status)
}

var post Post

if err := json.NewDecoder(rr.Body).Decode(&post); err != nil {
  t.Errorf("Error decoding response body: %v", err)
}

resultId := post.Id
expectedId := 101

if resultId != expectedId {
  t.Errorf("Expected: %d. Got: %d.", expectedId, resultId)
}

// ...

func (*JsonPlaceholderMock) CreatePost(body io.ReadCloser) (*http.Response, error) {
  buffer := new(bytes.Buffer)
  buffer.ReadFrom(body)
  bodyBytes := buffer.Bytes()

  var reqPost PostWithoutId

  if err := json.Unmarshal(bodyBytes, &reqPost); err != nil {
    log.Panicf("Error reading mocked data: %v", err)
  }

  newPost := Post{
    Id: 101,
    UserId: reqPost.UserId,
    Title: reqPost.Title,
    Body: reqPost.Body,
  }

  respBody, err := json.Marshal(newPost)

  if err != nil {
    log.Panicf("Error reading mocked data: %v", err)
  }

  return &http.Response{
    StatusCode: http.StatusOK,
    Body: ioutil.NopCloser(bytes.NewBuffer(respBody)),
  }, nil
}

// ...

func TestCreatePostHandler(t *testing.T) {
  CreatePost = (&JsonPlaceholderMock{}).CreatePost

  postWithoutId := PostWithoutId{
    UserId: 2,
    Title: "Hello World",
    Body: "Foo Bar",
  }

  reqBody, err := json.Marshal(postWithoutId)

  if err != nil {
    log.Panicf("Error reading mocked request data: %v", err)
  }

  req, err := http.NewRequest("POST", "/posts", bytes.NewBuffer(reqBody))

  if err != nil {
    t.Errorf("Error creating a new request: %v", err)
  }

  req.Header.Set("Content-Type", "application/json")

  rr := httptest.NewRecorder()
  handler := http.HandlerFunc(PostsResource{}.Create)
  handler.ServeHTTP(rr, req)

  if status := rr.Code; status != http.StatusOK {
    t.Errorf("Handler returned wrong status code. Expected: %d. Got: %d.", http.StatusOK, status)
  }

  var post Post

  if err := json.NewDecoder(rr.Body).Decode(&post); err != nil {
    t.Errorf("Error decoding response body: %v", err)
  }

  resultId := post.Id
  expectedId := 101

  if resultId != expectedId {
    t.Errorf("Expected: %d. Got: %d.", expectedId, resultId)
  }
}

), we must first understand the implementation details of this handler function:

func Logger(next http.Handler) http.Handler {
  return DefaultLogger(next)
}

 function only calls a package-scoped function, 

, which logs information for each incoming request.

var (
  LogEntryCtxKey = &contextKey{"LogEntry"}
  DefaultLogger func(next http.Handler) http.Handler
)

This package-scoped function accepts a handler function and returns a handler function. Therefore, we can write a test that involves passing a simple route handler to 

 method with a response recorder and created request:

func TestRequestLogger(t *testing.T) {
  testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("[]"))
  })

  req := httptest.NewRequest("GET", "/posts", nil)
  rr := httptest.NewRecorder()

  handler := middleware.DefaultLogger(testHandler)
  handler.ServeHTTP(rr, req)
}

Try adding more endpoints and writing tests for those endpoints' route handlers.

AUTHOR

Ken Chan

Disclaimer - If you are unfamiliar with writing a simple unit test for a route handler of a Go and chi RESTful API, then please read this blog post before proceeding on. Go's testing library package provides many utilities for automating the testing of Go code. To write robust tests for Go code,…

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Free Tools

Testing a Go and chi RESTful API - Route Handlers and Middleware (Part 2)

Tags

Responses (0)

Free AI Career Tools

AI Job Listings

ATS Resume Checker

Startup Perks

Masterclasses

Tutorials

Fullstack React with TypeScript