lunny/git-lfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
e9ffd5dc5c
git-lfs/lfsapi/endpoint_finder_test.go

728 lines
22 KiB
Go
Raw Normal View History

move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
package lfsapi
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
import (
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
"io/ioutil"
"os"
Add support for local paths Currently, we only support local remotes using file URLs, but not local paths. This is a highly requested feature, however, so implement support for local paths as remotes. First, fix the handling of local paths we already have: the handling of absolute Unix-style paths. Instead of checking for the remote to contain a file URL to determine whether to append "info/lfs" to the URL, look to see if the URL we're using is a file URL, which will catch local paths which will have been rewritten as such by this point. The "info/lfs" part of the URL is not handled by the transfer adapter, so we don't want to add it on. If we get something that looks like it's not a URL, check if it's a file on the file system, and if so, don't attempt to interpret it as an SSH URL. This fixes the confusion with Windows paths, which resemble SSH-style locations with a single-letter alias as the host name. Finally, when turning a local path into a file URL, turn the path into an absolute one if possible and rewrite it using slashes, which is required for file URLs. Add several tests for the various cases: one for Unix-style paths, one for native paths, and one for relative paths.
2019-11-13 21:16:45 +00:00
"runtime"
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"testing"
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
"github.com/git-lfs/git-lfs/creds"
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
"github.com/git-lfs/git-lfs/lfshttp"
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"github.com/stretchr/testify/assert"
)
func TestEndpointDefaultsToOrigin(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.lfsurl": "abc",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "abc", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointOverridesOrigin(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"lfs.url": "abc",
"remote.origin.lfsurl": "def",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "abc", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointNoOverrideDefaultRemote(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.lfsurl": "abc",
"remote.other.lfsurl": "def",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "abc", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointUseAlternateRemote(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.lfsurl": "abc",
"remote.other.lfsurl": "def",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "other")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "def", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "https://example.com/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestBareEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "https://example.com/foo/bar.git",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointSeparateClonePushUrl(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "https://example.com/foo/bar.git",
"remote.origin.pushurl": "https://readwrite.com/foo/bar.git",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e = finder.Endpoint("upload", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://readwrite.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointOverriddenSeparateClonePushLfsUrl(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"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",
"remote.origin.lfspushurl": "https://readwritelfs.com/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://examplelfs.com/foo/bar", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e = finder.Endpoint("upload", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://readwritelfs.com/foo/bar", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestEndpointGlobalSeparateLfsPush(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"lfs.url": "https://readonly.com/foo/bar",
"lfs.pushurl": "https://write.com/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://readonly.com/foo/bar", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e = finder.Endpoint("upload", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://write.com/foo/bar", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestSSHEndpointOverridden(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "git@example.com:foo/bar",
"remote.origin.lfsurl": "lfs",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestSSHEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "ssh://git@example.com/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestSSHCustomPortEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "ssh://git@example.com:9000/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar", e.SSHMetadata.Path)
assert.Equal(t, "9000", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
Accept legacy Git SSH URLs For a long time, the preferred way to write an SSH URL for use with Git has been with the "ssh" scheme. However, Git still accepts the "git+ssh" and "ssh+git" schemes for remotes as well, despite marking them as deprecated in the code. For compatibility with Git, accept these schemes as an alias for the "ssh" scheme.
2019-07-15 21:05:09 +00:00
func TestGitSSHEndpointAddsLfsSuffix(t *testing.T) {
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.origin.url": "git+ssh://git@example.com/foo/bar",
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Accept legacy Git SSH URLs For a long time, the preferred way to write an SSH URL for use with Git has been with the "ssh" scheme. However, Git still accepts the "git+ssh" and "ssh+git" schemes for remotes as well, despite marking them as deprecated in the code. For compatibility with Git, accept these schemes as an alias for the "ssh" scheme.
2019-07-15 21:05:09 +00:00
}
func TestGitSSHCustomPortEndpointAddsLfsSuffix(t *testing.T) {
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.origin.url": "git+ssh://git@example.com:9000/foo/bar",
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar", e.SSHMetadata.Path)
assert.Equal(t, "9000", e.SSHMetadata.Port)
Accept legacy Git SSH URLs For a long time, the preferred way to write an SSH URL for use with Git has been with the "ssh" scheme. However, Git still accepts the "git+ssh" and "ssh+git" schemes for remotes as well, despite marking them as deprecated in the code. For compatibility with Git, accept these schemes as an alias for the "ssh" scheme.
2019-07-15 21:05:09 +00:00
}
func TestSSHGitEndpointAddsLfsSuffix(t *testing.T) {
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.origin.url": "ssh+git://git@example.com/foo/bar",
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Accept legacy Git SSH URLs For a long time, the preferred way to write an SSH URL for use with Git has been with the "ssh" scheme. However, Git still accepts the "git+ssh" and "ssh+git" schemes for remotes as well, despite marking them as deprecated in the code. For compatibility with Git, accept these schemes as an alias for the "ssh" scheme.
2019-07-15 21:05:09 +00:00
}
func TestSSHGitCustomPortEndpointAddsLfsSuffix(t *testing.T) {
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.origin.url": "ssh+git://git@example.com:9000/foo/bar",
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar", e.SSHMetadata.Path)
assert.Equal(t, "9000", e.SSHMetadata.Port)
Accept legacy Git SSH URLs For a long time, the preferred way to write an SSH URL for use with Git has been with the "ssh" scheme. However, Git still accepts the "git+ssh" and "ssh+git" schemes for remotes as well, despite marking them as deprecated in the code. For compatibility with Git, accept these schemes as an alias for the "ssh" scheme.
2019-07-15 21:05:09 +00:00
}
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
func TestBareSSHEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "git@example.com:foo/bar.git",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar.git", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
Treat [host:port]:path URLs correctly Remotes with custom ssh ports look like this in .git/config: [remote "origin"] url = [git@example.com:2323]:path/to.git Strip the brackets from the URL parts to support those URLs.
2018-09-05 11:41:16 +00:00
func TestBareSSSHEndpointWithCustomPortInBrackets(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Treat [host:port]:path URLs correctly Remotes with custom ssh ports look like this in .git/config: [remote "origin"] url = [git@example.com:2323]:path/to.git Strip the brackets from the URL parts to support those URLs.
2018-09-05 11:41:16 +00:00
"remote.origin.url": "[git@example.com:2222]:foo/bar.git",
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar.git", e.SSHMetadata.Path)
assert.Equal(t, "2222", e.SSHMetadata.Port)
Treat [host:port]:path URLs correctly Remotes with custom ssh ports look like this in .git/config: [remote "origin"] url = [git@example.com:2323]:path/to.git Strip the brackets from the URL parts to support those URLs.
2018-09-05 11:41:16 +00:00
}
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
func TestSSHEndpointFromGlobalLfsUrl(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"lfs.url": "git@example.com:foo/bar.git",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
assert.Equal(t, "foo/bar.git", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestHTTPEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "http://example.com/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestBareHTTPEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "http://example.com/foo/bar.git",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestGitEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "git://example.com/foo/bar",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestGitEndpointAddsLfsSuffixWithCustomProtocol(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "git://example.com/foo/bar",
"lfs.gitprotocol": "http",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
func TestBareGitEndpointAddsLfsSuffix(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
"remote.origin.url": "git://example.com/foo/bar.git",
}))
move endpoint pkg to lfsapi
2016-12-19 18:45:22 +00:00
e := finder.Endpoint("download", "")
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
assert.Equal(t, "", e.SSHMetadata.Path)
assert.Equal(t, "", e.SSHMetadata.Port)
Move endpoint discovery from git env to endpoint pkg
2016-12-14 04:08:05 +00:00
}
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
func TestLocalPathEndpointAddsDotGitForWorkingRepo(t *testing.T) {
Add support for local paths Currently, we only support local remotes using file URLs, but not local paths. This is a highly requested feature, however, so implement support for local paths as remotes. First, fix the handling of local paths we already have: the handling of absolute Unix-style paths. Instead of checking for the remote to contain a file URL to determine whether to append "info/lfs" to the URL, look to see if the URL we're using is a file URL, which will catch local paths which will have been rewritten as such by this point. The "info/lfs" part of the URL is not handled by the transfer adapter, so we don't want to add it on. If we get something that looks like it's not a URL, check if it's a file on the file system, and if so, don't attempt to interpret it as an SSH URL. This fixes the confusion with Windows paths, which resemble SSH-style locations with a single-letter alias as the host name. Finally, when turning a local path into a file URL, turn the path into an absolute one if possible and rewrite it using slashes, which is required for file URLs. Add several tests for the various cases: one for Unix-style paths, one for native paths, and one for relative paths.
2019-11-13 21:16:45 +00:00
// Windows will add a drive letter to the paths below since we
// canonicalize them.
if runtime.GOOS == "windows" {
return
}
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
path, err := ioutil.TempDir("", "lfsRepo")
assert.Nil(t, err)
path = path + "/local/path"
err = os.MkdirAll(path+"/.git", 0755)
assert.Nil(t, err)
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.origin.url": path,
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "file://"+path+"/.git", e.Url)
os.RemoveAll(path)
}
func TestLocalPathEndpointPreservesDotGitForWorkingRepo(t *testing.T) {
// Windows will add a drive letter to the paths below since we
// canonicalize them.
if runtime.GOOS == "windows" {
return
}
path, err := ioutil.TempDir("", "lfsRepo")
assert.Nil(t, err)
path = path + "/local/path/.git"
err = os.MkdirAll(path, 0755)
assert.Nil(t, err)
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.origin.url": path,
}))
e := finder.Endpoint("download", "")
assert.Equal(t, "file://"+path, e.Url)
os.RemoveAll(path)
}
func TestLocalPathEndpointPreservesNoDotGitForBareRepo(t *testing.T) {
// Windows will add a drive letter to the paths below since we
// canonicalize them.
if runtime.GOOS == "windows" {
return
}
path, err := ioutil.TempDir("", "lfsRepo")
assert.Nil(t, err)
path = path + "/local/path"
err = os.MkdirAll(path, 0755)
assert.Nil(t, err)
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
"remote.origin.url": path,
Map local abspath to file://<abspath> endpoint URL It can be used to configure a standalone transfer agent for local files, like: ``` git config lfs.customtransfer.file.path git-lfs-standalonetransfer-file git config lfs.file:///.standalonetransferagent file ``` The `file://` scheme is required for Git config URL match to work. An absolute path alone cannot be used for URL matching. An example implementation of a transfer agent is available as Gist <https://gist.github.com/sprohaska/f3cd4287d8c41b74fc808b5a5396cad1>. Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2018-03-10 14:43:44 +00:00
}))
e := finder.Endpoint("download", "")
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
assert.Equal(t, "file://"+path, e.Url)
os.RemoveAll(path)
Map local abspath to file://<abspath> endpoint URL It can be used to configure a standalone transfer agent for local files, like: ``` git config lfs.customtransfer.file.path git-lfs-standalonetransfer-file git config lfs.file:///.standalonetransferagent file ``` The `file://` scheme is required for Git config URL match to work. An absolute path alone cannot be used for URL matching. An example implementation of a transfer agent is available as Gist <https://gist.github.com/sprohaska/f3cd4287d8c41b74fc808b5a5396cad1>. Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2018-03-10 14:43:44 +00:00
}
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
func TestLocalPathEndpointRemovesDotGitForBareRepo(t *testing.T) {
Add support for local paths Currently, we only support local remotes using file URLs, but not local paths. This is a highly requested feature, however, so implement support for local paths as remotes. First, fix the handling of local paths we already have: the handling of absolute Unix-style paths. Instead of checking for the remote to contain a file URL to determine whether to append "info/lfs" to the URL, look to see if the URL we're using is a file URL, which will catch local paths which will have been rewritten as such by this point. The "info/lfs" part of the URL is not handled by the transfer adapter, so we don't want to add it on. If we get something that looks like it's not a URL, check if it's a file on the file system, and if so, don't attempt to interpret it as an SSH URL. This fixes the confusion with Windows paths, which resemble SSH-style locations with a single-letter alias as the host name. Finally, when turning a local path into a file URL, turn the path into an absolute one if possible and rewrite it using slashes, which is required for file URLs. Add several tests for the various cases: one for Unix-style paths, one for native paths, and one for relative paths.
2019-11-13 21:16:45 +00:00
// Windows will add a drive letter to the paths below since we
// canonicalize them.
if runtime.GOOS == "windows" {
return
}
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
path, err := ioutil.TempDir("", "lfsRepo")
assert.Nil(t, err)
path = path + "/local/path"
err = os.MkdirAll(path, 0755)
assert.Nil(t, err)
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
"remote.origin.url": path + "/.git",
Map local abspath to file://<abspath> endpoint URL It can be used to configure a standalone transfer agent for local files, like: ``` git config lfs.customtransfer.file.path git-lfs-standalonetransfer-file git config lfs.file:///.standalonetransferagent file ``` The `file://` scheme is required for Git config URL match to work. An absolute path alone cannot be used for URL matching. An example implementation of a transfer agent is available as Gist <https://gist.github.com/sprohaska/f3cd4287d8c41b74fc808b5a5396cad1>. Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2018-03-10 14:43:44 +00:00
}))
e := finder.Endpoint("download", "")
lfs{api,http}: test bare repo local path endpoints When generating a local path endpoint, we now test whether the path corresponds to a bare repo lacking a .git directory, and if so, we ensure the endpoint path has any trailing .git segment trimmed. Conversely, we ensure the endpoint path has a final .git segment if a .git directory is found. The test suite is updated to check the four relevant cases.
2020-04-02 00:37:50 +00:00
assert.Equal(t, "file://"+path, e.Url)
os.RemoveAll(path)
Map local abspath to file://<abspath> endpoint URL It can be used to configure a standalone transfer agent for local files, like: ``` git config lfs.customtransfer.file.path git-lfs-standalonetransfer-file git config lfs.file:///.standalonetransferagent file ``` The `file://` scheme is required for Git config URL match to work. An absolute path alone cannot be used for URL matching. An example implementation of a transfer agent is available as Gist <https://gist.github.com/sprohaska/f3cd4287d8c41b74fc808b5a5396cad1>. Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2018-03-10 14:43:44 +00:00
}
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
func TestAccessConfig(t *testing.T) {
type accessTest struct {
lfsapi: rename Access->AccessMode
2018-09-20 17:21:42 +00:00
AccessMode string
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
PrivateAccess bool
}
tests := map[string]accessTest{
"": {"none", false},
"basic": {"basic", true},
"BASIC": {"basic", true},
"private": {"basic", true},
"PRIVATE": {"basic", true},
"invalidauth": {"invalidauth", true},
}
for value, expected := range tests {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
"lfs.url": "http://example.com",
"lfs.http://example.com.access": value,
"lfs.https://example.com.access": "bad",
}))
dl := finder.Endpoint("upload", "")
ul := finder.Endpoint("download", "")
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
if access := finder.AccessFor(dl.Url); access.Mode() != creds.AccessMode(expected.AccessMode) {
t.Errorf("Expected creds.AccessMode() with value %q to be %v, got %v", value, expected.AccessMode, access)
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
}
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
if access := finder.AccessFor(ul.Url); access.Mode() != creds.AccessMode(expected.AccessMode) {
t.Errorf("Expected creds.AccessMode() with value %q to be %v, got %v", value, expected.AccessMode, access)
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
}
}
// Test again but with separate push url
for value, expected := range tests {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
"lfs.url": "http://example.com",
"lfs.pushurl": "http://examplepush.com",
"lfs.http://example.com.access": value,
"lfs.http://examplepush.com.access": value,
"lfs.https://example.com.access": "bad",
}))
dl := finder.Endpoint("upload", "")
ul := finder.Endpoint("download", "")
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
if access := finder.AccessFor(dl.Url); access.Mode() != creds.AccessMode(expected.AccessMode) {
t.Errorf("Expected creds.AccessMode() with value %q to be %v, got %v", value, expected.AccessMode, access)
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
}
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
if access := finder.AccessFor(ul.Url); access.Mode() != creds.AccessMode(expected.AccessMode) {
t.Errorf("Expected creds.AccessMode() with value %q to be %v, got %v", value, expected.AccessMode, access)
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
}
}
}
func TestAccessAbsentConfig(t *testing.T) {
finder := NewEndpointFinder(nil)
lfsapi: rename Access.GetMode()->Mode() Rename Access.GetMode() to Access.Mode(), and use it in the EndpointFinder implementation and tests instead of directly accessing the `mode` member
2018-10-02 23:35:54 +00:00
downloadAccess := finder.AccessFor(finder.Endpoint("download", "").Url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.NoneAccess, downloadAccess.Mode())
lfsapi: rename Access.GetMode()->Mode() Rename Access.GetMode() to Access.Mode(), and use it in the EndpointFinder implementation and tests instead of directly accessing the `mode` member
2018-10-02 23:35:54 +00:00
uploadAccess := finder.AccessFor(finder.Endpoint("upload", "").Url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.NoneAccess, uploadAccess.Mode())
simplify AccessFor signature
2016-12-19 18:55:47 +00:00
}
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
func TestSetAccess(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{}))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
url := "http://example.com"
access := finder.AccessFor(url)
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.NoneAccess, access.Mode())
assert.Equal(t, url, access.URL())
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
Remove NTLM support Our NTLM support has been known to be broken in various situations for a while, specifically on Windows. The core team is unable to troubleshoot these problems, and nobody has stepped up to maintain the NTLM support. In addition, NTLM uses cryptography and security techniques that are known to be insecure, such as the algorithms DES, MD4, and MD5, as well as simple, unsalted hashes of passwords. Since we now support Kerberos, most users should be able to replace their use of NTLM with Kerberos instead. Users have reported this working on Windows and it is known to work well on at least Debian as well. Drop support for NTLM and remove it from the codebase.
2021-01-12 22:44:28 +00:00
finder.SetAccess(access.Upgrade(creds.NegotiateAccess))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
newAccess := finder.AccessFor(url)
Remove NTLM support Our NTLM support has been known to be broken in various situations for a while, specifically on Windows. The core team is unable to troubleshoot these problems, and nobody has stepped up to maintain the NTLM support. In addition, NTLM uses cryptography and security techniques that are known to be insecure, such as the algorithms DES, MD4, and MD5, as well as simple, unsalted hashes of passwords. Since we now support Kerberos, most users should be able to replace their use of NTLM with Kerberos instead. Users have reported this working on Windows and it is known to work well on at least Debian as well. Drop support for NTLM and remove it from the codebase.
2021-01-12 22:44:28 +00:00
assert.Equal(t, creds.NegotiateAccess, newAccess.Mode())
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, url, newAccess.URL())
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
}
func TestChangeAccess(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
"lfs.http://example.com.access": "basic",
}))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
url := "http://example.com"
access := finder.AccessFor(url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.BasicAccess, access.Mode())
assert.Equal(t, url, access.URL())
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
Remove NTLM support Our NTLM support has been known to be broken in various situations for a while, specifically on Windows. The core team is unable to troubleshoot these problems, and nobody has stepped up to maintain the NTLM support. In addition, NTLM uses cryptography and security techniques that are known to be insecure, such as the algorithms DES, MD4, and MD5, as well as simple, unsalted hashes of passwords. Since we now support Kerberos, most users should be able to replace their use of NTLM with Kerberos instead. Users have reported this working on Windows and it is known to work well on at least Debian as well. Drop support for NTLM and remove it from the codebase.
2021-01-12 22:44:28 +00:00
finder.SetAccess(access.Upgrade(creds.NegotiateAccess))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
newAccess := finder.AccessFor(url)
Remove NTLM support Our NTLM support has been known to be broken in various situations for a while, specifically on Windows. The core team is unable to troubleshoot these problems, and nobody has stepped up to maintain the NTLM support. In addition, NTLM uses cryptography and security techniques that are known to be insecure, such as the algorithms DES, MD4, and MD5, as well as simple, unsalted hashes of passwords. Since we now support Kerberos, most users should be able to replace their use of NTLM with Kerberos instead. Users have reported this working on Windows and it is known to work well on at least Debian as well. Drop support for NTLM and remove it from the codebase.
2021-01-12 22:44:28 +00:00
assert.Equal(t, creds.NegotiateAccess, newAccess.Mode())
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, url, newAccess.URL())
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
}
func TestDeleteAccessWithNone(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
"lfs.http://example.com.access": "basic",
}))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
url := "http://example.com"
access := finder.AccessFor(url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.BasicAccess, access.Mode())
assert.Equal(t, url, access.URL())
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
finder.SetAccess(access.Upgrade(creds.NoneAccess))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
newAccess := finder.AccessFor(url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.NoneAccess, newAccess.Mode())
assert.Equal(t, url, newAccess.URL())
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
}
func TestDeleteAccessWithEmptyString(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
"lfs.http://example.com.access": "basic",
}))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
url := "http://example.com"
access := finder.AccessFor(url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.BasicAccess, access.Mode())
assert.Equal(t, url, access.URL())
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
finder.SetAccess(access.Upgrade(creds.AccessMode("")))
lfsapi: add new Access type Add a new Access type returned by the EndpointFinder. This type contains a URL and the AccessMode associated with it. It also contains an `Upgrade()` function, which returns a copy of the Access object but with a new AccessMode.
2018-09-24 18:50:09 +00:00
newAccess := finder.AccessFor(url)
creds: move Access types into creds package In the future, we're going to need to access the access-related types in the lfshttp package. To avoid an import loop, move Access and AccessMode into the creds package. Add constructors and accessors since the members are private.
2019-11-28 19:03:52 +00:00
assert.Equal(t, creds.NoneAccess, newAccess.Mode())
assert.Equal(t, url, newAccess.URL())
Teach the endpointGitFinder how to set access type
2016-12-19 19:24:22 +00:00
}
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
type EndpointParsingTestCase struct {
Given string
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
Expected lfshttp.Endpoint
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
}
func (c *EndpointParsingTestCase) Assert(t *testing.T) {
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
"url.https://github.com/.insteadof": "gh:",
}))
lfsapi: always pass operation when creating an endpoint In a future commit, we're going to need to know the operation when performing Git URL replacement, so ensure that the operation is passed whenever we're creating an endpoint.
2018-10-26 17:41:07 +00:00
actual := finder.NewEndpoint("upload", c.Given)
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
assert.Equal(t, c.Expected, actual, "lfsapi: expected endpoint for %q to be %#v (was %#v)", c.Given, c.Expected, actual)
}
func TestEndpointParsing(t *testing.T) {
// Note that many of these tests will produce silly or completely broken
// values for the Url, and that's okay: they work nevertheless.
for desc, c := range map[string]EndpointParsingTestCase{
"simple bare ssh": {
"git@github.com:git-lfs/git-lfs.git",
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://github.com/git-lfs/git-lfs.git",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "git@github.com",
Path: "git-lfs/git-lfs.git",
Port: "",
},
Operation: "",
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
},
},
"port bare ssh": {
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
"[git@lfshttp.github.com:443]:git-lfs/git-lfs.git",
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://lfshttp.github.com/git-lfs/git-lfs.git",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "git@lfshttp.github.com",
Path: "git-lfs/git-lfs.git",
Port: "443",
},
Operation: "",
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
},
},
"no user bare ssh": {
"github.com:git-lfs/git-lfs.git",
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://github.com/git-lfs/git-lfs.git",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "github.com",
Path: "git-lfs/git-lfs.git",
Port: "",
},
Operation: "",
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
},
},
"bare word bare ssh": {
"github:git-lfs/git-lfs.git",
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://github/git-lfs/git-lfs.git",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "github",
Path: "git-lfs/git-lfs.git",
Port: "",
},
Operation: "",
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
},
},
"insteadof alias": {
"gh:git-lfs/git-lfs.git",
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://github.com/git-lfs/git-lfs.git",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "",
Path: "",
Port: "",
},
Operation: "",
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
},
},
"remote helper": {
"remote::git-lfs/git-lfs.git",
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "remote::git-lfs/git-lfs.git",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "",
Path: "",
Port: "",
},
Operation: "",
lfsapi: handle SSH hostnames and aliases without users It's very common for a user to specify an SSH remote that refers to an alias in their gitconfig file. For example, if a user must use different SSH keys when pushing to different remotes, setting different aliases that use those different keys is the simplest and easiest way to accomplish that goal. Unfortunately, our parsing logic was broken for SSH remotes that used bare SSH URLs (that is, without “ssh://”) with a hostname or alias, but without a username component. The URL parser we used saw the hostname portion as the scheme of a URL, and we passed through any URLs with unknown schemes. This led to a failure to push, since we misparsed the URL as a non-SSH URL and gave up when it also didn't look like an HTTP(S) URL. If we get an unknown “scheme” when parsing a URL, check if the URL uses a remote helper (that is, it contains a double colon), and pass it through. Otherwise, do what Git does, and assume the URL is in fact an SSH URL, and handle it accordingly. We already handle the url.insteadof syntax properly, even if it looks like a scheme. Add tests that we continue to do so, and for the new code and all the various permutations mentioned above, and update the existing integration test to reflect our new parsing strategy.
2018-09-05 21:23:12 +00:00
},
},
} {
t.Run(desc, c.Assert)
}
}
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
lfsapi: support pushInsteadOf aliases For pushes, Git looks at both the insteadOf and pushInsteadOf aliases, and uses the latter in preference to the former. Teach Git LFS to honor pushInsteadOf as well when uploading.
2018-10-26 19:16:07 +00:00
type InsteadOfTestCase struct {
Given string
Operation string
Expected lfshttp.Endpoint
}
func (c *InsteadOfTestCase) Assert(t *testing.T) {
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
"remote.test.url": c.Given,
"url.https://example.com/.insteadof": "ex:",
"url.ssh://example.com/.pushinsteadof": "ex:",
"url.ssh://example.com/.insteadof": "exp:",
}))
actual := finder.Endpoint(c.Operation, "test")
assert.Equal(t, c.Expected, actual, "lfsapi: expected endpoint for %q to be %#v (was %#v)", c.Given, c.Expected, actual)
}
func TestInsteadOf(t *testing.T) {
// Note that many of these tests will produce silly or completely broken
// values for the Url, and that's okay: they work nevertheless.
for desc, c := range map[string]InsteadOfTestCase{
"insteadof alias (download)": {
"ex:git-lfs/git-lfs.git",
"download",
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "",
Path: "",
Port: "",
},
Operation: "download",
lfsapi: support pushInsteadOf aliases For pushes, Git looks at both the insteadOf and pushInsteadOf aliases, and uses the latter in preference to the former. Teach Git LFS to honor pushInsteadOf as well when uploading.
2018-10-26 19:16:07 +00:00
},
},
"pushinsteadof alias (upload)": {
"ex:git-lfs/git-lfs.git",
"upload",
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "example.com",
Path: "git-lfs/git-lfs.git",
Port: "",
},
Operation: "upload",
lfsapi: support pushInsteadOf aliases For pushes, Git looks at both the insteadOf and pushInsteadOf aliases, and uses the latter in preference to the former. Teach Git LFS to honor pushInsteadOf as well when uploading.
2018-10-26 19:16:07 +00:00
},
},
"exp alias (download)": {
"exp:git-lfs/git-lfs.git",
"download",
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "example.com",
Path: "git-lfs/git-lfs.git",
Port: "",
},
Operation: "download",
lfsapi: support pushInsteadOf aliases For pushes, Git looks at both the insteadOf and pushInsteadOf aliases, and uses the latter in preference to the former. Teach Git LFS to honor pushInsteadOf as well when uploading.
2018-10-26 19:16:07 +00:00
},
},
"exp alias (upload)": {
"exp:git-lfs/git-lfs.git",
"upload",
lfshttp.Endpoint{
lfshttp: use a separate struct for SSH metadata Right now, all of the SSH metadata for an endpoint is in the Endpoint struct, but in the future we'd like to move the SSH code to its own package. At that point, we'll want to avoid a dependency on the Endpoint struct, so let's move the SSH metadata out into its own struct, which we'll include in Endpoint. While we're at it, let's adjust most of the SSH code to use this new struct instead so we can easily move it in the future.
2021-02-03 21:46:28 +00:00
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
SSHMetadata: lfshttp.SSHMetadata{
UserAndHost: "example.com",
Path: "git-lfs/git-lfs.git",
Port: "",
},
Operation: "upload",
lfsapi: support pushInsteadOf aliases For pushes, Git looks at both the insteadOf and pushInsteadOf aliases, and uses the latter in preference to the former. Teach Git LFS to honor pushInsteadOf as well when uploading.
2018-10-26 19:16:07 +00:00
},
},
} {
t.Run(desc, c.Assert)
}
}
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
func TestNewEndpointFromCloneURLWithConfig(t *testing.T) {
expected := "https://foo/bar.git/info/lfs"
tests := []string{
"https://foo/bar",
"https://foo/bar/",
"https://foo/bar.git",
"https://foo/bar.git/",
}
finder := NewEndpointFinder(nil)
for _, actual := range tests {
lfsapi: always pass operation when creating an endpoint In a future commit, we're going to need to know the operation when performing Git URL replacement, so ensure that the operation is passed whenever we're creating an endpoint.
2018-10-26 17:41:07 +00:00
e := finder.NewEndpointFromCloneURL("upload", actual)
lfsapi: extract new lfshttp package Extract more basic http-related functionality out of lfsapi and into a new package, lfshttp. Everything is currently functional aside from authorization.
2018-09-06 21:42:41 +00:00
if e.Url != expected {
t.Errorf("%s returned bad endpoint url %s", actual, e.Url)
}
}
}
Reference in New Issue Copy Permalink