Go simple http handler testing all paths

I'm trying to get a 100% code coverage on this simple http handler file.

The file writes the default response headers if successful and then returns 200 with "Pong" which I've tested below. However, there is also a possibility that writing the default headers will generate an error in which case a 500 response with Internal Error body is expected.

I'm struggling to figure out how to trigger the 500 response case in a test. The case would fail if for some reason the writeDefaultHeaders function call's 2nd parameter was changed to "html" for example as html is not a supported response content type in my service.

What is the idiomatic way to mock this call / hit this error branch in the code?

Thanks.

ping_handler_test.go

package main

import (
	"net/http"
	"net/http/httptest"
	"testing"
)

func Test200PingHandler(t *testing.T) {
	req, _ := http.NewRequest("GET", "/ping", nil)
	w := httptest.NewRecorder()

	PingHandler(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("Ping Handler Status Code is NOT 200; got %v", w.Code)
	}

	if w.Body.String() != "Pong" {
		t.Errorf("Ping Handler Response Body is NOT Pong; got %v", w.Body.String())
	}
}

// This fails as it is the same setup as the passing success case
func Test500PingHandler(t *testing.T) {
	req, _ := http.NewRequest("GET", "/ping", nil)
	w := httptest.NewRecorder()

	PingHandler(w, req)

	if w.Code != http.StatusInternalServerError {
		t.Errorf("Ping Handler Status Code is NOT 500; got %v", w.Code)
	}

	if w.Body.String() != "Internal Server Error" {
		t.Errorf("Ping Handler Response Body is NOT Internal Server Error; got %v", w.Body.String())
	}
}

func BenchmarkPingHandler(b *testing.B) {
	for i := 0; i < b.N; i++ {
		req, _ := http.NewRequest("GET", "/ping", nil)
		w := httptest.NewRecorder()

		PingHandler(w, req)
	}
}

ping_handler.go

package main

import (
	"fmt"
	"net/http"
)

func PingHandler(w http.ResponseWriter, r *http.Request) {
	err := writeDefaultHeaders(w, "text")
	if err != nil {
		handleException(w, err)
		return
	}

	fmt.Fprintf(w, "Pong")
}

func writeDefaultHeaders(w http.ResponseWriter, contentType string) error {
	w.Header().Set("X-Frame-Options", "DENY")
	w.Header().Set("X-Content-Type-Options", "nosniff")
	w.Header().Set("X-XSS-Protection", "1;mode=block")

	switch contentType {
	case "text":
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		return nil
	case "json":
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		return nil
	default:
		return errors.New("Attempting to render an unknown content type")
	}
}

Edit
Another Example:

json_response, err := json.Marshal(response)
if err != nil {
	handleException(w, err)
	return
}

In this case, how do I test json.Marshal returning an error?

> What is the idiomatic way to mock this call / hit this error branch in the code?

Usually for testing you want to use a public interface and either supply an implementation to your code (NewMyThing(hw HeaderWriter)) or use some other mechanism (like a DefaultHeaderWriter which you can swap out in your test).

Since this code is private you can just use a variable though:

var writeDefaultHeaders = func(w http.ResponseWriter, contentType string) error {
	w.Header().Set("X-Frame-Options", "DENY")
	w.Header().Set("X-Content-Type-Options", "nosniff")
	w.Header().Set("X-XSS-Protection", "1;mode=block")

	switch contentType {
	case "text":
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		return nil
	case "json":
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		return nil
	default:
		return errors.New("Attempting to render an unknown content type")
	}
}

func PingHandler(w http.ResponseWriter, r *http.Request) {
	err := writeDefaultHeaders(w, "text")
	if err != nil {
		handleException(w, err)
		return
	}

	fmt.Fprintf(w, "Pong")
}

And then swap it out in your test:

func Test500PingHandler(t *testing.T) {
	writeDefaultHeaders = headerWriterFunc(func(w http.ResponseWriter, contentType string) error {
		return fmt.Errorf("ERROR")
	})
    // ...
}

You probably want to set it back when you're done.

In my opinion swapping out a single function like this is not good testing practice. Tests should be against the public API so you can tinker with your code without having to rewrite your tests every time you make a single change.

Interface example:

type Marshaler interface {
	Marshal(v interface{}) ([]byte, error)
}

type jsonMarshaler struct{}

func (_ *jsonMarshaler) Marshal(v interface{}) ([]byte, error) {
	return json.Marshal(v)
}

var marshaler Marshaler = (*jsonMarshaler)(nil)

And then:

json_response, err := marshaler.Marshal(response)

Unless I am missing something the way to get an error is to remove the hardcoded "text" and have whatever you're passing as contentType be something in the request. Parse it out of the request and then pass it on to writeDefaultHeaders. Passing case is either "text" or "json", everything else should give you your error, assuming handleException works as expected (you haven't shown it)

Example (of course you don't want the "Content-Type" header to look like this)

package main
import (
"net/http"
"net/http/httptest"
"testing"
)
func Test200PingHandler(t *testing.T) {
req, _ := http.NewRequest("GET", "/ping", nil)
req.Header().Set("Content-Type", "text")
//req.Header().Set("Content-Type", "json")
w := httptest.NewRecorder()
PingHandler(w, req)
if w.Code != http.StatusOK {
t.Errorf("Ping Handler Status Code is NOT 200; got %v", w.Code)
}
if w.Body.String() != "Pong" {
t.Errorf("Ping Handler Response Body is NOT Pong; got %v", w.Body.String())
}
}
// This fails as it is the same setup as the passing success case
func Test500PingHandler(t *testing.T) {
req, _ := http.NewRequest("GET", "/ping", nil)
req.Header().Set("Content-Type", "fail")
w := httptest.NewRecorder()
PingHandler(w, req)
if w.Code != http.StatusInternalServerError {
t.Errorf("Ping Handler Status Code is NOT 500; got %v", w.Code)
}
if w.Body.String() != "Internal Server Error" {
t.Errorf("Ping Handler Response Body is NOT Internal Server Error; got %v", w.Body.String())
}
}

main

package main
import (
"fmt"
"net/http"
)
func PingHandler(w http.ResponseWriter, r *http.Request) {
err := writeDefaultHeaders(w, req.Header().Get("Content-Type"))
if err != nil {
handleException(w, err)
return
}
fmt.Fprintf(w, "Pong")
}
func writeDefaultHeaders(w http.ResponseWriter, contentType string) error {
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("X-XSS-Protection", "1;mode=block")
switch contentType {
case "text":
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
return nil
case "json":
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
return nil
default:
return errors.New("Attempting to render an unknown content type")
}
}

As you have written it, this code will never be reached in PingHandler:

if err != nil {
handleException(w, err)
return
}

because the only place you return error is when writeDefaultHeaders is passed something other than text or json, and in PingHandler you hard-code "text", so ping handler will never call handleException, and the error handling is redundant. There is no other place you might return error in writeDefaultHeaders.

If you wish to test handleException, to see it returns a 500 error correctly (which is what you are asserting/testing in Test500PingHandler), just construct a PingHandlerFail function in the test file which sets an incorrect responseType and use that - there is no other way to trigger your error code.

func PingHandlerFail(w http.ResponseWriter, r *http.Request) {
err := writeDefaultHeaders(w, "foo")
if err != nil {
handleException(w, err)
return
}
fmt.Fprintf(w, "Pong")
}

Alternatively, change PingHandler to set contentType based on some request criteria like whether the request ends in .json or not (which you will presumably need to do in order to serve either json or text) so that you can trigger an error somehow - at present since PingHandler never serves anything but text, the error code is redundant and the result untestable.