chore(test): add unit test for round trip function (#18)

bxcodec · web-flow · commit 52f0db7895d3 · 2020-06-19T16:26:05.000+07:00
* chore(cache-interactor): rename the cache interactor

* chore(test): add test for round trip

* feat: export public function for full control

* chore: update readme example
diff --git a/Makefile b/Makefile
@@ -1,7 +1,19 @@
+ifndef $(GOPATH)
+    GOPATH=$(shell go env GOPATH)
+    export GOPATH
+endif
+
 .PHONY: mockery-prepare
+
+# Install the mockery. This command will install the mockery in the GOPATH/bin folder
 mockery-prepare:
-	@echo "Installing mockery"
-	@go get -u github.com/vektra/mockery
+	 @go get github.com/vektra/mockery/.../
+
+# Use the mockery to generate mock interface
+mockery-gen:
+	@rm -rf ./mocks
+	$(GOPATH)/bin/mockery --dir ./cache/ --name ICacheInteractor
+	 
 
 .PHONY: short-test
 short-test:
diff --git a/README.md b/README.md
@@ -45,7 +45,7 @@ Short example:
 
 // Inject the HTTP Client with httpcache
 client := &http.Client{}
-err := httpcache.NewWithInmemoryCache(client, time.Second*60)
+_, err := httpcache.NewWithInmemoryCache(client, time.Second*60)
 if err != nil {
   log.Fatal(err)
 }
diff --git a/cache/cache.go b/cache/cache.go
@@ -21,11 +21,12 @@ const (
 	// TODO (bxcodec): Add another storage type
 )
 
-// Interactor ...
-type Interactor interface {
-	Set(key string, value CachedResponse, duration time.Duration) error
+// ICacheInteractor ...
+type ICacheInteractor interface {
+	Set(key string, value CachedResponse) error
 	Get(key string) (CachedResponse, error)
 	Delete(key string) error
+	Flush() error
 	Origin() string
 }
 
diff --git a/cache/inmem/inmem.go b/cache/inmem/inmem.go
@@ -1,8 +1,6 @@
 package inmem
 
 import (
-	"time"
-
 	memcache "github.com/bxcodec/gotcha/cache"
 	"github.com/bxcodec/httpcache/cache"
 )
@@ -12,14 +10,13 @@ type inmemCache struct {
 }
 
 // NewCache will return the inmemory cache handler
-func NewCache(c memcache.Cache) cache.Interactor {
+func NewCache(c memcache.Cache) cache.ICacheInteractor {
 	return &inmemCache{
 		cache: c,
 	}
 }
 
-func (i *inmemCache) Set(key string, value cache.CachedResponse, duration time.Duration) (err error) {
-	// TODO(bxcodec): add custom duration here based on user response result on the fly
+func (i *inmemCache) Set(key string, value cache.CachedResponse) (err error) {
 	return i.cache.Set(key, value)
 }
 
@@ -39,3 +36,7 @@ func (i *inmemCache) Delete(key string) (err error) {
 func (i *inmemCache) Origin() string {
 	return cache.CacheStorageInMemory
 }
+
+func (i *inmemCache) Flush() error {
+	return i.cache.ClearCache()
+}
diff --git a/cache/inmem/inmem_test.go b/cache/inmem/inmem_test.go
@@ -26,7 +26,7 @@ func TestCacheInMemory(t *testing.T) {
 	}
 
 	// Try to SET item
-	err := cacheObj.Set(testKey, testVal, time.Second*5)
+	err := cacheObj.Set(testKey, testVal)
 	if err != nil {
 		t.Fatalf("expected %v, got %v", nil, err)
 	}
diff --git a/go.sum b/go.sum
@@ -4,9 +4,11 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/helper/cacheheader/directive.go b/helper/cacheheader/directive.go
@@ -259,7 +259,7 @@ func (cd *RequestCacheDirectives) addToken(token string) error {
 		cd.NoCache = true
 	case HeaderNoStore:
 		cd.NoStore = true
-	case "no-transform":
+	case HeaderNoTransform:
 		cd.NoTransform = true
 	case "only-if-cached":
 		cd.OnlyIfCached = true
@@ -292,7 +292,7 @@ func (cd *RequestCacheDirectives) addPair(token string, v string) error {
 		err = ErrNoCacheNoArgs
 	case HeaderNoStore:
 		err = ErrNoStoreNoArgs
-	case "no-transform":
+	case HeaderNoTransform:
 		err = ErrNoTransformNoArgs
 	case "only-if-cached":
 		err = ErrOnlyIfCachedNoArgs
@@ -467,7 +467,7 @@ func (cd *ResponseCacheDirectives) addToken(token string) error {
 		cd.NoCachePresent = true
 	case HeaderNoStore:
 		cd.NoStore = true
-	case "no-transform":
+	case HeaderNoTransform:
 		cd.NoTransform = true
 	case "public":
 		cd.Public = true
@@ -520,7 +520,7 @@ func (cd *ResponseCacheDirectives) addPair(token string, v string) error {
 		}
 	case HeaderNoStore:
 		err = ErrNoStoreNoArgs
-	case "no-transform":
+	case HeaderNoTransform:
 		err = ErrNoTransformNoArgs
 	case "public":
 		err = ErrPublicNoArgs
diff --git a/helper/cacheheader/object.go b/helper/cacheheader/object.go
@@ -81,7 +81,6 @@ func CachableObject(obj *Object, rv *ObjectResults) {
 		if !hasFreshness(obj.ReqDirectives, obj.RespDirectives, obj.RespHeaders, obj.RespExpiresHeader, obj.CacheIsPrivate) {
 			rv.OutReasons = append(rv.OutReasons, ReasonRequestMethodPOST)
 		}
-
 	case "PUT":
 		rv.OutReasons = append(rv.OutReasons, ReasonRequestMethodPUT)
 
diff --git a/httpcache.go b/httpcache.go
@@ -13,21 +13,22 @@ import (
 // NewWithCustomStorageCache will initiate the httpcache with your defined cache storage
 // To use your own cache storage handler, you need to implement the cache.Interactor interface
 // And pass it to httpcache.
-func NewWithCustomStorageCache(client *http.Client, cacheInteractor cache.Interactor) (err error) {
+func NewWithCustomStorageCache(client *http.Client, cacheInteractor cache.ICacheInteractor) (cacheHandler *CacheHandler, err error) {
 	return newClient(client, cacheInteractor)
 }
 
-func newClient(client *http.Client, cacheInteractor cache.Interactor) (err error) {
+func newClient(client *http.Client, cacheInteractor cache.ICacheInteractor) (cachedHandler *CacheHandler, err error) {
 	if client.Transport == nil {
 		client.Transport = http.DefaultTransport
 	}
-	client.Transport = NewRoundtrip(client.Transport, cacheInteractor)
+	cachedHandler = NewRoundtrip(client.Transport, cacheInteractor)
+	client.Transport = cachedHandler
 	return
 }
 
 // NewWithInmemoryCache will create a complete cache-support of HTTP client with using inmemory cache.
 // If the duration not set, the cache will use LFU algorithm
-func NewWithInmemoryCache(client *http.Client, duration ...time.Duration) (err error) {
+func NewWithInmemoryCache(client *http.Client, duration ...time.Duration) (cachedHandler *CacheHandler, err error) {
 	var expiryTime time.Duration
 	if len(duration) > 0 {
 		expiryTime = duration[0]
diff --git a/mocks/ICacheInteractor.go b/mocks/ICacheInteractor.go
diff --git a/roundtriper.go b/roundtriper.go
@@ -23,15 +23,18 @@ const (
 	XHacheOrigin = "X-HTTPCache-Origin"
 )
 
-// RoundTrip custom plugable' struct of implementation of the http.RoundTripper
-type RoundTrip struct {
+// CacheHandler custom plugable' struct of implementation of the http.RoundTripper
+type CacheHandler struct {
 	DefaultRoundTripper http.RoundTripper
-	CacheInteractor     cache.Interactor
+	CacheInteractor     cache.ICacheInteractor
 }
 
 // NewRoundtrip will create an implementations of cache http roundtripper
-func NewRoundtrip(defaultRoundTripper http.RoundTripper, cacheActor cache.Interactor) http.RoundTripper {
-	return &RoundTrip{
+func NewRoundtrip(defaultRoundTripper http.RoundTripper, cacheActor cache.ICacheInteractor) *CacheHandler {
+	if cacheActor == nil {
+		log.Fatal("cache interactor is nil")
+	}
+	return &CacheHandler{
 		DefaultRoundTripper: defaultRoundTripper,
 		CacheInteractor:     cacheActor,
 	}
@@ -89,8 +92,9 @@ func validateTheCacheControl(req *http.Request, resp *http.Response) (validation
 }
 
 // RoundTrip the implementation of http.RoundTripper
-func (r *RoundTrip) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	if allowedFromCache(req.Header) {
+func (r *CacheHandler) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	allowCache := allowedFromCache(req.Header)
+	if allowCache {
 		cachedResp, cachedItem, cachedErr := getCachedResponse(r.CacheInteractor, req)
 		if cachedResp != nil && cachedErr == nil {
 			buildTheCachedResponseHeader(cachedResp, cachedItem, r.CacheInteractor.Origin())
@@ -102,19 +106,11 @@ func (r *RoundTrip) RoundTrip(req *http.Request) (resp *http.Response, err error
 		}
 	}
 
-	err = nil
 	resp, err = r.DefaultRoundTripper.RoundTrip(req)
 	if err != nil {
 		return
 	}
 
-	// Only cache the response of with Success Status
-	if resp.StatusCode >= http.StatusMultipleChoices ||
-		resp.StatusCode < http.StatusOK ||
-		resp.StatusCode == http.StatusNoContent {
-		return
-	}
-
 	validationResult, err := validateTheCacheControl(req, resp)
 	if err != nil {
 		return
@@ -138,7 +134,7 @@ func (r *RoundTrip) RoundTrip(req *http.Request) (resp *http.Response, err error
 	return
 }
 
-func storeRespToCache(cacheInteractor cache.Interactor, req *http.Request, resp *http.Response) (err error) {
+func storeRespToCache(cacheInteractor cache.ICacheInteractor, req *http.Request, resp *http.Response) (err error) {
 	cachedResp := cache.CachedResponse{
 		RequestMethod: req.Method,
 		RequestURI:    req.RequestURI,
@@ -151,11 +147,11 @@ func storeRespToCache(cacheInteractor cache.Interactor, req *http.Request, resp
 	}
 	cachedResp.DumpedResponse = dumpedResponse
 
-	err = cacheInteractor.Set(getCacheKey(req), cachedResp, 0)
+	err = cacheInteractor.Set(getCacheKey(req), cachedResp)
 	return
 }
 
-func getCachedResponse(cacheInteractor cache.Interactor, req *http.Request) (resp *http.Response, cachedResp cache.CachedResponse, err error) {
+func getCachedResponse(cacheInteractor cache.ICacheInteractor, req *http.Request) (resp *http.Response, cachedResp cache.CachedResponse, err error) {
 	cachedResp, err = cacheInteractor.Get(getCacheKey(req))
 	if err != nil {
 		return
diff --git a/roundtripper_test.go b/roundtripper_test.go
@@ -1,14 +1,47 @@
 package httpcache_test
 
 import (
+	"errors"
+	"fmt"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	"github.com/bxcodec/httpcache"
+	"github.com/bxcodec/httpcache/cache"
+	"github.com/bxcodec/httpcache/mocks"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
-func TestRoundtrip(t *testing.T) {
+func TestSetToCacheRoundtrip(t *testing.T) {
+	mockCacheInteractor := new(mocks.ICacheInteractor)
+	cachedResponse := cache.CachedResponse{}
+	mockCacheInteractor.On("Get", mock.AnythingOfType("string")).Once().Return(cachedResponse, errors.New("uknown error"))
+	mockCacheInteractor.On("Set", mock.AnythingOfType("string"), mock.Anything).Once().Return(nil)
 	client := &http.Client{}
-	client.Transport = httpcache.NewRoundtrip(client.Transport, nil)
+	client.Transport = httpcache.NewRoundtrip(http.DefaultTransport, mockCacheInteractor)
+	// HTTP GET 200
+	jsonResp := []byte(`{"message": "Hello World!"}`)
+	handler := func() (res http.Handler) {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			require.Equal(t, "/hello", r.RequestURI)
+			w.Header().Set("Content-Type", "application/json")
+			w.Header().Set("Cache-Control", "max-age=3600")
+			w.WriteHeader(http.StatusOK)
+			_, err := w.Write(jsonResp)
+			require.NoError(t, err)
+		})
+	}()
 
+	mockServer := httptest.NewServer(handler)
+	defer mockServer.Close()
+	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/hello", mockServer.URL), nil)
+	require.NoError(t, err)
+
+	resp, err := client.Do(req)
+	require.NoError(t, err)
+
+	require.Empty(t, resp.Header.Get(httpcache.XHacheOrigin))
+	mockCacheInteractor.AssertExpectations(t)
 }
diff --git a/sample/inmem/main.go b/sample/inmem/main.go

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ Short example:`
`45`	`45`
`46`	`46`	`// Inject the HTTP Client with httpcache`
`47`	`47`	`client := &http.Client{}`
`48`		`-err := httpcache.NewWithInmemoryCache(client, time.Second*60)`
	`48`	`+_, err := httpcache.NewWithInmemoryCache(client, time.Second*60)`
`49`	`49`	`if err != nil {`
`50`	`50`	`log.Fatal(err)`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,11 +21,12 @@ const (`
`21`	`21`	`// TODO (bxcodec): Add another storage type`
`22`	`22`	`)`
`23`	`23`
`24`		`-// Interactor ...`
`25`		`-type Interactor interface {`
`26`		`- Set(key string, value CachedResponse, duration time.Duration) error`
	`24`	`+// ICacheInteractor ...`
	`25`	`+type ICacheInteractor interface {`
	`26`	`+ Set(key string, value CachedResponse) error`
`27`	`27`	`Get(key string) (CachedResponse, error)`
`28`	`28`	`Delete(key string) error`
	`29`	`+ Flush() error`
`29`	`30`	`Origin() string`
`30`	`31`	`}`
`31`	`32`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`	`1`	`package inmem`
`2`	`2`
`3`	`3`	`import (`
`4`		`- "time"`
`5`		`-`
`6`	`4`	`memcache "github.com/bxcodec/gotcha/cache"`
`7`	`5`	`"github.com/bxcodec/httpcache/cache"`
`8`	`6`	`)`
`@@ -12,14 +10,13 @@ type inmemCache struct {`
`12`	`10`	`}`
`13`	`11`
`14`	`12`	`// NewCache will return the inmemory cache handler`
`15`		`-func NewCache(c memcache.Cache) cache.Interactor {`
	`13`	`+func NewCache(c memcache.Cache) cache.ICacheInteractor {`
`16`	`14`	`return &inmemCache{`
`17`	`15`	`cache: c,`
`18`	`16`	`}`
`19`	`17`	`}`
`20`	`18`
`21`		`-func (i *inmemCache) Set(key string, value cache.CachedResponse, duration time.Duration) (err error) {`
`22`		`- // TODO(bxcodec): add custom duration here based on user response result on the fly`
	`19`	`+func (i *inmemCache) Set(key string, value cache.CachedResponse) (err error) {`
`23`	`20`	`return i.cache.Set(key, value)`
`24`	`21`	`}`
`25`	`22`
`@@ -39,3 +36,7 @@ func (i *inmemCache) Delete(key string) (err error) {`
`39`	`36`	`func (i *inmemCache) Origin() string {`
`40`	`37`	`return cache.CacheStorageInMemory`
`41`	`38`	`}`
	`39`	`+`
	`40`	`+func (i *inmemCache) Flush() error {`
	`41`	`+ return i.cache.ClearCache()`
	`42`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ func TestCacheInMemory(t *testing.T) {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`// Try to SET item`
`29`		`- err := cacheObj.Set(testKey, testVal, time.Second*5)`
	`29`	`+ err := cacheObj.Set(testKey, testVal)`
`30`	`30`	`if err != nil {`
`31`	`31`	`t.Fatalf("expected %v, got %v", nil, err)`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,6 @@ func CachableObject(obj Object, rv ObjectResults) {`
`81`	`81`	`if !hasFreshness(obj.ReqDirectives, obj.RespDirectives, obj.RespHeaders, obj.RespExpiresHeader, obj.CacheIsPrivate) {`
`82`	`82`	`rv.OutReasons = append(rv.OutReasons, ReasonRequestMethodPOST)`
`83`	`83`	`}`
`84`		`-`
`85`	`84`	`case "PUT":`
`86`	`85`	`rv.OutReasons = append(rv.OutReasons, ReasonRequestMethodPUT)`
`87`	`86`