client usage testing

assured/assured_bindings.go

@@ -67,7 +67,7 @@ func createApplicationRouter(ctx context.Context, logger kitlog.Logger) *mux.Rou
 		kithttp.NewServer(
 			e.WrappedEndpoint(e.VerifyEndpoint),
 			decodeAssuredCall,
-			encodeJSONResponse,
+			encodeAssuredCall,
 			kithttp.ServerErrorLogger(logger),
 			kithttp.ServerAfter(kithttp.SetResponseHeader("Access-Control-Allow-Origin", "*")),
 			kithttp.ServerErrorEncoder(errorEncoder)),
@@ -122,19 +122,17 @@ func decodeAssuredCall(ctx context.Context, req *http.Request) (interface{}, err
 
 // encodeAssuredCall writes the assured Call to the http response as it is intended to be stubbed
 func encodeAssuredCall(ctx context.Context, w http.ResponseWriter, i interface{}) error {
-	if call, ok := i.(*Call); ok {
-		w.WriteHeader(call.StatusCode)
-		w.Write([]byte(call.String()))
+	switch resp := i.(type) {
+	case *Call:
+		w.WriteHeader(resp.StatusCode)
+		w.Write([]byte(resp.String()))
+	case []*Call:
+		w.Header().Set("Content-Type", "application/json")
+		return json.NewEncoder(w).Encode(resp)
 	}
 	return nil
 }
 
-// encodeJSONResponse writes to the http response as JSON
-func encodeJSONResponse(ctx context.Context, w http.ResponseWriter, i interface{}) error {
-	w.Header().Set("Content-Type", "application/json")
-	return json.NewEncoder(w).Encode(i)
-}
-
 func errorEncoder(ctx context.Context, err error, w http.ResponseWriter) {
 
 }

assured/assured_bindings_test.go

@@ -214,6 +214,16 @@ func TestEncodeAssuredCall(t *testing.T) {
 	require.Equal(t, `{"assured": true}`, resp.Body.String())
 }
 
+func TestEncodeAssuredCalls(t *testing.T) {
+	resp := httptest.NewRecorder()
+
+	err := encodeAssuredCall(ctx, resp, []*Call{call1, call2})
+
+	require.NoError(t, err)
+	require.Equal(t, "application/json", resp.HeaderMap.Get("Content-Type"))
+	require.Equal(t, `[{"Path":"test/assured","Method":"GET","StatusCode":200,"Response":"eyJhc3N1cmVkIjogdHJ1ZX0="},{"Path":"test/assured","Method":"GET","StatusCode":409,"Response":"ZXJyb3I="}]`+"\n", resp.Body.String())
+}
+
 var (
 	ctx   = context.Background()
 	verbs = []string{

assured/assured_endpoints_test.go

@@ -76,8 +76,8 @@ func TestWhenEndpointSuccess(t *testing.T) {
 		madeCalls:    map[string][]*Call{},
 	}
 	expected := map[string][]*Call{
-		"GET:test/assured": {call2, call1},
-		":teapot/assured":  {call3},
+		"GET:test/assured":    {call2, call1},
+		"POST:teapot/assured": {call3},
 	}
 
 	c, err := endpoints.WhenEndpoint(ctx, call1)
@@ -133,7 +133,7 @@ func TestClearEndpointSuccess(t *testing.T) {
 		madeCalls:    fullAssuredCalls,
 	}
 	expected := map[string][]*Call{
-		":teapot/assured": {call3},
+		"POST:teapot/assured": {call3},
 	}
 
 	c, err := endpoints.ClearEndpoint(ctx, call1)
@@ -188,10 +188,11 @@ var (
 	}
 	call3 = &Call{
 		Path:       "teapot/assured",
+		Method:     "POST",
 		StatusCode: http.StatusTeapot,
 	}
 	fullAssuredCalls = map[string][]*Call{
-		"GET:test/assured": {call1, call2},
-		":teapot/assured":  {call3},
+		"GET:test/assured":    {call1, call2},
+		"POST:teapot/assured": {call3},
 	}
 )

assured/client.go

@@ -103,7 +103,7 @@ func (c *Client) Verify(method, path string) ([]*Call, error) {
 	defer resp.Body.Close()
 
 	var calls []*Call
-	if err = json.NewDecoder(resp.Body).Decode(calls); err != nil {
+	if err = json.NewDecoder(resp.Body).Decode(&calls); err != nil {
 		return nil, err
 	}
 	return calls, nil

assured/client_test.go

@@ -2,8 +2,12 @@ package assured
 
 import (
 	"bytes"
+	"encoding/json"
 	"io/ioutil"
 	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
 	"testing"
 
 	kitlog "github.com/go-kit/kit/log"
@@ -17,24 +21,166 @@ func TestClient(t *testing.T) {
 
 	require.NoError(t, client.Given(call1))
 	require.NoError(t, client.Given(call2))
+	require.NoError(t, client.Given(call3))
 
 	req, err := http.NewRequest(http.MethodGet, url+"test/assured", bytes.NewReader([]byte(`{"calling":"you"}`)))
 	require.NoError(t, err)
 
-	hit1, err := httpClient.Do(req)
+	resp, err := httpClient.Do(req)
 	require.NoError(t, err)
-	require.Equal(t, http.StatusOK, hit1.StatusCode)
-	body, err := ioutil.ReadAll(hit1.Body)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	body, err := ioutil.ReadAll(resp.Body)
 	require.NoError(t, err)
 	require.Equal(t, []byte(`{"assured": true}`), body)
 
 	req, err = http.NewRequest(http.MethodGet, url+"test/assured", bytes.NewReader([]byte(`{"calling":"again"}`)))
 	require.NoError(t, err)
 
-	hit2, err := httpClient.Do(req)
+	resp, err = httpClient.Do(req)
 	require.NoError(t, err)
-	require.Equal(t, http.StatusConflict, hit2.StatusCode)
-	body, err = ioutil.ReadAll(hit2.Body)
+	require.Equal(t, http.StatusConflict, resp.StatusCode)
+	body, err = ioutil.ReadAll(resp.Body)
 	require.NoError(t, err)
 	require.Equal(t, []byte("error"), body)
+
+	req, err = http.NewRequest(http.MethodPost, url+"teapot/assured", bytes.NewReader([]byte(`{"calling":"here"}`)))
+	require.NoError(t, err)
+
+	resp, err = httpClient.Do(req)
+	require.NoError(t, err)
+	require.Equal(t, http.StatusTeapot, resp.StatusCode)
+	body, err = ioutil.ReadAll(resp.Body)
+	require.NoError(t, err)
+	require.Equal(t, []byte{}, body)
+
+	calls, err := client.Verify("GET", "test/assured")
+	require.NoError(t, err)
+	require.Equal(t, []*Call{
+		&Call{Method: "GET", Path: "test/assured", StatusCode: 200, Response: []byte(`{"calling":"you"}`)},
+		&Call{Method: "GET", Path: "test/assured", StatusCode: 200, Response: []byte(`{"calling":"again"}`)}}, calls)
+
+	calls, err = client.Verify("POST", "teapot/assured")
+	require.NoError(t, err)
+	require.Equal(t, []*Call{&Call{Method: "POST", Path: "teapot/assured", StatusCode: 200, Response: []byte(`{"calling":"here"}`)}}, calls)
+
+	err = client.Clear("GET", "test/assured")
+	require.NoError(t, err)
+
+	calls, err = client.Verify("GET", "test/assured")
+	require.NoError(t, err)
+	require.Nil(t, calls)
+
+	calls, err = client.Verify("POST", "teapot/assured")
+	require.NoError(t, err)
+	require.Equal(t, []*Call{&Call{Method: "POST", Path: "teapot/assured", StatusCode: 200, Response: []byte(`{"calling":"here"}`)}}, calls)
+
+	err = client.ClearAll()
+	require.NoError(t, err)
+
+	calls, err = client.Verify("GET", "test/assured")
+	require.NoError(t, err)
+	require.Nil(t, calls)
+
+	calls, err = client.Verify("POST", "teapot/assured")
+	require.NoError(t, err)
+	require.Nil(t, calls)
+}
+
+func TestClientGivenMethodFailure(t *testing.T) {
+	client := NewClient(kitlog.NewLogfmtLogger(ioutil.Discard), nil).Run()
+
+	err := client.Given(&Call{Path: "NoMethodMan"})
+
+	require.Error(t, err)
+	require.Equal(t, "cannot stub call without Method", err.Error())
+}
+
+func TestClientGivenPathFailure(t *testing.T) {
+	client := NewClient(kitlog.NewLogfmtLogger(ioutil.Discard), nil).Run()
+
+	err := client.Given(&Call{Method: "GOT"})
+
+	require.Error(t, err)
+	require.Equal(t, "cannot stub call without Path", err.Error())
+}
+
+func TestClientBadRequestFailure(t *testing.T) {
+	client := NewClient(kitlog.NewLogfmtLogger(ioutil.Discard), nil).Run()
+
+	err := client.Given(&Call{Method: "\"", Path: "goat/path"})
+
+	require.Error(t, err)
+	require.Equal(t, `net/http: invalid method "\""`, err.Error())
+
+	err = client.Given(&Call{Method: "\"", Path: "goat/path", Response: []byte("goats among men")})
+
+	require.Error(t, err)
+	require.Equal(t, `net/http: invalid method "\""`, err.Error())
+
+	calls, err := client.Verify("\"", "goat/path")
+
+	require.Error(t, err)
+	require.Equal(t, `net/http: invalid method "\""`, err.Error())
+	require.Nil(t, calls)
+
+	err = client.Clear("\"", "goat/path")
+
+	require.Error(t, err)
+	require.Equal(t, `net/http: invalid method "\""`, err.Error())
+
+	p := -1
+	client.port = &p
+	err = client.ClearAll()
+
+	require.Error(t, err)
+	require.Equal(t, `Delete http://localhost:-1/clear: invalid URL port "-1"`, err.Error())
+}
+
+func TestClientVerifyHttpClientFailure(t *testing.T) {
+	client := NewClient(kitlog.NewLogfmtLogger(ioutil.Discard), nil)
+
+	calls, err := client.Verify("GONE", "not/started")
+
+	require.Error(t, err)
+	require.Contains(t, err.Error(), `connection refused`)
+	require.Nil(t, calls)
+}
+
+func TestClientVerifyResponseFailure(t *testing.T) {
+	client := NewClient(kitlog.NewLogfmtLogger(ioutil.Discard), nil)
+	testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer testServer.Close()
+	index := strings.LastIndex(testServer.URL, ":")
+	port, err := strconv.ParseInt(testServer.URL[index+1:], 10, 64)
+	require.NoError(t, err)
+	p := int(port)
+	client.port = &p
+
+	calls, err := client.Verify("GONE", "not/started")
+
+	require.Error(t, err)
+	require.Equal(t, `failure to verify calls`, err.Error())
+	require.Nil(t, calls)
+}
+
+func TestClientVerifyBodyFailure(t *testing.T) {
+	client := NewClient(kitlog.NewLogfmtLogger(ioutil.Discard), nil)
+	testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode("ydob+dab")
+	}))
+	defer testServer.Close()
+	index := strings.LastIndex(testServer.URL, ":")
+	port, err := strconv.ParseInt(testServer.URL[index+1:], 10, 64)
+	require.NoError(t, err)
+	p := int(port)
+	client.port = &p
+
+	calls, err := client.Verify("BODY", "bad+body")
+
+	require.Error(t, err)
+	require.Equal(t, `json: cannot unmarshal string into Go value of type []*assured.Call`, err.Error())
+	require.Nil(t, calls)
 }