Bump libcompose and its dependencies

2025-08-31 22:32:14 +00:00 · 2016-05-23 17:22:40 -07:00
parent c18cd26e78
commit 50de80d09a
1109 changed files with 35052 additions and 125685 deletions
--- a/vendor/github.com/docker/distribution/registry/client/auth/authchallenge.go
+++ b/vendor/github.com/docker/distribution/registry/client/auth/authchallenge.go
@@ -25,7 +25,7 @@ type Challenge struct {
 type ChallengeManager interface {
 	// GetChallenges returns the challenges for the given
 	// endpoint URL.
-	GetChallenges(endpoint string) ([]Challenge, error)
+	GetChallenges(endpoint url.URL) ([]Challenge, error)

 	// AddResponse adds the response to the challenge
 	// manager. The challenges will be parsed out of
@@ -48,8 +48,10 @@ func NewSimpleChallengeManager() ChallengeManager {

 type simpleChallengeManager map[string][]Challenge

-func (m simpleChallengeManager) GetChallenges(endpoint string) ([]Challenge, error) {
-	challenges := m[endpoint]
+func (m simpleChallengeManager) GetChallenges(endpoint url.URL) ([]Challenge, error) {
+	endpoint.Host = strings.ToLower(endpoint.Host)
+
+	challenges := m[endpoint.String()]
 	return challenges, nil
 }

@@ -60,11 +62,10 @@ func (m simpleChallengeManager) AddResponse(resp *http.Response) error {
 	}
 	urlCopy := url.URL{
 		Path:   resp.Request.URL.Path,
-		Host:   resp.Request.URL.Host,
+		Host:   strings.ToLower(resp.Request.URL.Host),
 		Scheme: resp.Request.URL.Scheme,
 	}
 	m[urlCopy.String()] = challenges
-
 	return nil
 }

--- a/vendor/github.com/docker/distribution/registry/client/auth/authchallenge_test.go
+++ b/vendor/github.com/docker/distribution/registry/client/auth/authchallenge_test.go
@@ -1,38 +0,0 @@
-package auth
-
-import (
-	"net/http"
-	"testing"
-)
-
-func TestAuthChallengeParse(t *testing.T) {
-	header := http.Header{}
-	header.Add("WWW-Authenticate", `Bearer realm="https://auth.example.com/token",service="registry.example.com",other=fun,slashed="he\"\l\lo"`)
-
-	challenges := parseAuthHeader(header)
-	if len(challenges) != 1 {
-		t.Fatalf("Unexpected number of auth challenges: %d, expected 1", len(challenges))
-	}
-	challenge := challenges[0]
-
-	if expected := "bearer"; challenge.Scheme != expected {
-		t.Fatalf("Unexpected scheme: %s, expected: %s", challenge.Scheme, expected)
-	}
-
-	if expected := "https://auth.example.com/token"; challenge.Parameters["realm"] != expected {
-		t.Fatalf("Unexpected param: %s, expected: %s", challenge.Parameters["realm"], expected)
-	}
-
-	if expected := "registry.example.com"; challenge.Parameters["service"] != expected {
-		t.Fatalf("Unexpected param: %s, expected: %s", challenge.Parameters["service"], expected)
-	}
-
-	if expected := "fun"; challenge.Parameters["other"] != expected {
-		t.Fatalf("Unexpected param: %s, expected: %s", challenge.Parameters["other"], expected)
-	}
-
-	if expected := "he\"llo"; challenge.Parameters["slashed"] != expected {
-		t.Fatalf("Unexpected param: %s, expected: %s", challenge.Parameters["slashed"], expected)
-	}
-
-}
--- a/vendor/github.com/docker/distribution/registry/client/auth/session.go
+++ b/vendor/github.com/docker/distribution/registry/client/auth/session.go
@@ -15,6 +15,18 @@ import (
 	"github.com/docker/distribution/registry/client/transport"
 )

+var (
+	// ErrNoBasicAuthCredentials is returned if a request can't be authorized with
+	// basic auth due to lack of credentials.
+	ErrNoBasicAuthCredentials = errors.New("no basic auth credentials")
+
+	// ErrNoToken is returned if a request is successful but the body does not
+	// contain an authorization token.
+	ErrNoToken = errors.New("authorization server did not include a token in the response")
+)
+
+const defaultClientID = "registry-client"
+
 // AuthenticationHandler is an interface for authorizing a request from
 // params from a "WWW-Authenicate" header for a single scheme.
 type AuthenticationHandler interface {
@@ -32,6 +44,14 @@ type AuthenticationHandler interface {
 type CredentialStore interface {
 	// Basic returns basic auth for the given URL
 	Basic(*url.URL) (string, string)
+
+	// RefreshToken returns a refresh token for the
+	// given URL and service
+	RefreshToken(*url.URL, string) string
+
+	// SetRefreshToken sets the refresh token if none
+	// is provided for the given url and service
+	SetRefreshToken(realm *url.URL, service, token string)
 }

 // NewAuthorizer creates an authorizer which can handle multiple authentication
@@ -63,9 +83,7 @@ func (ea *endpointAuthorizer) ModifyRequest(req *http.Request) error {
 		Path:   req.URL.Path[:v2Root+4],
 	}

-	pingEndpoint := ping.String()
-
-	challenges, err := ea.challenges.GetChallenges(pingEndpoint)
+	challenges, err := ea.challenges.GetChallenges(ping)
 	if err != nil {
 		return err
 	}
@@ -101,27 +119,47 @@ type clock interface {
 type tokenHandler struct {
 	header    http.Header
 	creds     CredentialStore
-	scope     tokenScope
 	transport http.RoundTripper
 	clock     clock

+	offlineAccess bool
+	forceOAuth    bool
+	clientID      string
+	scopes        []Scope
+
 	tokenLock       sync.Mutex
 	tokenCache      string
 	tokenExpiration time.Time
-
-	additionalScopes map[string]struct{}
 }

-// tokenScope represents the scope at which a token will be requested.
-// This represents a specific action on a registry resource.
-type tokenScope struct {
-	Resource string
-	Scope    string
-	Actions  []string
+// Scope is a type which is serializable to a string
+// using the allow scope grammar.
+type Scope interface {
+	String() string
 }

-func (ts tokenScope) String() string {
-	return fmt.Sprintf("%s:%s:%s", ts.Resource, ts.Scope, strings.Join(ts.Actions, ","))
+// RepositoryScope represents a token scope for access
+// to a repository.
+type RepositoryScope struct {
+	Repository string
+	Actions    []string
+}
+
+// String returns the string representation of the repository
+// using the scope grammar
+func (rs RepositoryScope) String() string {
+	return fmt.Sprintf("repository:%s:%s", rs.Repository, strings.Join(rs.Actions, ","))
+}
+
+// TokenHandlerOptions is used to configure a new token handler
+type TokenHandlerOptions struct {
+	Transport   http.RoundTripper
+	Credentials CredentialStore
+
+	OfflineAccess bool
+	ForceOAuth    bool
+	ClientID      string
+	Scopes        []Scope
 }

 // An implementation of clock for providing real time data.
@@ -133,22 +171,33 @@ func (realClock) Now() time.Time { return time.Now() }
 // NewTokenHandler creates a new AuthenicationHandler which supports
 // fetching tokens from a remote token server.
 func NewTokenHandler(transport http.RoundTripper, creds CredentialStore, scope string, actions ...string) AuthenticationHandler {
-	return newTokenHandler(transport, creds, realClock{}, scope, actions...)
+	// Create options...
+	return NewTokenHandlerWithOptions(TokenHandlerOptions{
+		Transport:   transport,
+		Credentials: creds,
+		Scopes: []Scope{
+			RepositoryScope{
+				Repository: scope,
+				Actions:    actions,
+			},
+		},
+	})
 }

-// newTokenHandler exposes the option to provide a clock to manipulate time in unit testing.
-func newTokenHandler(transport http.RoundTripper, creds CredentialStore, c clock, scope string, actions ...string) AuthenticationHandler {
-	return &tokenHandler{
-		transport: transport,
-		creds:     creds,
-		clock:     c,
-		scope: tokenScope{
-			Resource: "repository",
-			Scope:    scope,
-			Actions:  actions,
-		},
-		additionalScopes: map[string]struct{}{},
+// NewTokenHandlerWithOptions creates a new token handler using the provided
+// options structure.
+func NewTokenHandlerWithOptions(options TokenHandlerOptions) AuthenticationHandler {
+	handler := &tokenHandler{
+		transport:     options.Transport,
+		creds:         options.Credentials,
+		offlineAccess: options.OfflineAccess,
+		forceOAuth:    options.ForceOAuth,
+		clientID:      options.ClientID,
+		scopes:        options.Scopes,
+		clock:         realClock{},
 	}
+
+	return handler
 }

 func (th *tokenHandler) client() *http.Client {
@@ -165,88 +214,162 @@ func (th *tokenHandler) Scheme() string {
 func (th *tokenHandler) AuthorizeRequest(req *http.Request, params map[string]string) error {
 	var additionalScopes []string
 	if fromParam := req.URL.Query().Get("from"); fromParam != "" {
-		additionalScopes = append(additionalScopes, tokenScope{
-			Resource: "repository",
-			Scope:    fromParam,
-			Actions:  []string{"pull"},
+		additionalScopes = append(additionalScopes, RepositoryScope{
+			Repository: fromParam,
+			Actions:    []string{"pull"},
 		}.String())
 	}
-	if err := th.refreshToken(params, additionalScopes...); err != nil {
+
+	token, err := th.getToken(params, additionalScopes...)
+	if err != nil {
 		return err
 	}

-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", th.tokenCache))
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

 	return nil
 }

-func (th *tokenHandler) refreshToken(params map[string]string, additionalScopes ...string) error {
+func (th *tokenHandler) getToken(params map[string]string, additionalScopes ...string) (string, error) {
 	th.tokenLock.Lock()
 	defer th.tokenLock.Unlock()
+	scopes := make([]string, 0, len(th.scopes)+len(additionalScopes))
+	for _, scope := range th.scopes {
+		scopes = append(scopes, scope.String())
+	}
 	var addedScopes bool
 	for _, scope := range additionalScopes {
-		if _, ok := th.additionalScopes[scope]; !ok {
-			th.additionalScopes[scope] = struct{}{}
-			addedScopes = true
-		}
+		scopes = append(scopes, scope)
+		addedScopes = true
 	}
+
 	now := th.clock.Now()
 	if now.After(th.tokenExpiration) || addedScopes {
-		tr, err := th.fetchToken(params)
+		token, expiration, err := th.fetchToken(params, scopes)
 		if err != nil {
-			return err
+			return "", err
 		}
-		th.tokenCache = tr.Token
-		th.tokenExpiration = tr.IssuedAt.Add(time.Duration(tr.ExpiresIn) * time.Second)
+
+		// do not update cache for added scope tokens
+		if !addedScopes {
+			th.tokenCache = token
+			th.tokenExpiration = expiration
+		}
+
+		return token, nil
 	}

-	return nil
+	return th.tokenCache, nil
 }

-type tokenResponse struct {
-	Token       string    `json:"token"`
-	AccessToken string    `json:"access_token"`
-	ExpiresIn   int       `json:"expires_in"`
-	IssuedAt    time.Time `json:"issued_at"`
+type postTokenResponse struct {
+	AccessToken  string    `json:"access_token"`
+	RefreshToken string    `json:"refresh_token"`
+	ExpiresIn    int       `json:"expires_in"`
+	IssuedAt     time.Time `json:"issued_at"`
+	Scope        string    `json:"scope"`
 }

-func (th *tokenHandler) fetchToken(params map[string]string) (token *tokenResponse, err error) {
-	//log.Debugf("Getting bearer token with %s for %s", challenge.Parameters, ta.auth.Username)
-	realm, ok := params["realm"]
-	if !ok {
-		return nil, errors.New("no realm specified for token auth challenge")
+func (th *tokenHandler) fetchTokenWithOAuth(realm *url.URL, refreshToken, service string, scopes []string) (token string, expiration time.Time, err error) {
+	form := url.Values{}
+	form.Set("scope", strings.Join(scopes, " "))
+	form.Set("service", service)
+
+	clientID := th.clientID
+	if clientID == "" {
+		// Use default client, this is a required field
+		clientID = defaultClientID
+	}
+	form.Set("client_id", clientID)
+
+	if refreshToken != "" {
+		form.Set("grant_type", "refresh_token")
+		form.Set("refresh_token", refreshToken)
+	} else if th.creds != nil {
+		form.Set("grant_type", "password")
+		username, password := th.creds.Basic(realm)
+		form.Set("username", username)
+		form.Set("password", password)
+
+		// attempt to get a refresh token
+		form.Set("access_type", "offline")
+	} else {
+		// refuse to do oauth without a grant type
+		return "", time.Time{}, fmt.Errorf("no supported grant type")
 	}

-	// TODO(dmcgowan): Handle empty scheme
-
-	realmURL, err := url.Parse(realm)
+	resp, err := th.client().PostForm(realm.String(), form)
 	if err != nil {
-		return nil, fmt.Errorf("invalid token auth challenge realm: %s", err)
+		return "", time.Time{}, err
+	}
+	defer resp.Body.Close()
+
+	if !client.SuccessStatus(resp.StatusCode) {
+		err := client.HandleErrorResponse(resp)
+		return "", time.Time{}, err
 	}

-	req, err := http.NewRequest("GET", realmURL.String(), nil)
+	decoder := json.NewDecoder(resp.Body)
+
+	var tr postTokenResponse
+	if err = decoder.Decode(&tr); err != nil {
+		return "", time.Time{}, fmt.Errorf("unable to decode token response: %s", err)
+	}
+
+	if tr.RefreshToken != "" && tr.RefreshToken != refreshToken {
+		th.creds.SetRefreshToken(realm, service, tr.RefreshToken)
+	}
+
+	if tr.ExpiresIn < minimumTokenLifetimeSeconds {
+		// The default/minimum lifetime.
+		tr.ExpiresIn = minimumTokenLifetimeSeconds
+		logrus.Debugf("Increasing token expiration to: %d seconds", tr.ExpiresIn)
+	}
+
+	if tr.IssuedAt.IsZero() {
+		// issued_at is optional in the token response.
+		tr.IssuedAt = th.clock.Now().UTC()
+	}
+
+	return tr.AccessToken, tr.IssuedAt.Add(time.Duration(tr.ExpiresIn) * time.Second), nil
+}
+
+type getTokenResponse struct {
+	Token        string    `json:"token"`
+	AccessToken  string    `json:"access_token"`
+	ExpiresIn    int       `json:"expires_in"`
+	IssuedAt     time.Time `json:"issued_at"`
+	RefreshToken string    `json:"refresh_token"`
+}
+
+func (th *tokenHandler) fetchTokenWithBasicAuth(realm *url.URL, service string, scopes []string) (token string, expiration time.Time, err error) {
+
+	req, err := http.NewRequest("GET", realm.String(), nil)
 	if err != nil {
-		return nil, err
+		return "", time.Time{}, err
 	}

 	reqParams := req.URL.Query()
-	service := params["service"]
-	scope := th.scope.String()

 	if service != "" {
 		reqParams.Add("service", service)
 	}

-	for _, scopeField := range strings.Fields(scope) {
-		reqParams.Add("scope", scopeField)
-	}
-
-	for scope := range th.additionalScopes {
+	for _, scope := range scopes {
 		reqParams.Add("scope", scope)
 	}

+	if th.offlineAccess {
+		reqParams.Add("offline_token", "true")
+		clientID := th.clientID
+		if clientID == "" {
+			clientID = defaultClientID
+		}
+		reqParams.Add("client_id", clientID)
+	}
+
 	if th.creds != nil {
-		username, password := th.creds.Basic(realmURL)
+		username, password := th.creds.Basic(realm)
 		if username != "" && password != "" {
 			reqParams.Add("account", username)
 			req.SetBasicAuth(username, password)
@@ -257,20 +380,24 @@ func (th *tokenHandler) fetchToken(params map[string]string) (token *tokenRespon

 	resp, err := th.client().Do(req)
 	if err != nil {
-		return nil, err
+		return "", time.Time{}, err
 	}
 	defer resp.Body.Close()

 	if !client.SuccessStatus(resp.StatusCode) {
 		err := client.HandleErrorResponse(resp)
-		return nil, err
+		return "", time.Time{}, err
 	}

 	decoder := json.NewDecoder(resp.Body)

-	tr := new(tokenResponse)
-	if err = decoder.Decode(tr); err != nil {
-		return nil, fmt.Errorf("unable to decode token response: %s", err)
+	var tr getTokenResponse
+	if err = decoder.Decode(&tr); err != nil {
+		return "", time.Time{}, fmt.Errorf("unable to decode token response: %s", err)
+	}
+
+	if tr.RefreshToken != "" && th.creds != nil {
+		th.creds.SetRefreshToken(realm, service, tr.RefreshToken)
 	}

 	// `access_token` is equivalent to `token` and if both are specified
@@ -281,21 +408,48 @@ func (th *tokenHandler) fetchToken(params map[string]string) (token *tokenRespon
 	}

 	if tr.Token == "" {
-		return nil, errors.New("authorization server did not include a token in the response")
+		return "", time.Time{}, ErrNoToken
 	}

 	if tr.ExpiresIn < minimumTokenLifetimeSeconds {
-		logrus.Debugf("Increasing token expiration to: %d seconds", tr.ExpiresIn)
 		// The default/minimum lifetime.
 		tr.ExpiresIn = minimumTokenLifetimeSeconds
+		logrus.Debugf("Increasing token expiration to: %d seconds", tr.ExpiresIn)
 	}

 	if tr.IssuedAt.IsZero() {
 		// issued_at is optional in the token response.
-		tr.IssuedAt = th.clock.Now()
+		tr.IssuedAt = th.clock.Now().UTC()
 	}

-	return tr, nil
+	return tr.Token, tr.IssuedAt.Add(time.Duration(tr.ExpiresIn) * time.Second), nil
+}
+
+func (th *tokenHandler) fetchToken(params map[string]string, scopes []string) (token string, expiration time.Time, err error) {
+	realm, ok := params["realm"]
+	if !ok {
+		return "", time.Time{}, errors.New("no realm specified for token auth challenge")
+	}
+
+	// TODO(dmcgowan): Handle empty scheme and relative realm
+	realmURL, err := url.Parse(realm)
+	if err != nil {
+		return "", time.Time{}, fmt.Errorf("invalid token auth challenge realm: %s", err)
+	}
+
+	service := params["service"]
+
+	var refreshToken string
+
+	if th.creds != nil {
+		refreshToken = th.creds.RefreshToken(realmURL, service)
+	}
+
+	if refreshToken != "" || th.forceOAuth {
+		return th.fetchTokenWithOAuth(realmURL, refreshToken, service, scopes)
+	}
+
+	return th.fetchTokenWithBasicAuth(realmURL, service, scopes)
 }

 type basicHandler struct {
@@ -322,5 +476,5 @@ func (bh *basicHandler) AuthorizeRequest(req *http.Request, params map[string]st
 			return nil
 		}
 	}
-	return errors.New("no basic auth credentials")
+	return ErrNoBasicAuthCredentials
 }
--- a/vendor/github.com/docker/distribution/registry/client/auth/session_test.go
+++ b/vendor/github.com/docker/distribution/registry/client/auth/session_test.go
@@ -1,599 +0,0 @@
-package auth
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/docker/distribution/registry/client/transport"
-	"github.com/docker/distribution/testutil"
-)
-
-// An implementation of clock for providing fake time data.
-type fakeClock struct {
-	current time.Time
-}
-
-// Now implements clock
-func (fc *fakeClock) Now() time.Time { return fc.current }
-
-func testServer(rrm testutil.RequestResponseMap) (string, func()) {
-	h := testutil.NewHandler(rrm)
-	s := httptest.NewServer(h)
-	return s.URL, s.Close
-}
-
-type testAuthenticationWrapper struct {
-	headers   http.Header
-	authCheck func(string) bool
-	next      http.Handler
-}
-
-func (w *testAuthenticationWrapper) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
-	auth := r.Header.Get("Authorization")
-	if auth == "" || !w.authCheck(auth) {
-		h := rw.Header()
-		for k, values := range w.headers {
-			h[k] = values
-		}
-		rw.WriteHeader(http.StatusUnauthorized)
-		return
-	}
-	w.next.ServeHTTP(rw, r)
-}
-
-func testServerWithAuth(rrm testutil.RequestResponseMap, authenticate string, authCheck func(string) bool) (string, func()) {
-	h := testutil.NewHandler(rrm)
-	wrapper := &testAuthenticationWrapper{
-
-		headers: http.Header(map[string][]string{
-			"X-API-Version":       {"registry/2.0"},
-			"X-Multi-API-Version": {"registry/2.0", "registry/2.1", "trust/1.0"},
-			"WWW-Authenticate":    {authenticate},
-		}),
-		authCheck: authCheck,
-		next:      h,
-	}
-
-	s := httptest.NewServer(wrapper)
-	return s.URL, s.Close
-}
-
-// ping pings the provided endpoint to determine its required authorization challenges.
-// If a version header is provided, the versions will be returned.
-func ping(manager ChallengeManager, endpoint, versionHeader string) ([]APIVersion, error) {
-	resp, err := http.Get(endpoint)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if err := manager.AddResponse(resp); err != nil {
-		return nil, err
-	}
-
-	return APIVersions(resp, versionHeader), err
-}
-
-type testCredentialStore struct {
-	username string
-	password string
-}
-
-func (tcs *testCredentialStore) Basic(*url.URL) (string, string) {
-	return tcs.username, tcs.password
-}
-
-func TestEndpointAuthorizeToken(t *testing.T) {
-	service := "localhost.localdomain"
-	repo1 := "some/registry"
-	repo2 := "other/registry"
-	scope1 := fmt.Sprintf("repository:%s:pull,push", repo1)
-	scope2 := fmt.Sprintf("repository:%s:pull,push", repo2)
-	tokenMap := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?scope=%s&service=%s", url.QueryEscape(scope1), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"token":"statictoken"}`),
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?scope=%s&service=%s", url.QueryEscape(scope2), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"token":"badtoken"}`),
-			},
-		},
-	})
-	te, tc := testServer(tokenMap)
-	defer tc()
-
-	m := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-	})
-
-	authenicate := fmt.Sprintf("Bearer realm=%q,service=%q", te+"/token", service)
-	validCheck := func(a string) bool {
-		return a == "Bearer statictoken"
-	}
-	e, c := testServerWithAuth(m, authenicate, validCheck)
-	defer c()
-
-	challengeManager1 := NewSimpleChallengeManager()
-	versions, err := ping(challengeManager1, e+"/v2/", "x-api-version")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(versions) != 1 {
-		t.Fatalf("Unexpected version count: %d, expected 1", len(versions))
-	}
-	if check := (APIVersion{Type: "registry", Version: "2.0"}); versions[0] != check {
-		t.Fatalf("Unexpected api version: %#v, expected %#v", versions[0], check)
-	}
-	transport1 := transport.NewTransport(nil, NewAuthorizer(challengeManager1, NewTokenHandler(nil, nil, repo1, "pull", "push")))
-	client := &http.Client{Transport: transport1}
-
-	req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatalf("Error sending get request: %s", err)
-	}
-
-	if resp.StatusCode != http.StatusAccepted {
-		t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-	}
-
-	badCheck := func(a string) bool {
-		return a == "Bearer statictoken"
-	}
-	e2, c2 := testServerWithAuth(m, authenicate, badCheck)
-	defer c2()
-
-	challengeManager2 := NewSimpleChallengeManager()
-	versions, err = ping(challengeManager2, e+"/v2/", "x-multi-api-version")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(versions) != 3 {
-		t.Fatalf("Unexpected version count: %d, expected 3", len(versions))
-	}
-	if check := (APIVersion{Type: "registry", Version: "2.0"}); versions[0] != check {
-		t.Fatalf("Unexpected api version: %#v, expected %#v", versions[0], check)
-	}
-	if check := (APIVersion{Type: "registry", Version: "2.1"}); versions[1] != check {
-		t.Fatalf("Unexpected api version: %#v, expected %#v", versions[1], check)
-	}
-	if check := (APIVersion{Type: "trust", Version: "1.0"}); versions[2] != check {
-		t.Fatalf("Unexpected api version: %#v, expected %#v", versions[2], check)
-	}
-	transport2 := transport.NewTransport(nil, NewAuthorizer(challengeManager2, NewTokenHandler(nil, nil, repo2, "pull", "push")))
-	client2 := &http.Client{Transport: transport2}
-
-	req, _ = http.NewRequest("GET", e2+"/v2/hello", nil)
-	resp, err = client2.Do(req)
-	if err != nil {
-		t.Fatalf("Error sending get request: %s", err)
-	}
-
-	if resp.StatusCode != http.StatusUnauthorized {
-		t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusUnauthorized)
-	}
-}
-
-func basicAuth(username, password string) string {
-	auth := username + ":" + password
-	return base64.StdEncoding.EncodeToString([]byte(auth))
-}
-
-func TestEndpointAuthorizeTokenBasic(t *testing.T) {
-	service := "localhost.localdomain"
-	repo := "some/fun/registry"
-	scope := fmt.Sprintf("repository:%s:pull,push", repo)
-	username := "tokenuser"
-	password := "superSecretPa$$word"
-
-	tokenMap := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?account=%s&scope=%s&service=%s", username, url.QueryEscape(scope), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"access_token":"statictoken"}`),
-			},
-		},
-	})
-
-	authenicate1 := fmt.Sprintf("Basic realm=localhost")
-	basicCheck := func(a string) bool {
-		return a == fmt.Sprintf("Basic %s", basicAuth(username, password))
-	}
-	te, tc := testServerWithAuth(tokenMap, authenicate1, basicCheck)
-	defer tc()
-
-	m := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-	})
-
-	authenicate2 := fmt.Sprintf("Bearer realm=%q,service=%q", te+"/token", service)
-	bearerCheck := func(a string) bool {
-		return a == "Bearer statictoken"
-	}
-	e, c := testServerWithAuth(m, authenicate2, bearerCheck)
-	defer c()
-
-	creds := &testCredentialStore{
-		username: username,
-		password: password,
-	}
-
-	challengeManager := NewSimpleChallengeManager()
-	_, err := ping(challengeManager, e+"/v2/", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	transport1 := transport.NewTransport(nil, NewAuthorizer(challengeManager, NewTokenHandler(nil, creds, repo, "pull", "push"), NewBasicHandler(creds)))
-	client := &http.Client{Transport: transport1}
-
-	req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatalf("Error sending get request: %s", err)
-	}
-
-	if resp.StatusCode != http.StatusAccepted {
-		t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-	}
-}
-
-func TestEndpointAuthorizeTokenBasicWithExpiresIn(t *testing.T) {
-	service := "localhost.localdomain"
-	repo := "some/fun/registry"
-	scope := fmt.Sprintf("repository:%s:pull,push", repo)
-	username := "tokenuser"
-	password := "superSecretPa$$word"
-
-	tokenMap := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?account=%s&scope=%s&service=%s", username, url.QueryEscape(scope), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"token":"statictoken", "expires_in": 3001}`),
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?account=%s&scope=%s&service=%s", username, url.QueryEscape(scope), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"access_token":"statictoken", "expires_in": 3001}`),
-			},
-		},
-	})
-
-	authenicate1 := fmt.Sprintf("Basic realm=localhost")
-	tokenExchanges := 0
-	basicCheck := func(a string) bool {
-		tokenExchanges = tokenExchanges + 1
-		return a == fmt.Sprintf("Basic %s", basicAuth(username, password))
-	}
-	te, tc := testServerWithAuth(tokenMap, authenicate1, basicCheck)
-	defer tc()
-
-	m := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-	})
-
-	authenicate2 := fmt.Sprintf("Bearer realm=%q,service=%q", te+"/token", service)
-	bearerCheck := func(a string) bool {
-		return a == "Bearer statictoken"
-	}
-	e, c := testServerWithAuth(m, authenicate2, bearerCheck)
-	defer c()
-
-	creds := &testCredentialStore{
-		username: username,
-		password: password,
-	}
-
-	challengeManager := NewSimpleChallengeManager()
-	_, err := ping(challengeManager, e+"/v2/", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	clock := &fakeClock{current: time.Now()}
-	transport1 := transport.NewTransport(nil, NewAuthorizer(challengeManager, newTokenHandler(nil, creds, clock, repo, "pull", "push"), NewBasicHandler(creds)))
-	client := &http.Client{Transport: transport1}
-
-	// First call should result in a token exchange
-	// Subsequent calls should recycle the token from the first request, until the expiration has lapsed.
-	timeIncrement := 1000 * time.Second
-	for i := 0; i < 4; i++ {
-		req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-		resp, err := client.Do(req)
-		if err != nil {
-			t.Fatalf("Error sending get request: %s", err)
-		}
-		if resp.StatusCode != http.StatusAccepted {
-			t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-		}
-		if tokenExchanges != 1 {
-			t.Fatalf("Unexpected number of token exchanges, want: 1, got %d (iteration: %d)", tokenExchanges, i)
-		}
-		clock.current = clock.current.Add(timeIncrement)
-	}
-
-	// After we've exceeded the expiration, we should see a second token exchange.
-	req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatalf("Error sending get request: %s", err)
-	}
-	if resp.StatusCode != http.StatusAccepted {
-		t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-	}
-	if tokenExchanges != 2 {
-		t.Fatalf("Unexpected number of token exchanges, want: 2, got %d", tokenExchanges)
-	}
-}
-
-func TestEndpointAuthorizeTokenBasicWithExpiresInAndIssuedAt(t *testing.T) {
-	service := "localhost.localdomain"
-	repo := "some/fun/registry"
-	scope := fmt.Sprintf("repository:%s:pull,push", repo)
-	username := "tokenuser"
-	password := "superSecretPa$$word"
-
-	// This test sets things up such that the token was issued one increment
-	// earlier than its sibling in TestEndpointAuthorizeTokenBasicWithExpiresIn.
-	// This will mean that the token expires after 3 increments instead of 4.
-	clock := &fakeClock{current: time.Now()}
-	timeIncrement := 1000 * time.Second
-	firstIssuedAt := clock.Now()
-	clock.current = clock.current.Add(timeIncrement)
-	secondIssuedAt := clock.current.Add(2 * timeIncrement)
-	tokenMap := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?account=%s&scope=%s&service=%s", username, url.QueryEscape(scope), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"token":"statictoken", "issued_at": "` + firstIssuedAt.Format(time.RFC3339Nano) + `", "expires_in": 3001}`),
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  fmt.Sprintf("/token?account=%s&scope=%s&service=%s", username, url.QueryEscape(scope), service),
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusOK,
-				Body:       []byte(`{"access_token":"statictoken", "issued_at": "` + secondIssuedAt.Format(time.RFC3339Nano) + `", "expires_in": 3001}`),
-			},
-		},
-	})
-
-	authenicate1 := fmt.Sprintf("Basic realm=localhost")
-	tokenExchanges := 0
-	basicCheck := func(a string) bool {
-		tokenExchanges = tokenExchanges + 1
-		return a == fmt.Sprintf("Basic %s", basicAuth(username, password))
-	}
-	te, tc := testServerWithAuth(tokenMap, authenicate1, basicCheck)
-	defer tc()
-
-	m := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-	})
-
-	authenicate2 := fmt.Sprintf("Bearer realm=%q,service=%q", te+"/token", service)
-	bearerCheck := func(a string) bool {
-		return a == "Bearer statictoken"
-	}
-	e, c := testServerWithAuth(m, authenicate2, bearerCheck)
-	defer c()
-
-	creds := &testCredentialStore{
-		username: username,
-		password: password,
-	}
-
-	challengeManager := NewSimpleChallengeManager()
-	_, err := ping(challengeManager, e+"/v2/", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	transport1 := transport.NewTransport(nil, NewAuthorizer(challengeManager, newTokenHandler(nil, creds, clock, repo, "pull", "push"), NewBasicHandler(creds)))
-	client := &http.Client{Transport: transport1}
-
-	// First call should result in a token exchange
-	// Subsequent calls should recycle the token from the first request, until the expiration has lapsed.
-	// We shaved one increment off of the equivalent logic in TestEndpointAuthorizeTokenBasicWithExpiresIn
-	// so this loop should have one fewer iteration.
-	for i := 0; i < 3; i++ {
-		req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-		resp, err := client.Do(req)
-		if err != nil {
-			t.Fatalf("Error sending get request: %s", err)
-		}
-		if resp.StatusCode != http.StatusAccepted {
-			t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-		}
-		if tokenExchanges != 1 {
-			t.Fatalf("Unexpected number of token exchanges, want: 1, got %d (iteration: %d)", tokenExchanges, i)
-		}
-		clock.current = clock.current.Add(timeIncrement)
-	}
-
-	// After we've exceeded the expiration, we should see a second token exchange.
-	req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatalf("Error sending get request: %s", err)
-	}
-	if resp.StatusCode != http.StatusAccepted {
-		t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-	}
-	if tokenExchanges != 2 {
-		t.Fatalf("Unexpected number of token exchanges, want: 2, got %d", tokenExchanges)
-	}
-}
-
-func TestEndpointAuthorizeBasic(t *testing.T) {
-	m := testutil.RequestResponseMap([]testutil.RequestResponseMapping{
-		{
-			Request: testutil.Request{
-				Method: "GET",
-				Route:  "/v2/hello",
-			},
-			Response: testutil.Response{
-				StatusCode: http.StatusAccepted,
-			},
-		},
-	})
-
-	username := "user1"
-	password := "funSecretPa$$word"
-	authenicate := fmt.Sprintf("Basic realm=localhost")
-	validCheck := func(a string) bool {
-		return a == fmt.Sprintf("Basic %s", basicAuth(username, password))
-	}
-	e, c := testServerWithAuth(m, authenicate, validCheck)
-	defer c()
-	creds := &testCredentialStore{
-		username: username,
-		password: password,
-	}
-
-	challengeManager := NewSimpleChallengeManager()
-	_, err := ping(challengeManager, e+"/v2/", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	transport1 := transport.NewTransport(nil, NewAuthorizer(challengeManager, NewBasicHandler(creds)))
-	client := &http.Client{Transport: transport1}
-
-	req, _ := http.NewRequest("GET", e+"/v2/hello", nil)
-	resp, err := client.Do(req)
-	if err != nil {
-		t.Fatalf("Error sending get request: %s", err)
-	}
-
-	if resp.StatusCode != http.StatusAccepted {
-		t.Fatalf("Unexpected status code: %d, expected %d", resp.StatusCode, http.StatusAccepted)
-	}
-}