update tests

Author: pkieltyka

httpvcr.go

@@ -1,6 +1,8 @@
 package httpvcr
 
-import "net/http"
+import (
+	"net/http"
+)
 
 type Mode uint32
 
@@ -48,6 +50,9 @@ func New(cassetteName string, opts ...Options) *HTTPVCR {
 	}
 }
 
+// Start starts a VCR session with the given cassette name.
+// Records episodes if the cassette file does not exists.
+// Otherwise plays back recorded episodes.
 func (v *HTTPVCR) Start() {
 	if v.mode != ModeStopped {
 		panic("httpvcr: session already started!")
@@ -66,20 +71,26 @@ func (v *HTTPVCR) Start() {
 	}
 }
 
+// Stop stops the VCR session and writes the cassette file (when recording)
 func (v *HTTPVCR) Stop() {
 	if v.mode == ModeRecord {
 		v.Cassette.write()
 	}
-	// TODO: what happens if we stop then start again?
-	v.mode = ModeStopped
 
-	if v.options.HTTPDefaultOverride {
+	if v.options.HTTPDefaultOverride { //&& v.originalTransport != nil {
 		http.DefaultTransport = v.originalTransport
 	}
+
+	v.mode = ModeStopped
 }
 
 func (v *HTTPVCR) Mode() Mode {
-	return v.Mode()
+	return v.mode
+}
+
+// FilterData allows replacement of sensitive data with a dummy-string
+func (v *HTTPVCR) FilterResponseBody(original string, replacement string) {
+	v.FilterMap[original] = replacement
 }
 
 func (v *HTTPVCR) RoundTrip(request *http.Request) (*http.Response, error) {
@@ -103,6 +114,7 @@ func (v *HTTPVCR) RoundTrip(request *http.Request) (*http.Response, error) {
 
 		e := episode{Request: vcrReq, Response: vcrRes}
 		v.Cassette.Episodes = append(v.Cassette.Episodes, e)
+
 	} else {
 		e := v.Cassette.matchEpisode(vcrReq)
 		vcrRes = e.Response

httpvcr_test.go

@@ -1 +1,266 @@
 package httpvcr
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var testRequestCounter = 0
+
+func testBegin(t *testing.T) {
+	// delete old fixtures
+	err := os.RemoveAll("fixtures")
+	assert.Nil(t, err)
+
+	// reset counter
+	testRequestCounter = 0
+}
+
+func testRequest(t *testing.T, url string, postBody *string) (*http.Response, string) {
+	var err error
+	var response *http.Response
+
+	if postBody != nil {
+		buf := bytes.NewBufferString(*postBody)
+		response, err = http.Post(url, "text/plain", buf)
+	} else {
+		response, err = http.Get(url)
+	}
+	assert.Nil(t, err)
+	defer response.Body.Close()
+
+	body, err := ioutil.ReadAll(response.Body)
+	assert.Nil(t, err)
+
+	return response, string(body)
+}
+
+func testAllRequests(t *testing.T, urlBase string) {
+	var body string
+	var response *http.Response
+
+	response, body = testRequest(t, urlBase, nil)
+	assert.Equal(t, "0:GET:/:''", body)
+	assert.Equal(t, 200, response.StatusCode)
+	assert.Equal(t, "200 OK", response.Status)
+	assert.Equal(t, "HTTP/1.0", response.Proto)
+	assert.Equal(t, 1, response.ProtoMajor)
+	assert.Equal(t, 0, response.ProtoMinor)
+	assert.Equal(t, len(body), int(response.ContentLength))
+	assert.Equal(t, []string{"yes"}, response.Header["Test"])
+
+	_, body = testRequest(t, urlBase, nil)
+	assert.Equal(t, "1:GET:/:''", body)
+
+	str := "Hey Buddy"
+	response, body = testRequest(t, urlBase, &str)
+	assert.Equal(t, "2:POST:/:'Hey Buddy'", body)
+	assert.Equal(t, len(body), int(response.ContentLength))
+
+	multilineStr := "abc\ndef\n"
+	_, body = testRequest(t, urlBase, &multilineStr)
+	assert.Equal(t, "3:POST:/:'abc\ndef\n'", body)
+
+	_, body = testRequest(t, urlBase+"/modme", &str)
+	assert.Equal(t, "4:POST:/modme:'moddedString'", body)
+
+	str = "secret-key"
+	_, body = testRequest(t, urlBase, &str)
+	assert.Equal(t, "5:POST:/:'secret-key'", body)
+
+}
+
+func testServer() *httptest.Server {
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		header := w.Header()
+		header["Test"] = []string{"yes"}
+
+		body, _ := ioutil.ReadAll(r.Body)
+		fmt.Fprintf(w, "%d:%s:%s:'%s'", testRequestCounter, r.Method, r.URL.Path, body)
+		testRequestCounter++
+	}))
+}
+
+func requestMod(request *http.Request) {
+	if request.URL.Path == "/modme" {
+		ModifyHTTPRequestBody(request, func(body string) string {
+			return strings.Replace(string(body), "Hey Buddy", "moddedString", 1)
+		})
+	}
+}
+
+func TestVCR(t *testing.T) {
+	testBegin(t)
+
+	ts := testServer()
+	defer ts.Close()
+
+	vcr := New("test_cassette")
+	vcr.FilterResponseBody("secret-key", "dummy-key")
+	vcr.RequestModifier = requestMod
+
+	vcr.Start()
+	assert.Equal(t, ModeRecord, vcr.Mode())
+	testAllRequests(t, ts.URL)
+	vcr.Stop()
+
+	// this only works because the key is the only body content.
+	// otherwise the base64 alignment would be off.
+	data, _ := ioutil.ReadFile("fixtures/vcr/test_cassette.json")
+	assert.Contains(t, string(data), base64.StdEncoding.EncodeToString([]byte("dummy-key")))
+	assert.NotContains(t, string(data), base64.StdEncoding.EncodeToString([]byte("secret-key")))
+
+	vcr.Start()
+	assert.Equal(t, ModeReplay, vcr.Mode())
+	testAllRequests(t, ts.URL)
+	vcr.Stop()
+}
+
+func TestNoSession(t *testing.T) {
+	testBegin(t)
+
+	ts := testServer()
+	defer ts.Close()
+
+	_, body := testRequest(t, ts.URL, nil)
+	assert.Equal(t, "0:GET:/:''", body)
+}
+
+func TestNoEpisodesLeft(t *testing.T) {
+	testBegin(t)
+
+	defer func() {
+		assert.Equal(t, "httpvcr: no more episodes!", recover())
+	}()
+
+	vcr := New("test_cassette")
+	vcr.Start()
+	vcr.Stop()
+
+	vcr.Start()
+	defer vcr.Stop()
+	testRequest(t, "http://1.2.3.4", nil)
+}
+
+func TestEpisodesDoNotMatch(t *testing.T) {
+	testBegin(t)
+
+	ts := testServer()
+	defer ts.Close()
+
+	vcr := New("test_cassette")
+	assert.Equal(t, ModeStopped, vcr.Mode())
+	vcr.Start()
+	assert.Equal(t, ModeRecord, vcr.Mode())
+	testRequest(t, ts.URL, nil)
+	vcr.Stop()
+
+	// Method mismatch
+	func() {
+		vcr.Start()
+		defer vcr.Stop()
+
+		defer func() {
+			assert.Equal(t, fmt.Sprintf("httpvcr: problem with episode for POST %s\n  episode Method does not match:\n  expected: GET\n  but got: POST", ts.URL), recover())
+		}()
+
+		body := ""
+		testRequest(t, ts.URL, &body)
+	}()
+
+	// URL mismatch
+	func() {
+		otherURL := ts.URL + "/abc"
+		defer func() {
+			assert.Equal(t, fmt.Sprintf("httpvcr: problem with episode for GET %s\n  episode URL does not match:\n  expected: %v\n  but got: %v", otherURL, ts.URL, otherURL), recover())
+		}()
+
+		vcr.Start()
+		defer vcr.Stop()
+		testRequest(t, otherURL, nil)
+	}()
+
+	func() {
+		defer func() {
+			assert.Equal(t, fmt.Sprintf("httpvcr: problem with episode for POST %s\n  episode Body does not match:\n  expected: foo\n  but got: bar", ts.URL), recover())
+		}()
+
+		body := "foo"
+
+		vcr = New("test_cassette2")
+
+		vcr.Start()
+		testRequest(t, ts.URL, &body)
+		vcr.Stop()
+
+		vcr.Start()
+		defer vcr.Stop()
+		body = "bar"
+		testRequest(t, ts.URL, &body)
+	}()
+}
+
+func TestOriginalRoundTripErrors(t *testing.T) {
+	testBegin(t)
+
+	vcr := New("test_cassette")
+	vcr.Start()
+	defer vcr.Stop()
+
+	_, err := http.Get("xhttp://foo")
+	assert.EqualError(t, err, "Get xhttp://foo: unsupported protocol scheme \"xhttp\"")
+}
+
+func TestFileWriteError(t *testing.T) {
+	testBegin(t)
+
+	defer func() {
+		assert.Equal(t, recover(), "httpvcr: cannot write cassette file!")
+	}()
+
+	vcr := New("test")
+	vcr.Start()
+	defer vcr.Stop()
+
+	err := os.MkdirAll("fixtures/vcr/test.json", 0755)
+	assert.Nil(t, err)
+}
+
+func TestFileParseError(t *testing.T) {
+	testBegin(t)
+
+	defer func() {
+		assert.Equal(t, recover(), "httpvcr: cannot parse json!")
+	}()
+
+	os.MkdirAll("fixtures/vcr", 0755)
+	err := ioutil.WriteFile("fixtures/vcr/test.json", []byte("{[}"), 0644)
+	assert.Nil(t, err)
+
+	vcr := New("test")
+	vcr.Start()
+	vcr.Stop()
+}
+
+// func TestStartTwice(t *testing.T) {
+// 	testBegin(t)
+
+// 	defer func() {
+// 		assert.Equal(t, recover(), "httpvcr: session already started!")
+// 	}()
+
+// 	vcr := New("test")
+// 	vcr.Start()
+// 	vcr.Start()
+
+// 	vcr.Stop()
+// }

util_test.go

@@ -6,33 +6,33 @@ import (
 	"net/http"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestModifyHTTPRequestBody(t *testing.T) {
 	req, err := http.NewRequest("GET", "/", bytes.NewBufferString("abc"))
-	require.Nil(t, err)
-	require.Equal(t, int64(3), req.ContentLength)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(3), req.ContentLength)
 
 	ModifyHTTPRequestBody(req, func(input string) string {
-		require.Equal(t, input, "abc")
+		assert.Equal(t, input, "abc")
 		return "foofoo"
 	})
 
-	require.Equal(t, int64(6), req.ContentLength)
+	assert.Equal(t, int64(6), req.ContentLength)
 	body, _ := ioutil.ReadAll(req.Body)
-	require.Equal(t, "foofoo", string(body))
+	assert.Equal(t, "foofoo", string(body))
 }
 
 func TestModifyHTTPRequestBodyWithNilBody(t *testing.T) {
 	req, err := http.NewRequest("GET", "/", nil)
-	require.Nil(t, err)
-	require.Equal(t, int64(0), req.ContentLength)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(0), req.ContentLength)
 
 	ModifyHTTPRequestBody(req, func(input string) string {
 		return "foofoo"
 	})
 
-	require.Equal(t, int64(0), req.ContentLength)
-	require.Equal(t, req.Body, nil)
+	assert.Equal(t, int64(0), req.ContentLength)
+	assert.Equal(t, req.Body, nil)
 }