Use net/http/httptest to emulate server behavior

Author: bmuschko

cmd/verify.go

@@ -1,13 +1,11 @@
 package cmd
 
 import (
-	"github.com/bmuschko/link-verifier/http"
 	"github.com/bmuschko/link-verifier/verify"
 	"github.com/spf13/cobra"
 )
 
 func doVerifyCmd(cmd *cobra.Command, args []string) {
-	http.SetTimeout(parsedOptions.Timeout)
 	files := verify.Resolve(parsedOptions.RootDirs, parsedOptions.IncludePatterns)
-	verify.Process(files, parsedOptions.IgnoreStatusCodes, parsedOptions.Fail)
+	verify.Process(files, parsedOptions.Timeout, parsedOptions.IgnoreStatusCodes, parsedOptions.Fail)
 }

http/http.go

@@ -6,26 +6,33 @@ import (
 	"time"
 )
 
-var client = &http.Client{}
+type HTTP struct {
+	client *http.Client
+}
 
 // SetTimeout sets timeout for HTTP requests in seconds.
-func SetTimeout(timeout int) {
-	client.Timeout = time.Duration(int(time.Second) * timeout)
+func (h *HTTP) SetTimeout(timeout int) {
+	h.client.Timeout = time.Duration(int(time.Second) * timeout)
+}
+
+// GetTimeout gets timeout for HTTP requests as duration.
+func (h *HTTP) GetTimeout() time.Duration {
+	return h.client.Timeout
 }
 
 // Get emits a HTTP HEAD request for a given URL. Captures the status code, status and outcome of the call.
 // Returns with information about the response.
-func Head(link string) HttpResponse {
+func (h *HTTP) Head(link string) HttpResponse {
 	return sendRequest(link, func(url *url.URL) (resp *http.Response, err error) {
-		return client.Head(url.String())
+		return h.client.Head(url.String())
 	})
 }
 
 // Get emits a HTTP GET request for a given URL. Captures the status code, status and outcome of the call.
 // Returns with information about the response.
-func Get(link string) HttpResponse {
+func (h *HTTP) Get(link string) HttpResponse {
 	return sendRequest(link, func(url *url.URL) (resp *http.Response, err error) {
-		return client.Get(url.String())
+		return h.client.Get(url.String())
 	})
 }
 
@@ -64,3 +71,7 @@ type HttpResponse struct {
 	Status     string
 	Error      error
 }
+
+func NewHTTP() *HTTP {
+	return &HTTP{client: &http.Client{}}
+}

http/http_test.go

@@ -3,84 +3,121 @@ package http_test
 import (
 	. "github.com/bmuschko/link-verifier/http"
 	. "github.com/stretchr/testify/assert"
+	"net/http"
+	"net/http/httptest"
 	"testing"
+	"time"
 )
 
 const (
-	validUrl      = "http://www.google.com/"
-	incompleteUrl = "https://www.googleapis.com/urlshortener/v1/url"
-	unknownUrl    = "http://www.unknown1x.com/"
-	invalidUrl    = "123://www.invalid.com/"
+	invalidUrl = "123://www.invalid.com/"
 )
 
 func TestSetTimeout(t *testing.T) {
-	SetTimeout(20)
+	h := NewHTTP()
+	h.SetTimeout(20)
+
+	Equal(t, h.GetTimeout(), time.Duration(int(time.Second)*20))
 }
 
 func TestHeadValidUrl(t *testing.T) {
-	result := Head(validUrl)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	h := NewHTTP()
+	result := h.Head(server.URL)
 
-	Equal(t, validUrl, result.Url)
+	Equal(t, server.URL, result.Url)
 	True(t, result.Success)
 	Nil(t, result.Error)
-	Equal(t, 200, result.StatusCode)
+	Equal(t, http.StatusOK, result.StatusCode)
 }
 
-func TestHeadUrlForBadRequest(t *testing.T) {
-	t.Skip("Needs to emulate an HTTP server to reproducible results")
-	result := Head(incompleteUrl)
+func TestGetValidUrl(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
 
-	Equal(t, incompleteUrl, result.Url)
-	False(t, result.Success)
+	h := NewHTTP()
+	result := h.Get(server.URL)
+
+	Equal(t, server.URL, result.Url)
+	True(t, result.Success)
 	Nil(t, result.Error)
-	Equal(t, 400, result.StatusCode)
+	Equal(t, http.StatusOK, result.StatusCode)
 }
 
-func TestHeadNonExistentUrl(t *testing.T) {
-	result := Head(unknownUrl)
+func TestHeadUrlForBadRequest(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusBadRequest)
+	}))
+	defer server.Close()
+
+	h := NewHTTP()
+	result := h.Head(server.URL)
 
-	Equal(t, unknownUrl, result.Url)
+	Equal(t, server.URL, result.Url)
 	False(t, result.Success)
-	NotNil(t, result.Error)
+	Nil(t, result.Error)
+	Equal(t, http.StatusBadRequest, result.StatusCode)
 }
 
-func TestHeadInvalidUrl(t *testing.T) {
-	result := Head(invalidUrl)
+func TestGetUrlForBadRequest(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusBadRequest)
+	}))
+	defer server.Close()
 
-	Equal(t, invalidUrl, result.Url)
+	h := NewHTTP()
+	result := h.Get(server.URL)
+
+	Equal(t, server.URL, result.Url)
 	False(t, result.Success)
-	NotNil(t, result.Error)
+	Nil(t, result.Error)
+	Equal(t, http.StatusBadRequest, result.StatusCode)
 }
 
-func TestGetValidUrl(t *testing.T) {
-	result := Get(validUrl)
+func TestHeadNotFoundUrl(t *testing.T) {
+	server := httptest.NewServer(http.NotFoundHandler())
+	defer server.Close()
 
-	Equal(t, validUrl, result.Url)
-	True(t, result.Success)
+	h := NewHTTP()
+	result := h.Head(server.URL)
+
+	Equal(t, server.URL, result.Url)
+	False(t, result.Success)
 	Nil(t, result.Error)
-	Equal(t, 200, result.StatusCode)
+	Equal(t, http.StatusNotFound, result.StatusCode)
 }
 
-func TestGetUrlForBadRequest(t *testing.T) {
-	t.Skip("Needs to emulate an HTTP server to reproducible results")
-	result := Get(incompleteUrl)
+func TestGetNotFoundUrl(t *testing.T) {
+	server := httptest.NewServer(http.NotFoundHandler())
+	defer server.Close()
 
-	Equal(t, incompleteUrl, result.Url)
+	h := NewHTTP()
+	result := h.Get(server.URL)
+
+	Equal(t, server.URL, result.Url)
 	False(t, result.Success)
 	Nil(t, result.Error)
-	Equal(t, 400, result.StatusCode)
+	Equal(t, http.StatusNotFound, result.StatusCode)
 }
 
-func TestGetNonExistentUrl(t *testing.T) {
-	result := Get(unknownUrl)
+func TestHeadInvalidUrl(t *testing.T) {
+	h := NewHTTP()
+	result := h.Head(invalidUrl)
 
-	Equal(t, unknownUrl, result.Url)
+	Equal(t, invalidUrl, result.Url)
 	False(t, result.Success)
 	NotNil(t, result.Error)
 }
 
 func TestGetInvalidUrl(t *testing.T) {
-	result := Get(invalidUrl)
+	h := NewHTTP()
+	result := h.Get(invalidUrl)
 
 	Equal(t, invalidUrl, result.Url)
 	False(t, result.Success)

verify/verify.go

@@ -35,14 +35,14 @@ func Resolve(rootDirs []string, includePatterns []string) []string {
 // Process processes text-based files by verifying each parsed links by emitting a HTTP call.
 // Prints out a summary of successful and failed links.
 // By default fails the program if at least one link could not be resolved.
-func Process(files []string, ignoreStatusCodes []int, fail bool) {
+func Process(files []string, timeout int, ignoreStatusCodes []int, fail bool) {
 	aggregateSummary := []stat.Summary{}
 
 	for _, textBasedFile := range files {
 		fmt.Println()
 		fmt.Println("-> Verifying file:", textBasedFile)
 		content := file.ReadFile(textBasedFile)
-		summary := parseLinks(content, ignoreStatusCodes)
+		summary := parseLinks(content, timeout, ignoreStatusCodes)
 		aggregateSummary = append(aggregateSummary, summary)
 	}
 
@@ -62,7 +62,7 @@ func Process(files []string, ignoreStatusCodes []int, fail bool) {
 	}
 }
 
-func parseLinks(content string, ignoreStatusCodes []int) stat.Summary {
+func parseLinks(content string, timeout int, ignoreStatusCodes []int) stat.Summary {
 	links := text.ParseLinks(content)
 	summary := stat.Summary{Successful: 0, Failed: 0}
 
@@ -73,7 +73,7 @@ func parseLinks(content string, ignoreStatusCodes []int) stat.Summary {
 	ch := make(chan string)
 
 	for _, link := range links {
-		go validateLink(link, ignoreStatusCodes, &summary, ch)
+		go validateLink(link, timeout, ignoreStatusCodes, &summary, ch)
 	}
 
 	for range links {
@@ -83,7 +83,10 @@ func parseLinks(content string, ignoreStatusCodes []int) stat.Summary {
 	return summary
 }
 
-func validateLink(link string, ignoreStatusCodes []int, summary *stat.Summary, ch chan<- string) {
+func validateLink(link string, timeout int, ignoreStatusCodes []int, summary *stat.Summary, ch chan<- string) {
+	http := http.NewHTTP()
+	http.SetTimeout(timeout)
+
 	// Try HEAD request first
 	response := http.Head(link)