func TestEncodeExtensions(t *testing.T) { var buf bytes.Buffer exts := []*PointerExtension{ NewPointerExtension("foo", 0, "foo_oid"), NewPointerExtension("bar", 1, "bar_oid"), NewPointerExtension("baz", 2, "baz_oid"), } pointer := NewPointer("main_oid", 12345, exts) _, err := EncodePointer(&buf, pointer) assert.Equal(t, nil, err) bufReader := bufio.NewReader(&buf) assertLine(t, bufReader, "version https://git-lfs.github.com/spec/v1\n") assertLine(t, bufReader, "ext-0-foo sha256:foo_oid\n") assertLine(t, bufReader, "ext-1-bar sha256:bar_oid\n") assertLine(t, bufReader, "ext-2-baz sha256:baz_oid\n") assertLine(t, bufReader, "oid sha256:main_oid\n") assertLine(t, bufReader, "size 12345\n") line, err := bufReader.ReadString('\n') if err == nil { t.Fatalf("More to read: %s", line) } assert.Equal(t, "EOF", err.Error()) }
func TestCertFromSSLCAInfoEnv(t *testing.T) { tempfile, err := ioutil.TempFile("", "testcert") assert.Equal(t, nil, err, "Error creating temp cert file") defer os.Remove(tempfile.Name()) _, err = tempfile.WriteString(testCert) assert.Equal(t, nil, err, "Error writing temp cert file") tempfile.Close() oldEnv := Config.envVars defer func() { Config.envVars = oldEnv }() Config.envVars = map[string]string{"GIT_SSL_CAINFO": tempfile.Name()} // Should match any host at all pool := getRootCAsForHost("git-lfs.local") assert.NotEqual(t, (*x509.CertPool)(nil), pool) pool = getRootCAsForHost("wronghost.com") assert.NotEqual(t, (*x509.CertPool)(nil), pool) pool = getRootCAsForHost("notthisone.com:8888") assert.NotEqual(t, (*x509.CertPool)(nil), pool) }
func TestCertFromSSLCAPathEnv(t *testing.T) { tempdir, err := ioutil.TempDir("", "testcertdir") assert.Equal(t, nil, err, "Error creating temp cert dir") defer os.RemoveAll(tempdir) err = ioutil.WriteFile(filepath.Join(tempdir, "cert1.pem"), []byte(testCert), 0644) assert.Equal(t, nil, err, "Error creating cert file") oldEnv := Config.envVars defer func() { Config.envVars = oldEnv }() Config.envVars = map[string]string{"GIT_SSL_CAPATH": tempdir} // Should match any host at all pool := getRootCAsForHost("git-lfs.local") assert.NotEqual(t, (*x509.CertPool)(nil), pool) pool = getRootCAsForHost("wronghost.com") assert.NotEqual(t, (*x509.CertPool)(nil), pool) pool = getRootCAsForHost("notthisone.com:8888") assert.NotEqual(t, (*x509.CertPool)(nil), pool) }
func TestAccessAbsentConfig(t *testing.T) { config := &Configuration{} assert.Equal(t, "none", config.Access("download")) assert.Equal(t, "none", config.Access("upload")) assert.Equal(t, false, config.PrivateAccess("download")) assert.Equal(t, false, config.PrivateAccess("upload")) }
func TestCurrentRefAndCurrentRemoteRef(t *testing.T) { repo := test.NewRepo(t) repo.Pushd() defer func() { repo.Popd() repo.Cleanup() }() // test commits; we'll just modify the same file each time since we're // only interested in branches inputs := []*test.CommitInput{ { // 0 Files: []*test.FileInput{ {Filename: "file1.txt", Size: 20}, }, }, { // 1 NewBranch: "branch2", Files: []*test.FileInput{ {Filename: "file1.txt", Size: 25}, }, }, { // 2 ParentBranches: []string{"master"}, // back on master Files: []*test.FileInput{ {Filename: "file1.txt", Size: 30}, }, }, { // 3 NewBranch: "branch3", Files: []*test.FileInput{ {Filename: "file1.txt", Size: 32}, }, }, } outputs := repo.AddCommits(inputs) // last commit was on branch3 ref, err := CurrentRef() assert.Equal(t, nil, err) assert.Equal(t, &Ref{"branch3", RefTypeLocalBranch, outputs[3].Sha}, ref) test.RunGitCommand(t, true, "checkout", "master") ref, err = CurrentRef() assert.Equal(t, nil, err) assert.Equal(t, &Ref{"master", RefTypeLocalBranch, outputs[2].Sha}, ref) // Check remote repo.AddRemote("origin") test.RunGitCommand(t, true, "push", "-u", "origin", "master:someremotebranch") ref, err = CurrentRemoteRef() assert.Equal(t, nil, err) assert.Equal(t, &Ref{"origin/someremotebranch", RefTypeRemoteBranch, outputs[2].Sha}, ref) refname, err := RemoteRefNameForCurrentBranch() assert.Equal(t, nil, err) assert.Equal(t, "origin/someremotebranch", refname) remote, err := RemoteForCurrentBranch() assert.Equal(t, nil, err) assert.Equal(t, "origin", remote) }
func TestNtlmHeaderParseValid(t *testing.T) { res := http.Response{} res.Header = make(map[string][]string) res.Header.Add("Www-Authenticate", "NTLM "+base64.StdEncoding.EncodeToString([]byte("I am a moose"))) bytes, err := parseChallengeResponse(&res) assert.Equal(t, err, nil) assert.Equal(t, strings.HasPrefix(string(bytes), "NTLM"), false) }
func TestFetchPruneConfigDefault(t *testing.T) { config := &Configuration{} fp := config.FetchPruneConfig() assert.Equal(t, 7, fp.FetchRecentRefsDays) assert.Equal(t, 0, fp.FetchRecentCommitsDays) assert.Equal(t, 3, fp.PruneOffsetDays) assert.Equal(t, true, fp.FetchRecentRefsIncludeRemotes) }
func TestLoadInvalidExtension(t *testing.T) { config := &Configuration{} ext := config.Extensions()["foo"] assert.Equal(t, "", ext.Name) assert.Equal(t, "", ext.Clean) assert.Equal(t, "", ext.Smudge) assert.Equal(t, 0, ext.Priority) }
func TestWriterWithCallback(t *testing.T) { called := 0 calledRead := make([]int64, 0, 2) reader := &CallbackReader{ TotalSize: 5, Reader: bytes.NewBufferString("BOOYA"), C: func(total int64, read int64, current int) error { called += 1 calledRead = append(calledRead, read) assert.Equal(t, 5, int(total)) return nil }, } readBuf := make([]byte, 3) n, err := reader.Read(readBuf) assert.Equal(t, nil, err) assert.Equal(t, "BOO", string(readBuf[0:n])) n, err = reader.Read(readBuf) assert.Equal(t, nil, err) assert.Equal(t, "YA", string(readBuf[0:n])) assert.Equal(t, 2, called) assert.Equal(t, 2, len(calledRead)) assert.Equal(t, 3, int(calledRead[0])) assert.Equal(t, 5, int(calledRead[1])) }
func TestSSHGetExeAndArgsSsh(t *testing.T) { endpoint := Config.Endpoint("download") endpoint.SshUserAndHost = "*****@*****.**" oldGITSSH := Config.Getenv("GIT_SSH") Config.Setenv("GIT_SSH", "") exe, args := sshGetExeAndArgs(endpoint) assert.Equal(t, "ssh", exe) assert.Equal(t, []string{"*****@*****.**"}, args) Config.Setenv("GIT_SSH", oldGITSSH) }
func TestBareEndpointAddsLfsSuffix(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{"remote.origin.url": "https://example.com/foo/bar.git"}, remotes: []string{}, } endpoint := config.Endpoint() assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", endpoint.Url) assert.Equal(t, "", endpoint.SshUserAndHost) assert.Equal(t, "", endpoint.SshPath) }
func TestEncodeEmpty(t *testing.T) { var buf bytes.Buffer pointer := NewPointer("", 0, nil) _, err := EncodePointer(&buf, pointer) assert.Equal(t, nil, err) bufReader := bufio.NewReader(&buf) val, err := bufReader.ReadString('\n') assert.Equal(t, "", val) assert.Equal(t, "EOF", err.Error()) }
func TestEndpointDefaultsToOrigin(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{"remote.origin.lfsurl": "abc"}, remotes: []string{}, } endpoint := config.Endpoint() assert.Equal(t, "abc", endpoint.Url) assert.Equal(t, "", endpoint.SshUserAndHost) assert.Equal(t, "", endpoint.SshPath) }
func TestNtlmCloneRequest(t *testing.T) { req1, _ := http.NewRequest("Method", "url", nil) cloneOfReq1, err := cloneRequest(req1) assert.Equal(t, err, nil) assertRequestsEqual(t, req1, cloneOfReq1) req2, _ := http.NewRequest("Method", "url", bytes.NewReader([]byte("Moose can be request bodies"))) cloneOfReq2, err := cloneRequest(req2) assert.Equal(t, err, nil) assertRequestsEqual(t, req2, cloneOfReq2) }
func TestCertVerifyDisabledGlobalEnv(t *testing.T) { assert.Equal(t, false, isCertVerificationDisabledForHost("anyhost.com")) oldEnv := Config.envVars defer func() { Config.envVars = oldEnv }() Config.envVars = map[string]string{"GIT_SSL_NO_VERIFY": "1"} assert.Equal(t, true, isCertVerificationDisabledForHost("anyhost.com")) }
func TestCertVerifyDisabledGlobalConfig(t *testing.T) { assert.Equal(t, false, isCertVerificationDisabledForHost("anyhost.com")) oldGitConfig := Config.gitConfig defer func() { Config.gitConfig = oldGitConfig }() Config.gitConfig = map[string]string{"http.sslverify": "false"} assert.Equal(t, true, isCertVerificationDisabledForHost("anyhost.com")) }
func TestSSHCustomPortEndpointAddsLfsSuffix(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{"remote.origin.url": "ssh://[email protected]:9000/foo/bar"}, remotes: []string{}, } endpoint := config.Endpoint() assert.Equal(t, "https://example.com/foo/bar.git/info/lfs", endpoint.Url) assert.Equal(t, "*****@*****.**", endpoint.SshUserAndHost) assert.Equal(t, "foo/bar", endpoint.SshPath) assert.Equal(t, "9000", endpoint.SshPort) }
func TestSSHEndpointFromGlobalLfsUrl(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{"lfs.url": "[email protected]:foo/bar.git"}, remotes: []string{}, } endpoint := config.Endpoint() assert.Equal(t, "https://example.com/foo/bar.git", endpoint.Url) assert.Equal(t, "*****@*****.**", endpoint.SshUserAndHost) assert.Equal(t, "foo/bar.git", endpoint.SshPath) assert.Equal(t, "", endpoint.SshPort) }
func TestSSHGetExeAndArgsSshCustomPort(t *testing.T) { endpoint := Config.Endpoint() endpoint.SshUserAndHost = "*****@*****.**" endpoint.SshPort = "8888" oldGITSSH := Config.Getenv("GIT_SSH") Config.Setenv("GIT_SSH", "") exe, args := sshGetExeAndArgs(endpoint) assert.Equal(t, "ssh", exe) assert.Equal(t, []string{"-p", "8888", "*****@*****.**"}, args) Config.Setenv("GIT_SSH", oldGITSSH) }
func TestFilterIncludeExclude(t *testing.T) { cases := []TestIncludeExcludeCase{ // Null case TestIncludeExcludeCase{true, nil, nil}, // Inclusion TestIncludeExcludeCase{true, []string{"test/filename.dat"}, nil}, TestIncludeExcludeCase{true, []string{"test/filename.dat"}, nil}, TestIncludeExcludeCase{false, []string{"blank", "something", "foo"}, nil}, TestIncludeExcludeCase{false, []string{"test/notfilename.dat"}, nil}, TestIncludeExcludeCase{true, []string{"test"}, nil}, TestIncludeExcludeCase{true, []string{"test/*"}, nil}, TestIncludeExcludeCase{false, []string{"nottest"}, nil}, TestIncludeExcludeCase{false, []string{"nottest/*"}, nil}, TestIncludeExcludeCase{true, []string{"test/fil*"}, nil}, TestIncludeExcludeCase{false, []string{"test/g*"}, nil}, TestIncludeExcludeCase{true, []string{"tes*/*"}, nil}, // Exclusion TestIncludeExcludeCase{false, nil, []string{"test/filename.dat"}}, TestIncludeExcludeCase{false, nil, []string{"blank", "something", "test/filename.dat", "foo"}}, TestIncludeExcludeCase{true, nil, []string{"blank", "something", "foo"}}, TestIncludeExcludeCase{true, nil, []string{"test/notfilename.dat"}}, TestIncludeExcludeCase{false, nil, []string{"test"}}, TestIncludeExcludeCase{false, nil, []string{"test/*"}}, TestIncludeExcludeCase{true, nil, []string{"nottest"}}, TestIncludeExcludeCase{true, nil, []string{"nottest/*"}}, TestIncludeExcludeCase{false, nil, []string{"test/fil*"}}, TestIncludeExcludeCase{true, nil, []string{"test/g*"}}, TestIncludeExcludeCase{false, nil, []string{"tes*/*"}}, // Both TestIncludeExcludeCase{true, []string{"test/filename.dat"}, []string{"test/notfilename.dat"}}, TestIncludeExcludeCase{false, []string{"test"}, []string{"test/filename.dat"}}, TestIncludeExcludeCase{true, []string{"test/*"}, []string{"test/notfile*"}}, TestIncludeExcludeCase{false, []string{"test/*"}, []string{"test/file*"}}, TestIncludeExcludeCase{false, []string{"another/*", "test/*"}, []string{"test/notfilename.dat", "test/filename.dat"}}, } for _, c := range cases { assert.Equal(t, c.expectedResult, FilenamePassesIncludeExcludeFilter("test/filename.dat", c.includes, c.excludes), c) if IsWindows() { // also test with \ path separators, tolerate mixed separators for i, inc := range c.includes { c.includes[i] = strings.Replace(inc, "/", "\\", -1) } for i, ex := range c.excludes { c.excludes[i] = strings.Replace(ex, "/", "\\", -1) } assert.Equal(t, c.expectedResult, FilenamePassesIncludeExcludeFilter("test/filename.dat", c.includes, c.excludes), c) } } }
func TestBatcherSizeMet(t *testing.T) { b := NewBatcher(2) for i := 0; i < 4; i++ { b.Add(&Downloadable{}) } group := b.Next() assert.Equal(t, 2, len(group)) group = b.Next() assert.Equal(t, 2, len(group)) }
func TestSSHGetExeAndArgsTortoisePlink(t *testing.T) { endpoint := Config.Endpoint("download") endpoint.SshUserAndHost = "*****@*****.**" oldGITSSH := Config.Getenv("GIT_SSH") // this will run on non-Windows platforms too but no biggie plink := filepath.Join("Users", "joebloggs", "bin", "tortoiseplink.exe") Config.Setenv("GIT_SSH", plink) exe, args := sshGetExeAndArgs(endpoint) assert.Equal(t, plink, exe) assert.Equal(t, []string{"-batch", "*****@*****.**"}, args) Config.Setenv("GIT_SSH", oldGITSSH) }
func TestCertVerifyDisabledHostConfig(t *testing.T) { assert.Equal(t, false, isCertVerificationDisabledForHost("specifichost.com")) assert.Equal(t, false, isCertVerificationDisabledForHost("otherhost.com")) oldGitConfig := Config.gitConfig defer func() { Config.gitConfig = oldGitConfig }() Config.gitConfig = map[string]string{"http.https://specifichost.com/.sslverify": "false"} assert.Equal(t, true, isCertVerificationDisabledForHost("specifichost.com")) assert.Equal(t, false, isCertVerificationDisabledForHost("otherhost.com")) }
func TestEndpointNoOverrideDefaultRemote(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{ "remote.origin.lfsurl": "abc", "remote.other.lfsurl": "def", }, remotes: []string{}, } endpoint := config.Endpoint() assert.Equal(t, "abc", endpoint.Url) assert.Equal(t, "", endpoint.SshUserAndHost) assert.Equal(t, "", endpoint.SshPath) }
func TestSSHGetExeAndArgsPlinkCustomPort(t *testing.T) { endpoint := Config.Endpoint() endpoint.SshUserAndHost = "*****@*****.**" endpoint.SshPort = "8888" oldGITSSH := Config.Getenv("GIT_SSH") // this will run on non-Windows platforms too but no biggie plink := filepath.Join("Users", "joebloggs", "bin", "plink") Config.Setenv("GIT_SSH", plink) exe, args := sshGetExeAndArgs(endpoint) assert.Equal(t, plink, exe) assert.Equal(t, []string{"-P", "8888", "*****@*****.**"}, args) Config.Setenv("GIT_SSH", oldGITSSH) }
func TestEndpointOverridesOrigin(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{ "lfs.url": "abc", "remote.origin.lfsurl": "def", }, remotes: []string{}, } endpoint := config.Endpoint("download") assert.Equal(t, "abc", endpoint.Url) assert.Equal(t, "", endpoint.SshUserAndHost) assert.Equal(t, "", endpoint.SshPath) }
func TestSSHEndpointOverridden(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{ "remote.origin.url": "[email protected]:foo/bar", "remote.origin.lfsurl": "lfs", }, remotes: []string{}, } endpoint := config.Endpoint() assert.Equal(t, "lfs", endpoint.Url) assert.Equal(t, "", endpoint.SshUserAndHost) assert.Equal(t, "", endpoint.SshPath) }
func TestGitEndpointAddsLfsSuffixWithCustomProtocol(t *testing.T) { config := &Configuration{ gitConfig: map[string]string{ "remote.origin.url": "git://example.com/foo/bar", "lfs.gitprotocol": "http", }, remotes: []string{}, } endpoint := config.Endpoint("download") assert.Equal(t, "http://example.com/foo/bar.git/info/lfs", endpoint.Url) assert.Equal(t, "", endpoint.SshUserAndHost) assert.Equal(t, "", endpoint.SshPath) assert.Equal(t, "", endpoint.SshPort) }
func assertRequestsEqual(t *testing.T, req1 *http.Request, req2 *http.Request) { assert.Equal(t, req1.Method, req2.Method) for k, v := range req1.Header { assert.Equal(t, v, req2.Header[k]) } if req1.Body == nil { assert.Equal(t, req2.Body, nil) } else { bytes1, _ := ioutil.ReadAll(req1.Body) bytes2, _ := ioutil.ReadAll(req2.Body) assert.Equal(t, bytes.Compare(bytes1, bytes2), 0) } }
func TestVersionCompare(t *testing.T) { assert.Equal(t, true, IsVersionAtLeast("2.6.0", "2.6.0")) assert.Equal(t, true, IsVersionAtLeast("2.6.0", "2.6")) assert.Equal(t, true, IsVersionAtLeast("2.6.0", "2")) assert.Equal(t, true, IsVersionAtLeast("2.6.10", "2.6.5")) assert.Equal(t, true, IsVersionAtLeast("2.8.1", "2.7.2")) assert.Equal(t, false, IsVersionAtLeast("1.6.0", "2")) assert.Equal(t, false, IsVersionAtLeast("2.5.0", "2.6")) assert.Equal(t, false, IsVersionAtLeast("2.5.0", "2.5.1")) assert.Equal(t, false, IsVersionAtLeast("2.5.2", "2.5.10")) }