2016-12-19 18:45:22 +00:00
|
|
|
package lfsapi
|
2016-12-14 04:08:05 +00:00
|
|
|
|
|
|
|
import (
|
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"
|
2016-12-14 04:08:05 +00:00
|
|
|
"testing"
|
2023-07-27 07:35:20 +00:00
|
|
|
"regexp"
|
2016-12-14 04:08:05 +00:00
|
|
|
|
2021-09-01 19:41:10 +00:00
|
|
|
"github.com/git-lfs/git-lfs/v3/creds"
|
|
|
|
"github.com/git-lfs/git-lfs/v3/lfshttp"
|
|
|
|
"github.com/git-lfs/git-lfs/v3/ssh"
|
2016-12-14 04:08:05 +00:00
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
)
|
|
|
|
|
|
|
|
func TestEndpointDefaultsToOrigin(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.lfsurl": "abc",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "abc", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointOverridesOrigin(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"lfs.url": "abc",
|
|
|
|
"remote.origin.lfsurl": "def",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "abc", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointNoOverrideDefaultRemote(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.lfsurl": "abc",
|
|
|
|
"remote.other.lfsurl": "def",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "abc", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointUseAlternateRemote(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.lfsurl": "abc",
|
|
|
|
"remote.other.lfsurl": "def",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "other")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "def", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "https://example.com/foo/bar",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestBareEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "https://example.com/foo/bar.git",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointSeparateClonePushUrl(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
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",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e = finder.Endpoint("upload", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://readwrite.com/foo/bar.git/info/lfs", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointOverriddenSeparateClonePushLfsUrl(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
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",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://examplelfs.com/foo/bar", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e = finder.Endpoint("upload", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://readwritelfs.com/foo/bar", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEndpointGlobalSeparateLfsPush(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"lfs.url": "https://readonly.com/foo/bar",
|
|
|
|
"lfs.pushurl": "https://write.com/foo/bar",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://readonly.com/foo/bar", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e = finder.Endpoint("upload", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://write.com/foo/bar", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.UserAndHost)
|
|
|
|
assert.Equal(t, "", e.SSHMetadata.Path)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSSHEndpointOverridden(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "git@example.com:foo/bar",
|
|
|
|
"remote.origin.lfsurl": "lfs",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSSHEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "ssh://git@example.com/foo/bar",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
assert.Equal(t, "/foo/bar", e.SSHMetadata.Path)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.Port)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSSHCustomPortEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "ssh://git@example.com:9000/foo/bar",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
assert.Equal(t, "/foo/bar", e.SSHMetadata.Path)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "9000", e.SSHMetadata.Port)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
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)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
assert.Equal(t, "/foo/bar", e.SSHMetadata.Path)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.Port)
|
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)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
assert.Equal(t, "/foo/bar", e.SSHMetadata.Path)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "9000", e.SSHMetadata.Port)
|
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)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
assert.Equal(t, "/foo/bar", e.SSHMetadata.Path)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "", e.SSHMetadata.Port)
|
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)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "git@example.com", e.SSHMetadata.UserAndHost)
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
assert.Equal(t, "/foo/bar", e.SSHMetadata.Path)
|
2021-02-03 21:46:28 +00:00
|
|
|
assert.Equal(t, "9000", e.SSHMetadata.Port)
|
2019-07-15 21:05:09 +00:00
|
|
|
}
|
|
|
|
|
2016-12-14 04:08:05 +00:00
|
|
|
func TestBareSSHEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "git@example.com:foo/bar.git",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
2018-09-05 11:41:16 +00:00
|
|
|
func TestBareSSSHEndpointWithCustomPortInBrackets(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
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)
|
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)
|
2018-09-05 11:41:16 +00:00
|
|
|
}
|
|
|
|
|
2016-12-14 04:08:05 +00:00
|
|
|
func TestSSHEndpointFromGlobalLfsUrl(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"lfs.url": "git@example.com:foo/bar.git",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestHTTPEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "http://example.com/foo/bar",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestBareHTTPEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "http://example.com/foo/bar.git",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestGitEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "git://example.com/foo/bar",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestGitEndpointAddsLfsSuffixWithCustomProtocol(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "git://example.com/foo/bar",
|
|
|
|
"lfs.gitprotocol": "http",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestBareGitEndpointAddsLfsSuffix(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-14 04:08:05 +00:00
|
|
|
"remote.origin.url": "git://example.com/foo/bar.git",
|
|
|
|
}))
|
|
|
|
|
2016-12-19 18:45:22 +00:00
|
|
|
e := finder.Endpoint("download", "")
|
2016-12-14 04:08:05 +00:00
|
|
|
assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", e.Url)
|
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)
|
2016-12-14 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2020-04-02 00:37:50 +00:00
|
|
|
"remote.origin.url": path,
|
2018-03-10 14:43:44 +00:00
|
|
|
}))
|
|
|
|
e := finder.Endpoint("download", "")
|
2020-04-02 00:37:50 +00:00
|
|
|
assert.Equal(t, "file://"+path, e.Url)
|
|
|
|
|
|
|
|
os.RemoveAll(path)
|
2018-03-10 14:43:44 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2020-04-02 00:37:50 +00:00
|
|
|
"remote.origin.url": path + "/.git",
|
2018-03-10 14:43:44 +00:00
|
|
|
}))
|
|
|
|
e := finder.Endpoint("download", "")
|
2020-04-02 00:37:50 +00:00
|
|
|
assert.Equal(t, "file://"+path, e.Url)
|
|
|
|
|
|
|
|
os.RemoveAll(path)
|
2018-03-10 14:43:44 +00:00
|
|
|
}
|
|
|
|
|
2016-12-19 18:55:47 +00:00
|
|
|
func TestAccessConfig(t *testing.T) {
|
|
|
|
type accessTest struct {
|
2018-09-20 17:21:42 +00:00
|
|
|
AccessMode string
|
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 {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
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", "")
|
|
|
|
|
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)
|
2016-12-19 18:55:47 +00:00
|
|
|
}
|
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)
|
2016-12-19 18:55:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test again but with separate push url
|
|
|
|
for value, expected := range tests {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
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", "")
|
|
|
|
|
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)
|
2016-12-19 18:55:47 +00:00
|
|
|
}
|
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)
|
2016-12-19 18:55:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestAccessAbsentConfig(t *testing.T) {
|
|
|
|
finder := NewEndpointFinder(nil)
|
2018-10-02 23:35:54 +00:00
|
|
|
|
|
|
|
downloadAccess := finder.AccessFor(finder.Endpoint("download", "").Url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.NoneAccess, downloadAccess.Mode())
|
2018-10-02 23:35:54 +00:00
|
|
|
|
|
|
|
uploadAccess := finder.AccessFor(finder.Endpoint("upload", "").Url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.NoneAccess, uploadAccess.Mode())
|
2016-12-19 18:55:47 +00:00
|
|
|
}
|
|
|
|
|
2016-12-19 19:24:22 +00:00
|
|
|
func TestSetAccess(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{}))
|
2018-09-24 18:50:09 +00:00
|
|
|
url := "http://example.com"
|
|
|
|
access := finder.AccessFor(url)
|
2016-12-19 19:24:22 +00:00
|
|
|
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.NoneAccess, access.Mode())
|
|
|
|
assert.Equal(t, url, access.URL())
|
2018-09-24 18:50:09 +00:00
|
|
|
|
2021-01-12 22:44:28 +00:00
|
|
|
finder.SetAccess(access.Upgrade(creds.NegotiateAccess))
|
2018-09-24 18:50:09 +00:00
|
|
|
|
|
|
|
newAccess := finder.AccessFor(url)
|
2021-01-12 22:44:28 +00:00
|
|
|
assert.Equal(t, creds.NegotiateAccess, newAccess.Mode())
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, url, newAccess.URL())
|
2016-12-19 19:24:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestChangeAccess(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-19 19:24:22 +00:00
|
|
|
"lfs.http://example.com.access": "basic",
|
|
|
|
}))
|
|
|
|
|
2018-09-24 18:50:09 +00:00
|
|
|
url := "http://example.com"
|
|
|
|
access := finder.AccessFor(url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.BasicAccess, access.Mode())
|
|
|
|
assert.Equal(t, url, access.URL())
|
2018-09-24 18:50:09 +00:00
|
|
|
|
2021-01-12 22:44:28 +00:00
|
|
|
finder.SetAccess(access.Upgrade(creds.NegotiateAccess))
|
2018-09-24 18:50:09 +00:00
|
|
|
|
|
|
|
newAccess := finder.AccessFor(url)
|
2021-01-12 22:44:28 +00:00
|
|
|
assert.Equal(t, creds.NegotiateAccess, newAccess.Mode())
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, url, newAccess.URL())
|
2016-12-19 19:24:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestDeleteAccessWithNone(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-19 19:24:22 +00:00
|
|
|
"lfs.http://example.com.access": "basic",
|
|
|
|
}))
|
|
|
|
|
2018-09-24 18:50:09 +00:00
|
|
|
url := "http://example.com"
|
|
|
|
|
|
|
|
access := finder.AccessFor(url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.BasicAccess, access.Mode())
|
|
|
|
assert.Equal(t, url, access.URL())
|
2018-09-24 18:50:09 +00:00
|
|
|
|
2019-11-28 19:03:52 +00:00
|
|
|
finder.SetAccess(access.Upgrade(creds.NoneAccess))
|
2018-09-24 18:50:09 +00:00
|
|
|
|
|
|
|
newAccess := finder.AccessFor(url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.NoneAccess, newAccess.Mode())
|
|
|
|
assert.Equal(t, url, newAccess.URL())
|
2016-12-19 19:24:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestDeleteAccessWithEmptyString(t *testing.T) {
|
2018-09-06 21:42:41 +00:00
|
|
|
finder := NewEndpointFinder(lfshttp.NewContext(nil, nil, map[string]string{
|
2016-12-19 19:24:22 +00:00
|
|
|
"lfs.http://example.com.access": "basic",
|
|
|
|
}))
|
|
|
|
|
2018-09-24 18:50:09 +00:00
|
|
|
url := "http://example.com"
|
|
|
|
|
|
|
|
access := finder.AccessFor(url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.BasicAccess, access.Mode())
|
|
|
|
assert.Equal(t, url, access.URL())
|
2018-09-24 18:50:09 +00:00
|
|
|
|
2019-11-28 19:03:52 +00:00
|
|
|
finder.SetAccess(access.Upgrade(creds.AccessMode("")))
|
2018-09-24 18:50:09 +00:00
|
|
|
|
|
|
|
newAccess := finder.AccessFor(url)
|
2019-11-28 19:03:52 +00:00
|
|
|
assert.Equal(t, creds.NoneAccess, newAccess.Mode())
|
|
|
|
assert.Equal(t, url, newAccess.URL())
|
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
|
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) {
|
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:",
|
|
|
|
}))
|
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",
|
2018-09-06 21:42:41 +00:00
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://github.com/git-lfs/git-lfs.git",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
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": {
|
2021-02-03 21:46:28 +00:00
|
|
|
"[git@lfshttp.github.com:443]:git-lfs/git-lfs.git",
|
2018-09-06 21:42:41 +00:00
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://lfshttp.github.com/git-lfs/git-lfs.git",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
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",
|
2018-09-06 21:42:41 +00:00
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://github.com/git-lfs/git-lfs.git",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
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",
|
2018-09-06 21:42:41 +00:00
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://github/git-lfs/git-lfs.git",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
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",
|
2018-09-06 21:42:41 +00:00
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://github.com/git-lfs/git-lfs.git",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
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",
|
2018-09-06 21:42:41 +00:00
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "remote::git-lfs/git-lfs.git",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
2018-09-06 21:42:41 +00:00
|
|
|
|
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{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
UserAndHost: "",
|
|
|
|
Path: "",
|
|
|
|
Port: "",
|
|
|
|
},
|
|
|
|
Operation: "download",
|
2018-10-26 19:16:07 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
"pushinsteadof alias (upload)": {
|
|
|
|
"ex:git-lfs/git-lfs.git",
|
|
|
|
"upload",
|
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
UserAndHost: "example.com",
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
Path: "/git-lfs/git-lfs.git",
|
2021-02-03 21:46:28 +00:00
|
|
|
Port: "",
|
|
|
|
},
|
|
|
|
Operation: "upload",
|
2018-10-26 19:16:07 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
"exp alias (download)": {
|
|
|
|
"exp:git-lfs/git-lfs.git",
|
|
|
|
"download",
|
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
UserAndHost: "example.com",
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
Path: "/git-lfs/git-lfs.git",
|
2021-02-03 21:46:28 +00:00
|
|
|
Port: "",
|
|
|
|
},
|
|
|
|
Operation: "download",
|
2018-10-26 19:16:07 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
"exp alias (upload)": {
|
|
|
|
"exp:git-lfs/git-lfs.git",
|
|
|
|
"upload",
|
|
|
|
lfshttp.Endpoint{
|
2021-02-03 21:46:28 +00:00
|
|
|
Url: "https://example.com/git-lfs/git-lfs.git/info/lfs",
|
2021-02-03 22:27:01 +00:00
|
|
|
SSHMetadata: ssh.SSHMetadata{
|
2021-02-03 21:46:28 +00:00
|
|
|
UserAndHost: "example.com",
|
lfshttp: don't strip off initial slash on SSH commands
When we process an SSH URL, we intentionally strip off the slash at the
beginning of the URL. While that was convenient for
git-lfs-authenticate, it also prevents us from handling an absolute path
in git-lfs-transfer, since the path will have its leading slash stripped
off and will therefore be relative.
Instead, let's adopt Git's behavior, which is to not remove the leading
slash. This is an incompatible change, but we're about to do a major
release, so it's a good time to make it. This will affect both
git-lfs-transfer and git-lfs-authenticate commands, but at least GitHub
already supports the proper syntax.
Note that since we process the non-URL form of SSH remotes by converting
them to a URL and then parsing, let's strip off the leading slash when
we process that form, since there we do have the ability to distinguish
between absolute and relative paths.
Update the lfs-ssh-echo binary to handle this new format.
2021-05-14 18:00:23 +00:00
|
|
|
Path: "/git-lfs/git-lfs.git",
|
2021-02-03 21:46:28 +00:00
|
|
|
Port: "",
|
|
|
|
},
|
|
|
|
Operation: "upload",
|
2018-10-26 19:16:07 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
} {
|
|
|
|
t.Run(desc, c.Assert)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 {
|
2018-10-26 17:41:07 +00:00
|
|
|
e := finder.NewEndpointFromCloneURL("upload", actual)
|
2018-09-06 21:42:41 +00:00
|
|
|
if e.Url != expected {
|
|
|
|
t.Errorf("%s returned bad endpoint url %s", actual, e.Url)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-07-27 07:35:20 +00:00
|
|
|
|
|
|
|
func TestExtractRemoteUrlForHTTPS(t *testing.T) {
|
|
|
|
line := "14d0e09d4643d7547267c1cbf9972ac1c4db0b2d not-for-merge branch 'master' of https://example.com/git-lfs/git-lfs"
|
|
|
|
expected := "https://example.com/git-lfs/git-lfs"
|
|
|
|
|
|
|
|
result, err := ExtractRemoteUrl(line)
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, expected, result)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestExtractRemoteUrlForSSH(t *testing.T) {
|
|
|
|
line := "cb2ad9f68531e6afe76326d46acf566acf8af4f9 branch 'master' of ssh://example.com/git-lfs/git-lfs"
|
|
|
|
expected := "ssh://example.com/git-lfs/git-lfs"
|
|
|
|
|
|
|
|
result, err := ExtractRemoteUrl(line)
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, expected, result)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestExtractRemoteUrlForGit(t *testing.T) {
|
|
|
|
line := "90ed234fb0708235a733bcae0e5b90bd4fac5321 branch 'master' of example.com:git-lfs/git-lfs"
|
|
|
|
expected := "example.com:git-lfs/git-lfs"
|
|
|
|
|
|
|
|
result, err := ExtractRemoteUrl(line)
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, expected, result)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestExtractRemoteUrlNoURL(t *testing.T) {
|
|
|
|
invalid := []string{
|
|
|
|
"text without url",
|
|
|
|
// invalid characters in base64 git hash
|
|
|
|
"qwert34fb0708235a733bcae0e5b90bd4fac5321 branch 'master' of example.com:git-lfs/git-lfs",
|
|
|
|
// invalid git hash length
|
|
|
|
"90ed234fb0708235a733bcae0e5b90bd4fac532 branch 'master' of example.com:git-lfs/git-lfs",
|
|
|
|
// other label present where only `not-for-merge` label allowed
|
|
|
|
"90ed234fb0708235a733bcae0e5b90bd4fac532 disallowed-label branch 'master' of example.com:git-lfs/git-lfs",
|
|
|
|
// other type present where only `tag` or `branch` allowed
|
|
|
|
"90ed234fb0708235a733bcae0e5b90bd4fac532 othertype 'master' of example.com:git-lfs/git-lfs",
|
|
|
|
// missing `of`
|
|
|
|
"90ed234fb0708235a733bcae0e5b90bd4fac5321 branch 'master' example.com:git-lfs/git-lfs",
|
|
|
|
// missing `'`
|
|
|
|
"90ed234fb0708235a733bcae0e5b90bd4fac5321 branch of example.com:git-lfs/git-lfs",
|
|
|
|
}
|
|
|
|
for _, line := range invalid {
|
|
|
|
result, err := ExtractRemoteUrl(line)
|
|
|
|
assert.NotNil(t, err)
|
|
|
|
assert.Regexp(t, regexp.MustCompile("^failed to extract remote URL.*$"), err.Error())
|
|
|
|
assert.Equal(t, "", result)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|