k-space/dex
Archived
11
0
Fork 0
Code Issues Pull Requests Packages Projects Activity

vendor: revendor

Browse Source
This commit is contained in:
Eric Chiang
2016-12-22 11:39:28 -08:00
parent d87a4c35b9
commit 1451213dd7
268 changed files with 484 additions and 59530 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
vendor/github.com/pquerna/cachecontrol/.travis.yml generated vendored
View File

@@ -1,10 +0,0 @@
language: go
install:
- go get -d -v ./...
- go get -u github.com/stretchr/testify/require
go:
- 1.5
- 1.6
- tip

108
vendor/github.com/pquerna/cachecontrol/README.md generated vendored
View File

@@ -1,108 +0,0 @@
# cachecontrol: HTTP Caching Parser and Interpretation
[![GoDoc][1]][2][![Build Status](https://travis-ci.org/pquerna/cachecontrol.svg?branch=master)](https://travis-ci.org/pquerna/cachecontrol)
[1]: https://godoc.org/github.com/pquerna/cachecontrol?status.svg
[2]: https://godoc.org/github.com/pquerna/cachecontrol
`cachecontrol` implements [RFC 7234](http://tools.ietf.org/html/rfc7234) __Hypertext Transfer Protocol (HTTP/1.1): Caching__. It does this by parsing the `Cache-Control` and other headers, providing information about requests and responses -- but `cachecontrol` does not implement an actual cache backend, just the control plane to make decisions about if a particular response is cachable.
# Usage
`cachecontrol.CachableResponse` returns an array of [reasons](https://godoc.org/github.com/pquerna/cachecontrol/cacheobject#Reason) why a response should not be cached and when it expires. In the case that `len(reasons) == 0`, the response is cachable according to the RFC. However, some people want non-compliant caches for various business use cases, so each reason is specifically named, so if your cache wants to cache `POST` requests, it can easily do that, but still be RFC compliant in other situations.
# Examples
## Can you cache Example.com?
```go
package main
import (
"github.com/pquerna/cachecontrol"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
req, _ := http.NewRequest("GET", "http://www.example.com/", nil)
res, _ := http.DefaultClient.Do(req)
_, _ = ioutil.ReadAll(res.Body)
reasons, expires, _ := cachecontrol.CachableResponse(req, res, cachecontrol.Options{})
fmt.Println("Reasons to not cache: ", reasons)
fmt.Println("Expiration: ", expires.String())
}
```
## Can I use this in a high performance caching server?
`cachecontrol` is divided into two packages: `cachecontrol` with a high level API, and a lower level `cacheobject` package. Use [Object](https://godoc.org/github.com/pquerna/cachecontrol/cacheobject#Object) in a high performance use case where you have previously parsed headers containing dates or would like to avoid memory allocations.
```go
package main
import (
"github.com/pquerna/cachecontrol/cacheobject"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
req, _ := http.NewRequest("GET", "http://www.example.com/", nil)
res, _ := http.DefaultClient.Do(req)
_, _ = ioutil.ReadAll(res.Body)
reqDir, _ := cacheobject.ParseRequestCacheControl(req.Header.Get("Cache-Control"))
resDir, _ := cacheobject.ParseResponseCacheControl(res.Header.Get("Cache-Control"))
expiresHeader, _ := http.ParseTime(res.Header.Get("Expires"))
dateHeader, _ := http.ParseTime(res.Header.Get("Date"))
lastModifiedHeader, _ := http.ParseTime(res.Header.Get("Last-Modified"))
obj := cacheobject.Object{
RespDirectives: resDir,
RespHeaders: res.Header,
RespStatusCode: res.StatusCode,
RespExpiresHeader: expiresHeader,
RespDateHeader: dateHeader,
RespLastModifiedHeader: lastModifiedHeader,
ReqDirectives: reqDir,
ReqHeaders: req.Header,
ReqMethod: req.Method,
NowUTC: time.Now().UTC(),
}
rv := cacheobject.ObjectResults{}
cacheobject.CachableObject(&obj, &rv)
cacheobject.ExpirationObject(&obj, &rv)
fmt.Println("Errors: ", rv.OutErr)
fmt.Println("Reasons to not cache: ", rv.OutReasons)
fmt.Println("Warning headers to add: ", rv.OutWarnings)
fmt.Println("Expiration: ", rv.OutExpirationTime.String())
}
```
## Improvements, bugs, adding features, and taking cachecontrol new directions!
Please [open issues in Github](https://github.com/pquerna/cachecontrol/issues) for ideas, bugs, and general thoughts. Pull requests are of course preferred :)
# Credits
`cachecontrol` has recieved significant contributions from:
* [Paul Querna](https://github.com/pquerna)
## License
`cachecontrol` is licensed under the [Apache License, Version 2.0](./LICENSE)

111
vendor/github.com/pquerna/cachecontrol/api_test.go generated vendored
View File

@@ -1,111 +0,0 @@
/**
* Copyright 2015 Paul Querna
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package cachecontrol
import (
"github.com/pquerna/cachecontrol/cacheobject"
"github.com/stretchr/testify/require"
"fmt"
"io/ioutil"
"net/http"
"net/http/httptest"
"testing"
"time"
)
func roundTrip(t *testing.T, fnc func(w http.ResponseWriter, r *http.Request)) (*http.Request, *http.Response) {
ts := httptest.NewServer(http.HandlerFunc(fnc))
defer ts.Close()
req, err := http.NewRequest("GET", ts.URL, nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
_, err = ioutil.ReadAll(res.Body)
res.Body.Close()
require.NoError(t, err)
return req, res
}
func TestCachableResponsePublic(t *testing.T) {
req, res := roundTrip(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "public")
w.Header().Set("Last-Modified",
time.Now().UTC().Add(time.Duration(time.Hour*-5)).Format(http.TimeFormat))
fmt.Fprintln(w, `{}`)
})
opts := Options{}
reasons, expires, err := CachableResponse(req, res, opts)
require.NoError(t, err)
require.Len(t, reasons, 0)
require.WithinDuration(t,
time.Now().UTC().Add(time.Duration(float64(time.Hour)*0.5)),
expires,
10*time.Second)
}
func TestCachableResponsePrivate(t *testing.T) {
req, res := roundTrip(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "private")
fmt.Fprintln(w, `{}`)
})
opts := Options{}
reasons, expires, err := CachableResponse(req, res, opts)
require.NoError(t, err)
require.Len(t, reasons, 1)
require.Equal(t, reasons[0], cacheobject.ReasonResponsePrivate)
require.Equal(t, time.Time{}, expires)
opts.PrivateCache = true
reasons, expires, err = CachableResponse(req, res, opts)
require.NoError(t, err)
require.Len(t, reasons, 0)
require.Equal(t, time.Time{}, expires)
}
func TestResponseWriter(t *testing.T) {
var resp http.ResponseWriter
var req *http.Request
_, _ = roundTrip(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "private")
fmt.Fprintln(w, `{}`)
resp = w
req = r
})
opts := Options{}
reasons, expires, err := CachableResponseWriter(req, 200, resp, opts)
require.NoError(t, err)
require.Len(t, reasons, 1)
require.Equal(t, reasons[0], cacheobject.ReasonResponsePrivate)
require.Equal(t, time.Time{}, expires)
opts.PrivateCache = true
reasons, expires, err = CachableResponseWriter(req, 200, resp, opts)
require.NoError(t, err)
require.Len(t, reasons, 0)
require.Equal(t, time.Time{}, expires)
}

413
vendor/github.com/pquerna/cachecontrol/cacheobject/directive_test.go generated vendored
View File

@@ -1,413 +0,0 @@
/**
* Copyright 2015 Paul Querna
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package cacheobject
import (
"github.com/stretchr/testify/require"
"fmt"
"math"
"strconv"
"testing"
)
func TestMaxAge(t *testing.T) {
cd, err := ParseResponseCacheControl("")
require.NoError(t, err)
require.Equal(t, cd.MaxAge, DeltaSeconds(-1))
cd, err = ParseResponseCacheControl("max-age")
require.Error(t, err)
cd, err = ParseResponseCacheControl("max-age=20")
require.NoError(t, err)
require.Equal(t, cd.MaxAge, DeltaSeconds(20))
cd, err = ParseResponseCacheControl("max-age=0")
require.NoError(t, err)
require.Equal(t, cd.MaxAge, DeltaSeconds(0))
cd, err = ParseResponseCacheControl("max-age=-1")
require.Error(t, err)
}
func TestSMaxAge(t *testing.T) {
cd, err := ParseResponseCacheControl("")
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(-1))
cd, err = ParseResponseCacheControl("s-maxage")
require.Error(t, err)
cd, err = ParseResponseCacheControl("s-maxage=20")
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(20))
cd, err = ParseResponseCacheControl("s-maxage=0")
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(0))
cd, err = ParseResponseCacheControl("s-maxage=-1")
require.Error(t, err)
}
func TestResNoCache(t *testing.T) {
cd, err := ParseResponseCacheControl("")
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(-1))
cd, err = ParseResponseCacheControl("no-cache")
require.NoError(t, err)
require.Equal(t, cd.NoCachePresent, true)
require.Equal(t, len(cd.NoCache), 0)
cd, err = ParseResponseCacheControl("no-cache=MyThing")
require.NoError(t, err)
require.Equal(t, cd.NoCachePresent, true)
require.Equal(t, len(cd.NoCache), 1)
}
func TestResSpaceOnly(t *testing.T) {
cd, err := ParseResponseCacheControl(" ")
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(-1))
}
func TestResTabOnly(t *testing.T) {
cd, err := ParseResponseCacheControl("\t")
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(-1))
}
func TestResPrivateExtensionQuoted(t *testing.T) {
cd, err := ParseResponseCacheControl(`private="Set-Cookie,Request-Id" public`)
require.NoError(t, err)
require.Equal(t, cd.Public, true)
require.Equal(t, cd.PrivatePresent, true)
require.Equal(t, len(cd.Private), 2)
require.Equal(t, len(cd.Extensions), 0)
require.Equal(t, cd.Private["Set-Cookie"], true)
require.Equal(t, cd.Private["Request-Id"], true)
}
func TestResCommaFollowingBare(t *testing.T) {
cd, err := ParseResponseCacheControl(`public, max-age=500`)
require.NoError(t, err)
require.Equal(t, cd.Public, true)
require.Equal(t, cd.MaxAge, DeltaSeconds(500))
require.Equal(t, cd.PrivatePresent, false)
require.Equal(t, len(cd.Extensions), 0)
}
func TestResCommaFollowingKV(t *testing.T) {
cd, err := ParseResponseCacheControl(`max-age=500, public`)
require.NoError(t, err)
require.Equal(t, cd.Public, true)
require.Equal(t, cd.MaxAge, DeltaSeconds(500))
require.Equal(t, cd.PrivatePresent, false)
require.Equal(t, len(cd.Extensions), 0)
}
func TestResPrivateTrailingComma(t *testing.T) {
cd, err := ParseResponseCacheControl(`private=Set-Cookie, public`)
require.NoError(t, err)
require.Equal(t, cd.Public, true)
require.Equal(t, cd.PrivatePresent, true)
require.Equal(t, len(cd.Private), 1)
require.Equal(t, len(cd.Extensions), 0)
require.Equal(t, cd.Private["Set-Cookie"], true)
}
func TestResPrivateExtension(t *testing.T) {
cd, err := ParseResponseCacheControl(`private=Set-Cookie,Request-Id public`)
require.NoError(t, err)
require.Equal(t, cd.Public, true)
require.Equal(t, cd.PrivatePresent, true)
require.Equal(t, len(cd.Private), 2)
require.Equal(t, len(cd.Extensions), 0)
require.Equal(t, cd.Private["Set-Cookie"], true)
require.Equal(t, cd.Private["Request-Id"], true)
}
func TestResMultipleNoCacheTabExtension(t *testing.T) {
cd, err := ParseResponseCacheControl("no-cache " + "\t" + "no-cache=Mything aasdfdsfa")
require.NoError(t, err)
require.Equal(t, cd.NoCachePresent, true)
require.Equal(t, len(cd.NoCache), 1)
require.Equal(t, len(cd.Extensions), 1)
require.Equal(t, cd.NoCache["Mything"], true)
}
func TestResExtensionsEmptyQuote(t *testing.T) {
cd, err := ParseResponseCacheControl(`foo="" bar="hi"`)
require.NoError(t, err)
require.Equal(t, cd.SMaxAge, DeltaSeconds(-1))
require.Equal(t, len(cd.Extensions), 2)
require.Contains(t, cd.Extensions, "bar=hi")
require.Contains(t, cd.Extensions, "foo=")
}
func TestResQuoteMismatch(t *testing.T) {
cd, err := ParseResponseCacheControl(`foo="`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrQuoteMismatch)
}
func TestResMustRevalidateNoArgs(t *testing.T) {
cd, err := ParseResponseCacheControl(`must-revalidate=234`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrMustRevalidateNoArgs)
}
func TestResNoTransformNoArgs(t *testing.T) {
cd, err := ParseResponseCacheControl(`no-transform="xxx"`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrNoTransformNoArgs)
}
func TestResNoStoreNoArgs(t *testing.T) {
cd, err := ParseResponseCacheControl(`no-store=""`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrNoStoreNoArgs)
}
func TestResProxyRevalidateNoArgs(t *testing.T) {
cd, err := ParseResponseCacheControl(`proxy-revalidate=23432`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrProxyRevalidateNoArgs)
}
func TestResPublicNoArgs(t *testing.T) {
cd, err := ParseResponseCacheControl(`public=999Vary`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrPublicNoArgs)
}
func TestResMustRevalidate(t *testing.T) {
cd, err := ParseResponseCacheControl(`must-revalidate`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.MustRevalidate, true)
}
func TestResNoTransform(t *testing.T) {
cd, err := ParseResponseCacheControl(`no-transform`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.NoTransform, true)
}
func TestResNoStore(t *testing.T) {
cd, err := ParseResponseCacheControl(`no-store`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.NoStore, true)
}
func TestResProxyRevalidate(t *testing.T) {
cd, err := ParseResponseCacheControl(`proxy-revalidate`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.ProxyRevalidate, true)
}
func TestResPublic(t *testing.T) {
cd, err := ParseResponseCacheControl(`public`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.Public, true)
}
func TestResPrivate(t *testing.T) {
cd, err := ParseResponseCacheControl(`private`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Len(t, cd.Private, 0)
require.Equal(t, cd.PrivatePresent, true)
}
func TestParseDeltaSecondsZero(t *testing.T) {
ds, err := parseDeltaSeconds("0")
require.NoError(t, err)
require.Equal(t, ds, DeltaSeconds(0))
}
func TestParseDeltaSecondsLarge(t *testing.T) {
ds, err := parseDeltaSeconds(fmt.Sprintf("%d", int64(math.MaxInt32)*2))
require.NoError(t, err)
require.Equal(t, ds, DeltaSeconds(math.MaxInt32))
}
func TestParseDeltaSecondsVeryLarge(t *testing.T) {
ds, err := parseDeltaSeconds(fmt.Sprintf("%d", math.MaxInt64))
require.NoError(t, err)
require.Equal(t, ds, DeltaSeconds(math.MaxInt32))
}
func TestParseDeltaSecondsNegative(t *testing.T) {
ds, err := parseDeltaSeconds("-60")
require.Error(t, err)
require.Equal(t, DeltaSeconds(-1), ds)
}
func TestReqNoCacheNoArgs(t *testing.T) {
cd, err := ParseRequestCacheControl(`no-cache=234`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrNoCacheNoArgs)
}
func TestReqNoStoreNoArgs(t *testing.T) {
cd, err := ParseRequestCacheControl(`no-store=,,x`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrNoStoreNoArgs)
}
func TestReqNoTransformNoArgs(t *testing.T) {
cd, err := ParseRequestCacheControl(`no-transform=akx`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrNoTransformNoArgs)
}
func TestReqOnlyIfCachedNoArgs(t *testing.T) {
cd, err := ParseRequestCacheControl(`only-if-cached=no-store`)
require.Error(t, err)
require.Nil(t, cd)
require.Equal(t, err, ErrOnlyIfCachedNoArgs)
}
func TestReqMaxAge(t *testing.T) {
cd, err := ParseRequestCacheControl(`max-age=99999`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.MaxAge, DeltaSeconds(99999))
require.Equal(t, cd.MaxStale, DeltaSeconds(-1))
}
func TestReqMaxStale(t *testing.T) {
cd, err := ParseRequestCacheControl(`max-stale=99999`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.MaxStale, DeltaSeconds(99999))
require.Equal(t, cd.MaxAge, DeltaSeconds(-1))
require.Equal(t, cd.MinFresh, DeltaSeconds(-1))
}
func TestReqMaxAgeBroken(t *testing.T) {
cd, err := ParseRequestCacheControl(`max-age`)
require.Error(t, err)
require.Equal(t, ErrMaxAgeDeltaSeconds, err)
require.Nil(t, cd)
}
func TestReqMaxStaleBroken(t *testing.T) {
cd, err := ParseRequestCacheControl(`max-stale`)
require.Error(t, err)
require.Equal(t, ErrMaxStaleDeltaSeconds, err)
require.Nil(t, cd)
}
func TestReqMinFresh(t *testing.T) {
cd, err := ParseRequestCacheControl(`min-fresh=99999`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.MinFresh, DeltaSeconds(99999))
require.Equal(t, cd.MaxAge, DeltaSeconds(-1))
require.Equal(t, cd.MaxStale, DeltaSeconds(-1))
}
func TestReqMinFreshBroken(t *testing.T) {
cd, err := ParseRequestCacheControl(`min-fresh`)
require.Error(t, err)
require.Equal(t, ErrMinFreshDeltaSeconds, err)
require.Nil(t, cd)
}
func TestReqMinFreshJumk(t *testing.T) {
cd, err := ParseRequestCacheControl(`min-fresh=a99a`)
require.Error(t, err)
// need a struct cast in require... nothing exists?
// require.Implements(t, (*strconv.NumError)(nil), err)
if numError, ok := err.(*strconv.NumError); ok {
require.Equal(t, strconv.ErrSyntax, numError.Err)
} else {
require.True(t, ok, "Error was not a *strconv.NumError")
}
require.Nil(t, cd)
}
func TestReqExtensions(t *testing.T) {
cd, err := ParseRequestCacheControl(`min-fresh=99999 foobar=1 cats`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.MinFresh, DeltaSeconds(99999))
require.Equal(t, cd.MaxAge, DeltaSeconds(-1))
require.Equal(t, cd.MaxStale, DeltaSeconds(-1))
require.Len(t, cd.Extensions, 2)
require.Contains(t, cd.Extensions, "foobar=1")
require.Contains(t, cd.Extensions, "cats")
}
func TestReqMultiple(t *testing.T) {
cd, err := ParseRequestCacheControl(`no-store no-transform`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.NoStore, true)
require.Equal(t, cd.NoTransform, true)
require.Equal(t, cd.OnlyIfCached, false)
require.Len(t, cd.Extensions, 0)
}
func TestReqMultipleComma(t *testing.T) {
cd, err := ParseRequestCacheControl(`no-cache,only-if-cached`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.NoCache, true)
require.Equal(t, cd.NoStore, false)
require.Equal(t, cd.NoTransform, false)
require.Equal(t, cd.OnlyIfCached, true)
require.Len(t, cd.Extensions, 0)
}
func TestReqLeadingComma(t *testing.T) {
cd, err := ParseRequestCacheControl(`,no-cache`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Len(t, cd.Extensions, 0)
require.Equal(t, cd.NoCache, true)
require.Equal(t, cd.NoStore, false)
require.Equal(t, cd.NoTransform, false)
require.Equal(t, cd.OnlyIfCached, false)
}
func TestReqMinFreshQuoted(t *testing.T) {
cd, err := ParseRequestCacheControl(`min-fresh="99999"`)
require.NoError(t, err)
require.NotNil(t, cd)
require.Equal(t, cd.MinFresh, DeltaSeconds(99999))
require.Equal(t, cd.MaxAge, DeltaSeconds(-1))
require.Equal(t, cd.MaxStale, DeltaSeconds(-1))
}

77
vendor/github.com/pquerna/cachecontrol/cacheobject/object_http_test.go generated vendored
View File

@@ -1,77 +0,0 @@
/**
* Copyright 2015 Paul Querna
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package cacheobject
import (
"github.com/stretchr/testify/require"
"fmt"
"io/ioutil"
"net/http"
"net/http/httptest"
"testing"
"time"
)
func roundTrip(t *testing.T, fnc func(w http.ResponseWriter, r *http.Request)) (*http.Request, *http.Response) {
ts := httptest.NewServer(http.HandlerFunc(fnc))
defer ts.Close()
req, err := http.NewRequest("GET", ts.URL, nil)
require.NoError(t, err)
res, err := http.DefaultClient.Do(req)
require.NoError(t, err)
_, err = ioutil.ReadAll(res.Body)
res.Body.Close()
require.NoError(t, err)
return req, res
}
func TestCachableResponsePublic(t *testing.T) {
req, res := roundTrip(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "public")
w.Header().Set("Last-Modified",
time.Now().UTC().Add(time.Duration(time.Hour*-5)).Format(http.TimeFormat))
fmt.Fprintln(w, `{}`)
})
reasons, expires, err := UsingRequestResponse(req, res.StatusCode, res.Header, false)
require.NoError(t, err)
require.Len(t, reasons, 0)
require.WithinDuration(t,
time.Now().UTC().Add(time.Duration(float64(time.Hour)*0.5)),
expires,
10*time.Second)
}
func TestCachableResponseNoHeaders(t *testing.T) {
req, res := roundTrip(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
fmt.Fprintln(w, `{}`)
})
reasons, expires, err := UsingRequestResponse(req, res.StatusCode, res.Header, false)
require.NoError(t, err)
require.Len(t, reasons, 0)
require.True(t, expires.IsZero())
}

394
vendor/github.com/pquerna/cachecontrol/cacheobject/object_test.go generated vendored
View File

@@ -1,394 +0,0 @@
/**
* Copyright 2015 Paul Querna
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package cacheobject
import (
"github.com/stretchr/testify/require"
"net/http"
"testing"
"time"
)
func TestCachableStatusCode(t *testing.T) {
ok := []int{200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501}
for _, v := range ok {
require.True(t, cachableStatusCode(v), "status code should be cacheable: %d", v)
}
notok := []int{201, 429, 500, 504}
for _, v := range notok {
require.False(t, cachableStatusCode(v), "status code should not be cachable: %d", v)
}
}
func fill(t *testing.T, now time.Time) Object {
RespDirectives, err := ParseResponseCacheControl("")
require.NoError(t, err)
ReqDirectives, err := ParseRequestCacheControl("")
require.NoError(t, err)
obj := Object{
RespDirectives: RespDirectives,
RespHeaders: http.Header{},
RespStatusCode: 200,
RespDateHeader: now,
ReqDirectives: ReqDirectives,
ReqHeaders: http.Header{},
ReqMethod: "GET",
NowUTC: now,
}
return obj
}
func TestGETPrivate(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
RespDirectives, err := ParseResponseCacheControl("private")
require.NoError(t, err)
obj.RespDirectives = RespDirectives
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonResponsePrivate)
}
func TestGETPrivateWithPrivateCache(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
RespDirectives, err := ParseResponseCacheControl("private")
require.NoError(t, err)
obj.CacheIsPrivate = true
obj.RespDirectives = RespDirectives
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
}
func TestUncachableMethods(t *testing.T) {
type methodPair struct {
m string
r Reason
}
tc := []methodPair{
{"PUT", ReasonRequestMethodPUT},
{"DELETE", ReasonRequestMethodDELETE},
{"CONNECT", ReasonRequestMethodCONNECT},
{"OPTIONS", ReasonRequestMethodOPTIONS},
{"CONNECT", ReasonRequestMethodCONNECT},
{"TRACE", ReasonRequestMethodTRACE},
{"MADEUP", ReasonRequestMethodUnkown},
}
for _, mp := range tc {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = mp.m
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, mp.r)
}
}
func TestHEAD(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "HEAD"
obj.RespLastModifiedHeader = now.Add(time.Hour * -1)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
ExpirationObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
require.False(t, rv.OutExpirationTime.IsZero())
}
func TestHEADLongLastModified(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "HEAD"
obj.RespLastModifiedHeader = now.Add(time.Hour * -70000)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
ExpirationObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
require.False(t, rv.OutExpirationTime.IsZero())
require.WithinDuration(t, now.Add(twentyFourHours), rv.OutExpirationTime, time.Second*60)
}
func TestNonCachablePOST(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "POST"
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonRequestMethodPOST)
}
func TestCachablePOSTExpiresHeader(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "POST"
obj.RespExpiresHeader = now.Add(time.Hour * 1)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
}
func TestCachablePOSTSMax(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "POST"
obj.RespDirectives.SMaxAge = DeltaSeconds(900)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
}
func TestNonCachablePOSTSMax(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "POST"
obj.CacheIsPrivate = true
obj.RespDirectives.SMaxAge = DeltaSeconds(900)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonRequestMethodPOST)
}
func TestCachablePOSTMax(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "POST"
obj.RespDirectives.MaxAge = DeltaSeconds(9000)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
}
func TestPUTs(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "PUT"
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonRequestMethodPUT)
}
func TestPUTWithExpires(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqMethod = "PUT"
obj.RespExpiresHeader = now.Add(time.Hour * 1)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonRequestMethodPUT)
}
func TestAuthorization(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqHeaders.Set("Authorization", "bearer random")
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonRequestAuthorizationHeader)
}
func TestCachableAuthorization(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqHeaders.Set("Authorization", "bearer random")
obj.RespDirectives.Public = true
obj.RespDirectives.MaxAge = DeltaSeconds(300)
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.NoError(t, rv.OutErr)
require.Len(t, rv.OutReasons, 0)
}
func TestRespNoStore(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.RespDirectives.NoStore = true
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonResponseNoStore)
}
func TestReqNoStore(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.ReqDirectives.NoStore = true
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonRequestNoStore)
}
func TestResp500(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.RespStatusCode = 500
rv := ObjectResults{}
CachableObject(&obj, &rv)
require.Len(t, rv.OutReasons, 1)
require.Contains(t, rv.OutReasons, ReasonResponseUncachableByDefault)
}
func TestExpirationSMaxShared(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.RespDirectives.SMaxAge = DeltaSeconds(60)
rv := ObjectResults{}
ExpirationObject(&obj, &rv)
require.Len(t, rv.OutWarnings, 0)
require.WithinDuration(t, now.Add(time.Second*60), rv.OutExpirationTime, time.Second*1)
}
func TestExpirationSMaxPrivate(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.CacheIsPrivate = true
obj.RespDirectives.SMaxAge = DeltaSeconds(60)
rv := ObjectResults{}
ExpirationObject(&obj, &rv)
require.Len(t, rv.OutWarnings, 0)
require.True(t, rv.OutExpirationTime.IsZero())
}
func TestExpirationMax(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
obj.RespDirectives.MaxAge = DeltaSeconds(60)
rv := ObjectResults{}
ExpirationObject(&obj, &rv)
require.Len(t, rv.OutWarnings, 0)
require.WithinDuration(t, now.Add(time.Second*60), rv.OutExpirationTime, time.Second*1)
}
func TestExpirationMaxAndSMax(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
// cache should select the SMax age since this is a shared cache.
obj.RespDirectives.MaxAge = DeltaSeconds(60)
obj.RespDirectives.SMaxAge = DeltaSeconds(900)
rv := ObjectResults{}
ExpirationObject(&obj, &rv)
require.Len(t, rv.OutWarnings, 0)
require.WithinDuration(t, now.Add(time.Second*900), rv.OutExpirationTime, time.Second*1)
}
func TestExpirationExpires(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
// cache should select the SMax age since this is a shared cache.
obj.RespExpiresHeader = now.Add(time.Second * 1500)
rv := ObjectResults{}
ExpirationObject(&obj, &rv)
require.Len(t, rv.OutWarnings, 0)
require.WithinDuration(t, now.Add(time.Second*1500), rv.OutExpirationTime, time.Second*1)
}
func TestExpirationExpiresNoServerDate(t *testing.T) {
now := time.Now().UTC()
obj := fill(t, now)
// cache should select the SMax age since this is a shared cache.
obj.RespDateHeader = time.Time{}
obj.RespExpiresHeader = now.Add(time.Second * 1500)
rv := ObjectResults{}
ExpirationObject(&obj, &rv)
require.Len(t, rv.OutWarnings, 0)
require.WithinDuration(t, now.Add(time.Second*1500), rv.OutExpirationTime, time.Second*1)
}