lfsapi: introduce interface for initializing a Client

commands/commands.go

@@ -71,7 +71,7 @@ func getAPIClient() *lfsapi.Client {
 	defer global.Unlock()
 
 	if apiClient == nil {
-		c, err := lfsapi.NewClient(cfg.Os, cfg.Git)
+		c, err := lfsapi.NewClient(cfg)
 		if err != nil {
 			ExitWithError(err)
 		}

config/config.go

@@ -272,6 +272,14 @@ func (c *Configuration) Cleanup() error {
 	return c.fs.Cleanup()
 }
 
+func (c *Configuration) OSEnv() Environment {
+	return c.Os
+}
+
+func (c *Configuration) GitEnv() Environment {
+	return c.Git
+}
+
 func (c *Configuration) GitConfig() *git.Configuration {
 	return c.gitConfig
 }

lfs/lfs.go

@@ -19,7 +19,7 @@ func Environ(cfg *config.Configuration, manifest *tq.Manifest) []string {
 	osEnviron := os.Environ()
 	env := make([]string, 0, len(osEnviron)+7)
 
-	api, err := lfsapi.NewClient(cfg.Os, cfg.Git)
+	api, err := lfsapi.NewClient(cfg)
 	if err != nil {
 		// TODO(@ttaylorr): don't panic
 		panic(err.Error())

lfsapi/auth_test.go

@@ -72,7 +72,7 @@ func TestDoWithAuthApprove(t *testing.T) {
 	defer srv.Close()
 
 	creds := newMockCredentialHelper()
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/repo/lfs",
 	}))
 	require.Nil(t, err)
@@ -141,12 +141,11 @@ func TestDoWithAuthReject(t *testing.T) {
 	creds.Approve(invalidCreds)
 	assert.True(t, creds.IsApproved(invalidCreds))
 
-	c := &Client{
-		Credentials: creds,
-		Endpoints: NewEndpointFinder(UniqTestEnv(map[string]string{
-			"lfs.url": srv.URL,
-		})),
-	}
+	c, _ := NewClient(nil)
+	c.Credentials = creds
+	c.Endpoints = NewEndpointFinder(testEnv(map[string]string{
+		"lfs.url": srv.URL,
+	}))
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
 	require.Nil(t, err)
@@ -532,7 +531,7 @@ func TestGetCreds(t *testing.T) {
 			req.Header.Set(key, value)
 		}
 
-		ef := NewEndpointFinder(UniqTestEnv(test.Config))
+		ef := NewEndpointFinder(testEnv(test.Config))
 		endpoint, access, creds, credsURL, err := getCreds(credHelper, netrcFinder, ef, test.Remote, req)
 		if !assert.Nil(t, err) {
 			continue

lfsapi/certs.go

@@ -58,7 +58,7 @@ func getRootCAsForHost(c *Client, host string) *x509.CertPool {
 	return appendRootCAsForHostFromPlatform(pool, host)
 }
 
-func appendRootCAsForHostFromGitconfig(osEnv Env, gitEnv Env, pool *x509.CertPool, host string) *x509.CertPool {
+func appendRootCAsForHostFromGitconfig(osEnv, gitEnv config.Environment, pool *x509.CertPool, host string) *x509.CertPool {
 	// Accumulate certs from all these locations:
 
 	// GIT_SSL_CAINFO first

lfsapi/certs_test.go

@@ -60,7 +60,7 @@ func TestCertFromSSLCAInfoConfig(t *testing.T) {
 	// Test http.<url>.sslcainfo
 	for _, hostName := range sslCAInfoConfigHostNames {
 		hostKey := fmt.Sprintf("http.https://%v.sslcainfo", hostName)
-		c, err := NewClient(nil, UniqTestEnv(map[string]string{
+		c, err := NewClient(NewContext(nil, map[string]string{
 			hostKey: tempfile.Name(),
 		}))
 		assert.Nil(t, err)
@@ -82,7 +82,7 @@ func TestCertFromSSLCAInfoConfig(t *testing.T) {
 	}
 
 	// Test http.sslcainfo
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"http.sslcainfo": tempfile.Name(),
 	}))
 	assert.Nil(t, err)
@@ -103,9 +103,9 @@ func TestCertFromSSLCAInfoEnv(t *testing.T) {
 	assert.Nil(t, err, "Error writing temp cert file")
 	tempfile.Close()
 
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"GIT_SSL_CAINFO": tempfile.Name(),
-	}), nil)
+	}, nil))
 	assert.Nil(t, err)
 
 	// Should match any host at all
@@ -123,7 +123,7 @@ func TestCertFromSSLCAPathConfig(t *testing.T) {
 	err = ioutil.WriteFile(filepath.Join(tempdir, "cert1.pem"), []byte(testCert), 0644)
 	assert.Nil(t, err, "Error creating cert file")
 
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"http.sslcapath": tempdir,
 	}))
 
@@ -144,9 +144,9 @@ func TestCertFromSSLCAPathEnv(t *testing.T) {
 	err = ioutil.WriteFile(filepath.Join(tempdir, "cert1.pem"), []byte(testCert), 0644)
 	assert.Nil(t, err, "Error creating cert file")
 
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"GIT_SSL_CAPATH": tempdir,
-	}), nil)
+	}, nil))
 	assert.Nil(t, err)
 
 	// Should match any host at all
@@ -157,16 +157,16 @@ func TestCertFromSSLCAPathEnv(t *testing.T) {
 }
 
 func TestCertVerifyDisabledGlobalEnv(t *testing.T) {
-	empty := &Client{}
+	empty, _ := NewClient(nil)
 	httpClient := empty.httpClient("anyhost.com")
 	tr, ok := httpClient.Transport.(*http.Transport)
 	if assert.True(t, ok) {
 		assert.False(t, tr.TLSClientConfig.InsecureSkipVerify)
 	}
 
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"GIT_SSL_NO_VERIFY": "1",
-	}), nil)
+	}, nil))
 
 	assert.Nil(t, err)
 
@@ -178,14 +178,14 @@ func TestCertVerifyDisabledGlobalEnv(t *testing.T) {
 }
 
 func TestCertVerifyDisabledGlobalConfig(t *testing.T) {
-	def := &Client{}
+	def, _ := NewClient(nil)
 	httpClient := def.httpClient("anyhost.com")
 	tr, ok := httpClient.Transport.(*http.Transport)
 	if assert.True(t, ok) {
 		assert.False(t, tr.TLSClientConfig.InsecureSkipVerify)
 	}
 
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"http.sslverify": "false",
 	}))
 	assert.Nil(t, err)
@@ -198,7 +198,7 @@ func TestCertVerifyDisabledGlobalConfig(t *testing.T) {
 }
 
 func TestCertVerifyDisabledHostConfig(t *testing.T) {
-	def := &Client{}
+	def, _ := NewClient(nil)
 	httpClient := def.httpClient("specifichost.com")
 	tr, ok := httpClient.Transport.(*http.Transport)
 	if assert.True(t, ok) {
@@ -211,7 +211,7 @@ func TestCertVerifyDisabledHostConfig(t *testing.T) {
 		assert.False(t, tr.TLSClientConfig.InsecureSkipVerify)
 	}
 
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"http.https://specifichost.com/.sslverify": "false",
 	}))
 	assert.Nil(t, err)

lfsapi/client.go

@@ -210,11 +210,11 @@ func (c *Client) httpClient(host string) *http.Client {
 	defer c.clientMu.Unlock()
 
 	if c.gitEnv == nil {
-		c.gitEnv = make(TestEnv)
+		c.gitEnv = make(testEnv)
 	}
 
 	if c.osEnv == nil {
-		c.osEnv = make(TestEnv)
+		c.osEnv = make(testEnv)
 	}
 
 	if c.hostClients == nil {

lfsapi/client_test.go

@@ -111,7 +111,7 @@ func TestClientRedirect(t *testing.T) {
 	srv3Https = srv3.URL
 	srv3Http = fmt.Sprintf("http://%s", srv3InsecureListener.Addr().String())
 
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		fmt.Sprintf("http.%s.sslverify", srv3Https):  "false",
 		fmt.Sprintf("http.%s/.sslverify", srv3Https): "false",
 		fmt.Sprintf("http.%s.sslverify", srv3Http):   "false",
@@ -176,7 +176,7 @@ func TestClientRedirect(t *testing.T) {
 }
 
 func TestNewClient(t *testing.T) {
-	c, err := NewClient(UniqTestEnv(map[string]string{}), UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"lfs.dialtimeout":         "151",
 		"lfs.keepalive":           "152",
 		"lfs.tlstimeout":          "153",
@@ -191,12 +191,12 @@ func TestNewClient(t *testing.T) {
 }
 
 func TestNewClientWithGitSSLVerify(t *testing.T) {
-	c, err := NewClient(nil, nil)
+	c, err := NewClient(nil)
 	assert.Nil(t, err)
 	assert.False(t, c.SkipSSLVerify)
 
 	for _, value := range []string{"true", "1", "t"} {
-		c, err = NewClient(UniqTestEnv(map[string]string{}), UniqTestEnv(map[string]string{
+		c, err = NewClient(NewContext(nil, map[string]string{
 			"http.sslverify": value,
 		}))
 		t.Logf("http.sslverify: %q", value)
@@ -205,7 +205,7 @@ func TestNewClientWithGitSSLVerify(t *testing.T) {
 	}
 
 	for _, value := range []string{"false", "0", "f"} {
-		c, err = NewClient(UniqTestEnv(map[string]string{}), UniqTestEnv(map[string]string{
+		c, err = NewClient(NewContext(nil, map[string]string{
 			"http.sslverify": value,
 		}))
 		t.Logf("http.sslverify: %q", value)
@@ -215,23 +215,23 @@ func TestNewClientWithGitSSLVerify(t *testing.T) {
 }
 
 func TestNewClientWithOSSSLVerify(t *testing.T) {
-	c, err := NewClient(nil, nil)
+	c, err := NewClient(nil)
 	assert.Nil(t, err)
 	assert.False(t, c.SkipSSLVerify)
 
 	for _, value := range []string{"false", "0", "f"} {
-		c, err = NewClient(UniqTestEnv(map[string]string{
+		c, err = NewClient(NewContext(map[string]string{
 			"GIT_SSL_NO_VERIFY": value,
-		}), UniqTestEnv(map[string]string{}))
+		}, nil))
 		t.Logf("GIT_SSL_NO_VERIFY: %q", value)
 		assert.Nil(t, err)
 		assert.False(t, c.SkipSSLVerify)
 	}
 
 	for _, value := range []string{"true", "1", "t"} {
-		c, err = NewClient(UniqTestEnv(map[string]string{
+		c, err = NewClient(NewContext(map[string]string{
 			"GIT_SSL_NO_VERIFY": value,
-		}), UniqTestEnv(map[string]string{}))
+		}, nil))
 		t.Logf("GIT_SSL_NO_VERIFY: %q", value)
 		assert.Nil(t, err)
 		assert.True(t, c.SkipSSLVerify)
@@ -247,7 +247,7 @@ func TestNewRequest(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		c, err := NewClient(nil, UniqTestEnv(map[string]string{
+		c, err := NewClient(NewContext(nil, map[string]string{
 			"lfs.url": test[0],
 		}))
 		require.Nil(t, err)
@@ -260,7 +260,7 @@ func TestNewRequest(t *testing.T) {
 }
 
 func TestNewRequestWithBody(t *testing.T) {
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"lfs.url": "https://example.com",
 	}))
 	require.Nil(t, err)

lfsapi/endpoint_finder.go

@@ -37,7 +37,7 @@ type EndpointFinder interface {
 }
 
 type endpointGitFinder struct {
-	git         Env
+	git         config.Environment
 	gitProtocol string
 
 	aliasMu sync.Mutex
@@ -48,7 +48,7 @@ type endpointGitFinder struct {
 	urlConfig *config.URLConfig
 }
 
-func NewEndpointFinder(git Env) EndpointFinder {
+func NewEndpointFinder(git config.Environment) EndpointFinder {
 	e := &endpointGitFinder{
 		gitProtocol: "https",
 		aliases:     make(map[string]string),
@@ -277,7 +277,7 @@ func (e *endpointGitFinder) ReplaceUrlAlias(rawurl string) string {
 	return rawurl
 }
 
-func initAliases(e *endpointGitFinder, git Env) {
+func initAliases(e *endpointGitFinder, git config.Environment) {
 	prefix := "url."
 	suffix := ".insteadof"
 	for gitkey, gitval := range git.All() {

lfsapi/endpoint_finder_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestEndpointDefaultsToOrigin(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.lfsurl": "abc",
 	}))
 
@@ -18,7 +18,7 @@ func TestEndpointDefaultsToOrigin(t *testing.T) {
 }
 
 func TestEndpointOverridesOrigin(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"lfs.url":              "abc",
 		"remote.origin.lfsurl": "def",
 	}))
@@ -30,7 +30,7 @@ func TestEndpointOverridesOrigin(t *testing.T) {
 }
 
 func TestEndpointNoOverrideDefaultRemote(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.lfsurl": "abc",
 		"remote.other.lfsurl":  "def",
 	}))
@@ -42,7 +42,7 @@ func TestEndpointNoOverrideDefaultRemote(t *testing.T) {
 }
 
 func TestEndpointUseAlternateRemote(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.lfsurl": "abc",
 		"remote.other.lfsurl":  "def",
 	}))
@@ -54,7 +54,7 @@ func TestEndpointUseAlternateRemote(t *testing.T) {
 }
 
 func TestEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "https://example.com/foo/bar",
 	}))
 
@@ -65,7 +65,7 @@ func TestEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestBareEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "https://example.com/foo/bar.git",
 	}))
 
@@ -76,7 +76,7 @@ func TestBareEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestEndpointSeparateClonePushUrl(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url":     "https://example.com/foo/bar.git",
 		"remote.origin.pushurl": "https://readwrite.com/foo/bar.git",
 	}))
@@ -93,7 +93,7 @@ func TestEndpointSeparateClonePushUrl(t *testing.T) {
 }
 
 func TestEndpointOverriddenSeparateClonePushLfsUrl(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url":        "https://example.com/foo/bar.git",
 		"remote.origin.pushurl":    "https://readwrite.com/foo/bar.git",
 		"remote.origin.lfsurl":     "https://examplelfs.com/foo/bar",
@@ -112,7 +112,7 @@ func TestEndpointOverriddenSeparateClonePushLfsUrl(t *testing.T) {
 }
 
 func TestEndpointGlobalSeparateLfsPush(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"lfs.url":     "https://readonly.com/foo/bar",
 		"lfs.pushurl": "https://write.com/foo/bar",
 	}))
@@ -129,7 +129,7 @@ func TestEndpointGlobalSeparateLfsPush(t *testing.T) {
 }
 
 func TestSSHEndpointOverridden(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url":    "git@example.com:foo/bar",
 		"remote.origin.lfsurl": "lfs",
 	}))
@@ -142,7 +142,7 @@ func TestSSHEndpointOverridden(t *testing.T) {
 }
 
 func TestSSHEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "ssh://git@example.com/foo/bar",
 	}))
 
@@ -154,7 +154,7 @@ func TestSSHEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestSSHCustomPortEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "ssh://git@example.com:9000/foo/bar",
 	}))
 
@@ -166,7 +166,7 @@ func TestSSHCustomPortEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestBareSSHEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "git@example.com:foo/bar.git",
 	}))
 
@@ -178,7 +178,7 @@ func TestBareSSHEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestSSHEndpointFromGlobalLfsUrl(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"lfs.url": "git@example.com:foo/bar.git",
 	}))
 
@@ -190,7 +190,7 @@ func TestSSHEndpointFromGlobalLfsUrl(t *testing.T) {
 }
 
 func TestHTTPEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "http://example.com/foo/bar",
 	}))
 
@@ -202,7 +202,7 @@ func TestHTTPEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestBareHTTPEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "http://example.com/foo/bar.git",
 	}))
 
@@ -214,7 +214,7 @@ func TestBareHTTPEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestGitEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "git://example.com/foo/bar",
 	}))
 
@@ -226,7 +226,7 @@ func TestGitEndpointAddsLfsSuffix(t *testing.T) {
 }
 
 func TestGitEndpointAddsLfsSuffixWithCustomProtocol(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "git://example.com/foo/bar",
 		"lfs.gitprotocol":   "http",
 	}))
@@ -239,7 +239,7 @@ func TestGitEndpointAddsLfsSuffixWithCustomProtocol(t *testing.T) {
 }
 
 func TestBareGitEndpointAddsLfsSuffix(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"remote.origin.url": "git://example.com/foo/bar.git",
 	}))
 
@@ -266,7 +266,7 @@ func TestAccessConfig(t *testing.T) {
 	}
 
 	for value, expected := range tests {
-		finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+		finder := NewEndpointFinder(testEnv(map[string]string{
 			"lfs.url":                        "http://example.com",
 			"lfs.http://example.com.access":  value,
 			"lfs.https://example.com.access": "bad",
@@ -285,7 +285,7 @@ func TestAccessConfig(t *testing.T) {
 
 	// Test again but with separate push url
 	for value, expected := range tests {
-		finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+		finder := NewEndpointFinder(testEnv(map[string]string{
 			"lfs.url":                           "http://example.com",
 			"lfs.pushurl":                       "http://examplepush.com",
 			"lfs.http://example.com.access":     value,
@@ -312,7 +312,7 @@ func TestAccessAbsentConfig(t *testing.T) {
 }
 
 func TestSetAccess(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{}))
+	finder := NewEndpointFinder(testEnv(map[string]string{}))
 
 	assert.Equal(t, NoneAccess, finder.AccessFor("http://example.com"))
 	finder.SetAccess("http://example.com", NTLMAccess)
@@ -320,7 +320,7 @@ func TestSetAccess(t *testing.T) {
 }
 
 func TestChangeAccess(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"lfs.http://example.com.access": "basic",
 	}))
 
@@ -330,7 +330,7 @@ func TestChangeAccess(t *testing.T) {
 }
 
 func TestDeleteAccessWithNone(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"lfs.http://example.com.access": "basic",
 	}))
 
@@ -340,7 +340,7 @@ func TestDeleteAccessWithNone(t *testing.T) {
 }
 
 func TestDeleteAccessWithEmptyString(t *testing.T) {
-	finder := NewEndpointFinder(UniqTestEnv(map[string]string{
+	finder := NewEndpointFinder(testEnv(map[string]string{
 		"lfs.http://example.com.access": "basic",
 	}))
 

lfsapi/lfsapi.go

@@ -47,18 +47,29 @@ type Client struct {
 	LoggingStats bool // DEPRECATED
 
 	// only used for per-host ssl certs
-	gitEnv Env
-	osEnv  Env
+	gitEnv config.Environment
+	osEnv  config.Environment
 	uc     *config.URLConfig
 }
 
-func NewClient(osEnv Env, gitEnv Env) (*Client, error) {
-	if osEnv == nil {
-		osEnv = make(TestEnv)
-	}
+type Context interface {
+	OSEnv() config.Environment
+	GitEnv() config.Environment
+}
 
+func NewClient(ctx Context) (*Client, error) {
+	if ctx == nil {
+		return newClient(nil, nil)
+	}
+	return newClient(ctx.OSEnv(), ctx.GitEnv())
+}
+
+func newClient(osEnv, gitEnv config.Environment) (*Client, error) {
+	if osEnv == nil {
+		osEnv = make(testEnv)
+	}
 	if gitEnv == nil {
-		gitEnv = make(TestEnv)
+		gitEnv = make(testEnv)
 	}
 
 	netrc, netrcfile, err := ParseNetrc(osEnv)
@@ -96,11 +107,11 @@ func NewClient(osEnv Env, gitEnv Env) (*Client, error) {
 	return c, nil
 }
 
-func (c *Client) GitEnv() Env {
+func (c *Client) GitEnv() config.Environment {
 	return c.gitEnv
 }
 
-func (c *Client) OSEnv() Env {
+func (c *Client) OSEnv() config.Environment {
 	return c.osEnv
 }
 
@@ -135,31 +146,45 @@ func DecodeJSON(res *http.Response, obj interface{}) error {
 	return nil
 }
 
-// Env is an interface for the config.Environment methods that this package
-// relies on.
-type Env interface {
-	Get(string) (string, bool)
-	GetAll(string) []string
-	Int(string, int) int
-	Bool(string, bool) bool
-	All() map[string][]string
+type testContext struct {
+	osEnv  config.Environment
+	gitEnv config.Environment
 }
 
-type UniqTestEnv map[string]string
+func (c *testContext) OSEnv() config.Environment {
+	return c.osEnv
+}
 
-func (e UniqTestEnv) Get(key string) (v string, ok bool) {
+func (c *testContext) GitEnv() config.Environment {
+	return c.gitEnv
+}
+
+func NewContext(osEnv, gitEnv map[string]string) Context {
+	c := &testContext{}
+	if osEnv != nil {
+		c.osEnv = testEnv(osEnv)
+	}
+	if gitEnv != nil {
+		c.gitEnv = testEnv(gitEnv)
+	}
+	return c
+}
+
+type testEnv map[string]string
+
+func (e testEnv) Get(key string) (v string, ok bool) {
 	v, ok = e[key]
 	return
 }
 
-func (e UniqTestEnv) GetAll(key string) []string {
+func (e testEnv) GetAll(key string) []string {
 	if v, ok := e.Get(key); ok {
 		return []string{v}
 	}
 	return make([]string, 0)
 }
 
-func (e UniqTestEnv) Int(key string, def int) (val int) {
+func (e testEnv) Int(key string, def int) (val int) {
 	s, _ := e.Get(key)
 	if len(s) == 0 {
 		return def
@@ -173,7 +198,7 @@ func (e UniqTestEnv) Int(key string, def int) (val int) {
 	return i
 }
 
-func (e UniqTestEnv) Bool(key string, def bool) (val bool) {
+func (e testEnv) Bool(key string, def bool) (val bool) {
 	s, _ := e.Get(key)
 	if len(s) == 0 {
 		return def
@@ -189,61 +214,10 @@ func (e UniqTestEnv) Bool(key string, def bool) (val bool) {
 	}
 }
 
-func (e UniqTestEnv) All() map[string][]string {
+func (e testEnv) All() map[string][]string {
 	m := make(map[string][]string)
 	for k, _ := range e {
 		m[k] = e.GetAll(k)
 	}
 	return m
 }
-
-// TestEnv is a basic config.Environment implementation. Only used in tests, or
-// as a zero value to NewClient().
-type TestEnv map[string][]string
-
-func (e TestEnv) Get(key string) (string, bool) {
-	all := e.GetAll(key)
-
-	if len(all) == 0 {
-		return "", false
-	}
-	return all[len(all)-1], true
-}
-
-func (e TestEnv) GetAll(key string) []string {
-	return e[key]
-}
-
-func (e TestEnv) Int(key string, def int) (val int) {
-	s, _ := e.Get(key)
-	if len(s) == 0 {
-		return def
-	}
-
-	i, err := strconv.Atoi(s)
-	if err != nil {
-		return def
-	}
-
-	return i
-}
-
-func (e TestEnv) Bool(key string, def bool) (val bool) {
-	s, _ := e.Get(key)
-	if len(s) == 0 {
-		return def
-	}
-
-	switch strings.ToLower(s) {
-	case "true", "1", "on", "yes", "t":
-		return true
-	case "false", "0", "off", "no", "f":
-		return false
-	default:
-		return false
-	}
-}
-
-func (e TestEnv) All() map[string][]string {
-	return e
-}

lfsapi/netrc.go

@@ -5,13 +5,14 @@ import (
 	"path/filepath"
 
 	"github.com/bgentry/go-netrc/netrc"
+	"github.com/git-lfs/git-lfs/config"
 )
 
 type NetrcFinder interface {
 	FindMachine(string) *netrc.Machine
 }
 
-func ParseNetrc(osEnv Env) (NetrcFinder, string, error) {
+func ParseNetrc(osEnv config.Environment) (NetrcFinder, string, error) {
 	home, _ := osEnv.Get("HOME")
 	if len(home) == 0 {
 		return &noFinder{}, "", nil

lfsapi/ntlm_test.go

@@ -77,7 +77,7 @@ func TestNTLMAuth(t *testing.T) {
 	require.Nil(t, err)
 
 	credHelper := newMockCredentialHelper()
-	cli, err := NewClient(nil, UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(nil, map[string]string{
 		"lfs.url":                         srv.URL + "/ntlm",
 		"lfs." + srv.URL + "/ntlm.access": "ntlm",
 	}))
@@ -103,7 +103,7 @@ func TestNTLMAuth(t *testing.T) {
 }
 
 func TestNtlmClientSession(t *testing.T) {
-	cli, err := NewClient(nil, nil)
+	cli, err := NewClient(nil)
 	require.Nil(t, err)
 
 	creds := Creds{"username": "MOOSEDOMAIN\\canadian", "password": "MooseAntlersYeah"}
@@ -120,7 +120,7 @@ func TestNtlmClientSession(t *testing.T) {
 }
 
 func TestNtlmClientSessionBadCreds(t *testing.T) {
-	cli, err := NewClient(nil, nil)
+	cli, err := NewClient(nil)
 	require.Nil(t, err)
 	creds := Creds{"username": "badusername", "password": "MooseAntlersYeah"}
 	_, err = cli.ntlmClientSession(creds)

lfsapi/proxy.go

@@ -48,7 +48,7 @@ func proxyFromClient(c *Client) func(req *http.Request) (*url.URL, error) {
 	}
 }
 
-func getProxyServers(u *url.URL, urlCfg *config.URLConfig, osEnv Env) (httpsProxy string, httpProxy string, noProxy string) {
+func getProxyServers(u *url.URL, urlCfg *config.URLConfig, osEnv config.Environment) (httpsProxy string, httpProxy string, noProxy string) {
 	if urlCfg != nil {
 		httpProxy, _ = urlCfg.Get("http", u.String(), "proxy")
 		if strings.HasPrefix(httpProxy, "https://") {

lfsapi/proxy_test.go

@@ -9,9 +9,9 @@ import (
 )
 
 func TestHttpsProxyFromGitConfig(t *testing.T) {
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"HTTPS_PROXY": "https://proxy-from-env:8080",
-	}), UniqTestEnv(map[string]string{
+	}, map[string]string{
 		"http.proxy": "https://proxy-from-git-config:8080",
 	}))
 	require.Nil(t, err)
@@ -25,7 +25,7 @@ func TestHttpsProxyFromGitConfig(t *testing.T) {
 }
 
 func TestProxyForURL(t *testing.T) {
-	c, err := NewClient(nil, UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(nil, map[string]string{
 		"http.proxy":                           "https://proxy-for-everyone:8080",
 		"http.https://some-host.com:123.proxy": "https://proxy-for-some-host:8080",
 	}))
@@ -40,9 +40,9 @@ func TestProxyForURL(t *testing.T) {
 }
 
 func TestHttpProxyFromGitConfig(t *testing.T) {
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"HTTPS_PROXY": "https://proxy-from-env:8080",
-	}), UniqTestEnv(map[string]string{
+	}, map[string]string{
 		"http.proxy": "http://proxy-from-git-config:8080",
 	}))
 	require.Nil(t, err)
@@ -56,9 +56,9 @@ func TestHttpProxyFromGitConfig(t *testing.T) {
 }
 
 func TestProxyFromEnvironment(t *testing.T) {
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"HTTPS_PROXY": "https://proxy-from-env:8080",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	req, err := http.NewRequest("GET", "https://some-host.com:123/foo/bar", nil)
@@ -70,7 +70,7 @@ func TestProxyFromEnvironment(t *testing.T) {
 }
 
 func TestProxyIsNil(t *testing.T) {
-	c := &Client{}
+	c, _ := NewClient(nil)
 
 	req, err := http.NewRequest("GET", "http://some-host.com:123/foo/bar", nil)
 	require.Nil(t, err)
@@ -81,9 +81,9 @@ func TestProxyIsNil(t *testing.T) {
 }
 
 func TestProxyNoProxy(t *testing.T) {
-	c, err := NewClient(UniqTestEnv(map[string]string{
+	c, err := NewClient(NewContext(map[string]string{
 		"NO_PROXY": "some-host",
-	}), UniqTestEnv(map[string]string{
+	}, map[string]string{
 		"http.proxy": "https://proxy-from-git-config:8080",
 	}))
 	require.Nil(t, err)

lfsapi/response_test.go

@@ -29,7 +29,7 @@ func TestAuthErrWithBody(t *testing.T) {
 	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
 	assert.Nil(t, err)
 
-	c := &Client{}
+	c, _ := NewClient(nil)
 	_, err = c.Do(req)
 	assert.NotNil(t, err)
 	assert.True(t, errors.IsAuthError(err))
@@ -55,7 +55,7 @@ func TestFatalWithBody(t *testing.T) {
 	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
 	assert.Nil(t, err)
 
-	c := &Client{}
+	c, _ := NewClient(nil)
 	_, err = c.Do(req)
 	assert.NotNil(t, err)
 	assert.True(t, errors.IsFatalError(err))
@@ -64,7 +64,7 @@ func TestFatalWithBody(t *testing.T) {
 }
 
 func TestWithNonFatal500WithBody(t *testing.T) {
-	c := &Client{}
+	c, _ := NewClient(nil)
 
 	var called uint32
 
@@ -116,7 +116,7 @@ func TestAuthErrWithoutBody(t *testing.T) {
 	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
 	assert.Nil(t, err)
 
-	c := &Client{}
+	c, _ := NewClient(nil)
 	_, err = c.Do(req)
 	assert.NotNil(t, err)
 	assert.True(t, errors.IsAuthError(err))
@@ -140,7 +140,7 @@ func TestFatalWithoutBody(t *testing.T) {
 	req, err := http.NewRequest("GET", srv.URL+"/test", nil)
 	assert.Nil(t, err)
 
-	c := &Client{}
+	c, _ := NewClient(nil)
 	_, err = c.Do(req)
 	assert.NotNil(t, err)
 	assert.True(t, errors.IsFatalError(err))
@@ -149,7 +149,7 @@ func TestFatalWithoutBody(t *testing.T) {
 }
 
 func TestWithNonFatal500WithoutBody(t *testing.T) {
-	c := &Client{}
+	c, _ := NewClient(nil)
 
 	var called uint32
 

lfsapi/retries_test.go

@@ -60,7 +60,7 @@ func TestRequestWithRetries(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := NewClient(nil, nil)
+	c, err := NewClient(nil)
 	require.NoError(t, err)
 
 	req, err := http.NewRequest("POST", srv.URL, nil)

lfsapi/ssh.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/git-lfs/git-lfs/config"
 	"github.com/git-lfs/git-lfs/tools"
 	"github.com/rubyist/tracerx"
 )
@@ -69,7 +70,7 @@ func (r *sshAuthResponse) IsExpiredWithin(d time.Duration) (time.Time, bool) {
 }
 
 type sshAuthClient struct {
-	os Env
+	os config.Environment
 }
 
 func (c *sshAuthClient) Resolve(e Endpoint, method string) (sshAuthResponse, error) {
@@ -105,7 +106,7 @@ func (c *sshAuthClient) Resolve(e Endpoint, method string) (sshAuthResponse, err
 	return res, err
 }
 
-func sshGetLFSExeAndArgs(osEnv Env, e Endpoint, method string) (string, []string) {
+func sshGetLFSExeAndArgs(osEnv config.Environment, e Endpoint, method string) (string, []string) {
 	exe, args := sshGetExeAndArgs(osEnv, e)
 	operation := endpointOperation(e, method)
 	args = append(args, fmt.Sprintf("git-lfs-authenticate %s %s", e.SshPath, operation))
@@ -115,7 +116,7 @@ func sshGetLFSExeAndArgs(osEnv Env, e Endpoint, method string) (string, []string
 
 // Return the executable name for ssh on this machine and the base args
 // Base args includes port settings, user/host, everything pre the command to execute
-func sshGetExeAndArgs(osEnv Env, e Endpoint) (exe string, baseargs []string) {
+func sshGetExeAndArgs(osEnv config.Environment, e Endpoint) (exe string, baseargs []string) {
 	isPlink := false
 	isTortoise := false
 

lfsapi/ssh_test.go

@@ -213,7 +213,7 @@ func (r *fakeResolver) Resolve(e Endpoint, method string) (sshAuthResponse, erro
 }
 
 func TestSSHGetLFSExeAndArgs(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{}), nil)
+	cli, err := NewClient(nil)
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -256,10 +256,10 @@ func TestSSHGetLFSExeAndArgs(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsSsh(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "",
 		"GIT_SSH":         "",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -271,10 +271,10 @@ func TestSSHGetExeAndArgsSsh(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsSshCustomPort(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "",
 		"GIT_SSH":         "",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -289,10 +289,10 @@ func TestSSHGetExeAndArgsSshCustomPort(t *testing.T) {
 func TestSSHGetExeAndArgsPlink(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "plink.exe")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "",
 		"GIT_SSH":         plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -306,10 +306,10 @@ func TestSSHGetExeAndArgsPlink(t *testing.T) {
 func TestSSHGetExeAndArgsPlinkCustomPort(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "plink")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "",
 		"GIT_SSH":         plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -324,10 +324,10 @@ func TestSSHGetExeAndArgsPlinkCustomPort(t *testing.T) {
 func TestSSHGetExeAndArgsTortoisePlink(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "tortoiseplink.exe")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "",
 		"GIT_SSH":         plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -341,10 +341,10 @@ func TestSSHGetExeAndArgsTortoisePlink(t *testing.T) {
 func TestSSHGetExeAndArgsTortoisePlinkCustomPort(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "tortoiseplink")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "",
 		"GIT_SSH":         plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -357,10 +357,10 @@ func TestSSHGetExeAndArgsTortoisePlinkCustomPort(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsSshCommandPrecedence(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "sshcmd",
 		"GIT_SSH":         "bad",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -372,9 +372,9 @@ func TestSSHGetExeAndArgsSshCommandPrecedence(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsSshCommandArgs(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "sshcmd --args 1",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -386,9 +386,9 @@ func TestSSHGetExeAndArgsSshCommandArgs(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsSshCommandArgsWithMixedQuotes(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "sshcmd foo 'bar \"baz\"'",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -400,9 +400,9 @@ func TestSSHGetExeAndArgsSshCommandArgsWithMixedQuotes(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsSshCommandCustomPort(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": "sshcmd",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -415,9 +415,9 @@ func TestSSHGetExeAndArgsSshCommandCustomPort(t *testing.T) {
 }
 
 func TestSSHGetLFSExeAndArgsWithCustomSSH(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH": "not-ssh",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	u, err := url.Parse("ssh://git@host.com:12345/repo")
@@ -435,7 +435,7 @@ func TestSSHGetLFSExeAndArgsWithCustomSSH(t *testing.T) {
 }
 
 func TestSSHGetLFSExeAndArgsInvalidOptionsAsHost(t *testing.T) {
-	cli, err := NewClient(nil, nil)
+	cli, err := NewClient(nil)
 	require.Nil(t, err)
 
 	u, err := url.Parse("ssh://-oProxyCommand=gnome-calculator/repo")
@@ -453,9 +453,9 @@ func TestSSHGetLFSExeAndArgsInvalidOptionsAsHost(t *testing.T) {
 }
 
 func TestSSHGetLFSExeAndArgsInvalidOptionsAsHostWithCustomSSH(t *testing.T) {
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH": "not-ssh",
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	u, err := url.Parse("ssh://--oProxyCommand=gnome-calculator/repo")
@@ -473,7 +473,7 @@ func TestSSHGetLFSExeAndArgsInvalidOptionsAsHostWithCustomSSH(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsInvalidOptionsAsHost(t *testing.T) {
-	cli, err := NewClient(nil, nil)
+	cli, err := NewClient(nil)
 	require.Nil(t, err)
 
 	u, err := url.Parse("ssh://-oProxyCommand=gnome-calculator")
@@ -491,7 +491,7 @@ func TestSSHGetExeAndArgsInvalidOptionsAsHost(t *testing.T) {
 }
 
 func TestSSHGetExeAndArgsInvalidOptionsAsPath(t *testing.T) {
-	cli, err := NewClient(nil, nil)
+	cli, err := NewClient(nil)
 	require.Nil(t, err)
 
 	u, err := url.Parse("ssh://git@git-host.com/-oProxyCommand=gnome-calculator")
@@ -533,9 +533,9 @@ func TestParseBareSSHUrl(t *testing.T) {
 func TestSSHGetExeAndArgsPlinkCommand(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "plink.exe")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -549,9 +549,9 @@ func TestSSHGetExeAndArgsPlinkCommand(t *testing.T) {
 func TestSSHGetExeAndArgsPlinkCommandCustomPort(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "plink")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -566,9 +566,9 @@ func TestSSHGetExeAndArgsPlinkCommandCustomPort(t *testing.T) {
 func TestSSHGetExeAndArgsTortoisePlinkCommand(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "tortoiseplink.exe")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")
@@ -582,9 +582,9 @@ func TestSSHGetExeAndArgsTortoisePlinkCommand(t *testing.T) {
 func TestSSHGetExeAndArgsTortoisePlinkCommandCustomPort(t *testing.T) {
 	plink := filepath.Join("Users", "joebloggs", "bin", "tortoiseplink")
 
-	cli, err := NewClient(UniqTestEnv(map[string]string{
+	cli, err := NewClient(NewContext(map[string]string{
 		"GIT_SSH_COMMAND": plink,
-	}), nil)
+	}, nil))
 	require.Nil(t, err)
 
 	endpoint := cli.Endpoints.Endpoint("download", "")

lfsapi/stats_test.go

@@ -33,7 +33,8 @@ func TestStatsWithKey(t *testing.T) {
 	defer srv.Close()
 
 	out := &bytes.Buffer{}
-	c := &Client{ConcurrentTransfers: 5}
+	c, _ := NewClient(nil)
+	c.ConcurrentTransfers = 5
 	c.LogHTTPStats(nopCloser(out))
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
@@ -98,7 +99,8 @@ func TestStatsWithoutKey(t *testing.T) {
 	defer srv.Close()
 
 	out := &bytes.Buffer{}
-	c := &Client{ConcurrentTransfers: 5}
+	c, _ := NewClient(nil)
+	c.ConcurrentTransfers = 5
 	c.LogHTTPStats(nopCloser(out))
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
@@ -139,7 +141,8 @@ func TestStatsDisabled(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c := &Client{ConcurrentTransfers: 5}
+	c, _ := NewClient(nil)
+	c.ConcurrentTransfers = 5
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
 	req = c.LogRequest(req, "stats-test")

lfsapi/verbose_test.go

@@ -37,10 +37,9 @@ func TestVerboseEnabled(t *testing.T) {
 	defer srv.Close()
 
 	out := &bytes.Buffer{}
-	c := &Client{
-		Verbose:    true,
-		VerboseOut: out,
-	}
+	c, _ := NewClient(nil)
+	c.Verbose = true
+	c.VerboseOut = out
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
 	req.Header.Set("Authorization", "Basic ABC")
@@ -94,10 +93,9 @@ func TestVerboseWithBinaryBody(t *testing.T) {
 	defer srv.Close()
 
 	out := &bytes.Buffer{}
-	c := &Client{
-		Verbose:    true,
-		VerboseOut: out,
-	}
+	c, _ := NewClient(nil)
+	c.Verbose = true
+	c.VerboseOut = out
 
 	buf := bytes.NewBufferString("binary-request")
 	req, err := http.NewRequest("POST", srv.URL, buf)
@@ -152,11 +150,10 @@ func TestVerboseEnabledWithDebugging(t *testing.T) {
 	defer srv.Close()
 
 	out := &bytes.Buffer{}
-	c := &Client{
-		Verbose:          true,
-		VerboseOut:       out,
-		DebuggingVerbose: true,
-	}
+	c, _ := NewClient(nil)
+	c.Verbose = true
+	c.VerboseOut = out
+	c.DebuggingVerbose = true
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
 	req.Header.Set("Authorization", "Basic ABC")
@@ -211,11 +208,10 @@ func TestVerboseDisabled(t *testing.T) {
 	defer srv.Close()
 
 	out := &bytes.Buffer{}
-	c := &Client{
-		Verbose:          false,
-		VerboseOut:       out,
-		DebuggingVerbose: true,
-	}
+	c, _ := NewClient(nil)
+	c.Verbose = false
+	c.VerboseOut = out
+	c.DebuggingVerbose = true
 
 	req, err := http.NewRequest("POST", srv.URL, nil)
 	req.Header.Set("Authorization", "Basic ABC")

locking/api_test.go

@@ -52,7 +52,7 @@ func TestAPILock(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/api",
 	}))
 	require.Nil(t, err)
@@ -100,7 +100,7 @@ func TestAPIUnlock(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/api",
 	}))
 	require.Nil(t, err)
@@ -144,7 +144,7 @@ func TestAPISearch(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/api",
 	}))
 	require.Nil(t, err)
@@ -199,7 +199,7 @@ func TestAPIVerifiableLocks(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/api",
 	}))
 	require.Nil(t, err)

locking/locks_test.go

@@ -48,7 +48,7 @@ func TestRefreshCache(t *testing.T) {
 		srv.Close()
 	}()
 
-	lfsclient, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	lfsclient, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url":    srv.URL + "/api",
 		"user.name":  "Fred",
 		"user.email": "fred@bloggs.com",
@@ -119,7 +119,7 @@ func TestGetVerifiableLocks(t *testing.T) {
 
 	defer srv.Close()
 
-	lfsclient, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	lfsclient, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url":    srv.URL + "/api",
 		"user.name":  "Fred",
 		"user.email": "fred@bloggs.com",

test/cmd/lfstest-customadapter.go

@@ -30,7 +30,7 @@ func main() {
 	scanner := bufio.NewScanner(os.Stdin)
 	writer := bufio.NewWriter(os.Stdout)
 	errWriter := bufio.NewWriter(os.Stderr)
-	apiClient, err := lfsapi.NewClient(cfg.Os, cfg.Git)
+	apiClient, err := lfsapi.NewClient(cfg)
 	if err != nil {
 		writeToStderr("Error creating api client: "+err.Error(), errWriter)
 		os.Exit(1)

test/git-lfs-test-server-api/main.go

@@ -148,7 +148,7 @@ func buildManifest(r *test.Repo) (*tq.Manifest, error) {
 		endp = finder.NewEndpoint(apiUrl)
 	}
 
-	apiClient, err := lfsapi.NewClient(r.OSEnv(), r.GitEnv())
+	apiClient, err := lfsapi.NewClient(r)
 	apiClient.Endpoints = &constantEndpoint{
 		e:              endp,
 		EndpointFinder: apiClient.Endpoints,

tq/api_test.go

@@ -54,7 +54,7 @@ func TestAPIBatch(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/api",
 	}))
 	require.Nil(t, err)
@@ -110,7 +110,7 @@ func TestAPIBatchOnlyBasic(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url": srv.URL + "/api",
 	}))
 	require.Nil(t, err)
@@ -128,7 +128,7 @@ func TestAPIBatchOnlyBasic(t *testing.T) {
 }
 
 func TestAPIBatchEmptyObjects(t *testing.T) {
-	c, err := lfsapi.NewClient(nil, nil)
+	c, err := lfsapi.NewClient(nil)
 	require.Nil(t, err)
 
 	tqc := &tqClient{Client: c}

tq/custom_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestCustomTransferBasicConfig(t *testing.T) {
 	path := "/path/to/binary"
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.customtransfer.testsimple.path": path,
 	}))
 	require.Nil(t, err)
@@ -36,7 +36,7 @@ func TestCustomTransferBasicConfig(t *testing.T) {
 func TestCustomTransferDownloadConfig(t *testing.T) {
 	path := "/path/to/binary"
 	args := "-c 1 --whatever"
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.customtransfer.testdownload.path":       path,
 		"lfs.customtransfer.testdownload.args":       args,
 		"lfs.customtransfer.testdownload.concurrent": "false",
@@ -62,7 +62,7 @@ func TestCustomTransferDownloadConfig(t *testing.T) {
 func TestCustomTransferUploadConfig(t *testing.T) {
 	path := "/path/to/binary"
 	args := "-c 1 --whatever"
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.customtransfer.testupload.path":       path,
 		"lfs.customtransfer.testupload.args":       args,
 		"lfs.customtransfer.testupload.concurrent": "false",
@@ -88,7 +88,7 @@ func TestCustomTransferUploadConfig(t *testing.T) {
 func TestCustomTransferBothConfig(t *testing.T) {
 	path := "/path/to/binary"
 	args := "-c 1 --whatever --yeah"
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.customtransfer.testboth.path":       path,
 		"lfs.customtransfer.testboth.args":       args,
 		"lfs.customtransfer.testboth.concurrent": "yes",

tq/manifest.go

@@ -55,7 +55,7 @@ func (m *Manifest) batchClient() *tqClient {
 
 func NewManifest(f *fs.Filesystem, apiClient *lfsapi.Client, operation, remote string) *Manifest {
 	if apiClient == nil {
-		cli, err := lfsapi.NewClient(nil, nil)
+		cli, err := lfsapi.NewClient(nil)
 		if err != nil {
 			tracerx.Printf("unable to init tq.Manifest: %s", err)
 			return nil

tq/manifest_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestManifestIsConfigurable(t *testing.T) {
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.transfer.maxretries": "3",
 	}))
 	require.Nil(t, err)
@@ -19,7 +19,7 @@ func TestManifestIsConfigurable(t *testing.T) {
 }
 
 func TestManifestChecksNTLM(t *testing.T) {
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.url":                 "http://foo",
 		"lfs.http://foo.access":   "ntlm",
 		"lfs.concurrenttransfers": "3",
@@ -31,7 +31,7 @@ func TestManifestChecksNTLM(t *testing.T) {
 }
 
 func TestManifestClampsValidValues(t *testing.T) {
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.transfer.maxretries": "-1",
 	}))
 	require.Nil(t, err)
@@ -41,7 +41,7 @@ func TestManifestClampsValidValues(t *testing.T) {
 }
 
 func TestManifestIgnoresNonInts(t *testing.T) {
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.transfer.maxretries": "not_an_int",
 	}))
 	require.Nil(t, err)

tq/transfer_test.go

@@ -118,7 +118,7 @@ func testAdapterRegAndOverride(t *testing.T) {
 }
 
 func testAdapterRegButBasicOnly(t *testing.T) {
-	cli, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv(map[string]string{
+	cli, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.basictransfersonly": "yes",
 	}))
 	require.Nil(t, err)

tq/verify_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func TestVerifyWithoutAction(t *testing.T) {
-	c := &lfsapi.Client{}
+	c, _ := lfsapi.NewClient(nil)
 	tr := &Transfer{
 		Oid:  "abc",
 		Size: 123,
@@ -44,9 +44,9 @@ func TestVerifySuccess(t *testing.T) {
 	}))
 	defer srv.Close()
 
-	c, err := lfsapi.NewClient(nil, lfsapi.UniqTestEnv{
+	c, err := lfsapi.NewClient(lfsapi.NewContext(nil, map[string]string{
 		"lfs.transfer.maxverifies": "1",
-	})
+	}))
 	require.Nil(t, err)
 	tr := &Transfer{
 		Oid:  "abcd1234",