func TestIsValidGitRepository(t *testing.T) {
d := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(d)
// We have a .git that is populated
// Should return true with no error
ok, err := isValidGitRepository(d)
if !ok {
t.Errorf("The %q directory is git repository", d)
}
if err != nil {
t.Errorf("isValidGitRepository returned an unexpected error: %q", err.Error())
}
d = test.CreateEmptyLocalGitDirectory(t)
defer os.RemoveAll(d)
// There are no tracking objects in the .git repository
// Should return true with an EmptyGitRepositoryError
ok, err = isValidGitRepository(d)
if !ok {
t.Errorf("The %q directory is a git repository, but is empty", d)
}
if err != nil {
if e, ok := err.(errors.Error); !ok || e.ErrorCode != errors.EmptyGitRepositoryError {
t.Errorf("isValidGitRepository returned an unexpected error: %q, expecting EmptyGitRepositoryError", err.Error())
}
} else {
t.Errorf("isValidGitRepository returned no error, expecting EmptyGitRepositoryError")
}
d = filepath.Join(d, ".git")
// There is no .git in the provided directory
// Should return false with no error
if ok, err = isValidGitRepository(d); ok {
t.Errorf("The %q directory is not git repository", d)
}
if err != nil {
t.Errorf("isValidGitRepository returned an unexpected error: %q", err.Error())
}
d = test.CreateLocalGitDirectoryWithSubmodule(t)
defer os.RemoveAll(d)
ok, err = isValidGitRepository(filepath.Join(d, "submodule"))
if !ok || err != nil {
t.Errorf("Expected isValidGitRepository to return true, nil on submodule; got %v, %v", ok, err)
}
}
func TestDownloaderForceCopy(t *testing.T) {
gitLocalDir := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(gitLocalDir)
os.Chdir(gitLocalDir)
r, s, err := DownloaderForSource(".", true)
if err != nil {
t.Errorf("Unexpected error %q for %q, expected %q", err, ".", "*file.File")
}
if !strings.HasPrefix(s, "file://") {
t.Errorf("Expected source to have 'file://' prefix, it is %q", s)
}
if reflect.TypeOf(r).String() != "*file.File" {
t.Errorf("Expected %q for %q, got %q", "*file.File", ".", reflect.TypeOf(r).String())
}
}
func TestValidCloneSpec(t *testing.T) {
gitLocalDir := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(gitLocalDir)
valid := []string{"[email protected]:user/repo.git",
"git://github.com/user/repo.git",
"git://github.com/user/repo",
"http://github.com/user/repo.git",
"http://github.com/user/repo",
"https://github.com/user/repo.git",
"https://github.com/user/repo",
"file://" + gitLocalDir,
"file://" + gitLocalDir + "#master",
gitLocalDir,
gitLocalDir + "#master",
"[email protected]:repositories/authooks",
"[email protected]:/var/git/eap-ulx.git",
"ssh://git@[2001:db8::1]/repository.git",
"ssh://[email protected]:8080/foo/bar",
"git@[2001:db8::1]:repository.git",
"git@[2001:db8::1]:/repository.git",
"[email protected]:foo/bar",
"[email protected]:foo/bar",
"[email protected]:foo/bar",
"github.com:openshift/origin.git",
"http://github.com/user/repo#1234",
}
invalid := []string{"g&[email protected]:foo.bar",
"[email protected]/repo.git",
"some/lo:cal/path", // a local path that does not exist, but "some/lo" is not a valid host name
"http://github.com/user/repo#%%%%",
}
gh := New()
for _, scenario := range valid {
result, _ := gh.ValidCloneSpec(scenario)
if result == false {
t.Error(scenario)
}
}
for _, scenario := range invalid {
result, _ := gh.ValidCloneSpec(scenario)
if result {
t.Error(scenario)
}
}
}
func TestDownloaderForSource(t *testing.T) {
gitLocalDir := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(gitLocalDir)
localDir, _ := ioutil.TempDir(os.TempDir(), "localdir-s2i-test")
defer os.RemoveAll(localDir)
tc := map[string]string{
// Valid Git clone specs
"git://github.com/bar": "git.Clone",
"https://github.com/bar": "git.Clone",
"[email protected]:foo/bar.git": "git.Clone",
// Non-existing local path (it is not git repository, so it is file
// download)
"file://foo/bar": "error",
"/foo/bar": "error",
// Local directory with valid Git repository
gitLocalDir: "git.Clone",
"file://" + gitLocalDir: "git.Clone",
// Local directory that exists but it is not Git repository
localDir: "file.File",
"file://" + localDir: "file.File",
"foo://github.com/bar": "error",
"./foo": "error",
// Empty source string
"": "empty.Noop",
}
for s, expected := range tc {
r, filePathUpdate, err := DownloaderForSource(s, false)
if err != nil {
if expected != "error" {
t.Errorf("Unexpected error %q for %q, expected %q", err, s, expected)
}
continue
}
if s == gitLocalDir || s == localDir {
if !strings.HasPrefix(filePathUpdate, "file://") {
t.Errorf("input %s should have produced a file path update starting with file:// but produced: %s", s, filePathUpdate)
}
}
expected = "*" + expected
if reflect.TypeOf(r).String() != expected {
t.Errorf("Expected %q for %q, got %q", expected, s, reflect.TypeOf(r).String())
}
}
}
func TestMungeNoProtocolURL(t *testing.T) {
gitLocalDir := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(gitLocalDir)
gh := New()
tests := map[string]url.URL{
"[email protected]:user/repo.git": {
Scheme: "ssh",
Host: "github.com",
User: url.User("git"),
Path: "user/repo.git",
},
"git://github.com/user/repo.git": {
Scheme: "git",
Host: "github.com",
Path: "/user/repo.git",
},
"git://github.com/user/repo": {
Scheme: "git",
Host: "github.com",
Path: "/user/repo",
},
"http://github.com/user/repo.git": {
Scheme: "http",
Host: "github.com",
Path: "/user/repo.git",
},
"http://github.com/user/repo": {
Scheme: "http",
Host: "github.com",
Path: "/user/repo",
},
"https://github.com/user/repo.git": {
Scheme: "https",
Host: "github.com",
Path: "/user/repo.git",
},
"https://github.com/user/repo": {
Scheme: "https",
Host: "github.com",
Path: "/user/repo",
},
"file://" + gitLocalDir: {
Scheme: "file",
Path: gitLocalDir,
},
gitLocalDir: {
Scheme: "file",
Path: gitLocalDir,
},
"[email protected]:repositories/authooks": {
Scheme: "ssh",
Host: "192.168.122.1",
User: url.User("git"),
Path: "repositories/authooks",
},
"[email protected]:/var/git/eap-ulx.git": {
Scheme: "ssh",
Host: "build.ulx.hu",
User: url.User("mbalazs"),
Path: "/var/git/eap-ulx.git",
},
"ssh://git@[2001:db8::1]/repository.git": {
Scheme: "ssh",
Host: "[2001:db8::1]",
User: url.User("git"),
Path: "/repository.git",
},
"ssh://[email protected]:8080/foo/bar": {
Scheme: "ssh",
Host: "mydomain.com:8080",
User: url.User("git"),
Path: "/foo/bar",
},
"git@[2001:db8::1]:repository.git": {
Scheme: "ssh",
Host: "[2001:db8::1]",
User: url.User("git"),
Path: "repository.git",
},
"git@[2001:db8::1]:/repository.git": {
Scheme: "ssh",
Host: "[2001:db8::1]",
User: url.User("git"),
Path: "/repository.git",
},
}
for scenario, test := range tests {
uri, err := url.Parse(scenario)
if err != nil {
t.Errorf("Could not parse url %q", scenario)
}
err = gh.MungeNoProtocolURL(scenario, uri)
if err != nil {
t.Errorf("MungeNoProtocolURL returned err: %v", err)
}
// reflect.DeepEqual was not dealing with url.URL correctly, have to check each field individually
// First, the easy string compares
equal := uri.Scheme == test.Scheme && uri.Opaque == test.Opaque && uri.Host == test.Host && uri.Path == test.Path && uri.RawQuery == test.RawQuery && uri.Fragment == test.Fragment
if equal {
// now deal with User, a Userinfo struct ptr
if uri.User == nil && test.User != nil {
equal = false
} else if uri.User != nil && test.User == nil {
equal = false
} else if uri.User != nil && test.User != nil {
equal = uri.User.String() == test.User.String()
}
}
if !equal {
t.Errorf(`URL string %q, field by field check:
- Scheme: got %v, ok? %v
- Opaque: got %v, ok? %v
- Host: got %v, ok? %v
- Path: got %v, ok? %v
- RawQuery: got %v, ok? %v
- Fragment: got %v, ok? %v
- User: got %v`,
scenario,
uri.Scheme, uri.Scheme == test.Scheme,
uri.Opaque, uri.Opaque == test.Opaque,
uri.Host, uri.Host == test.Host,
uri.Path, uri.Path == test.Path,
uri.RawQuery, uri.RawQuery == test.RawQuery,
uri.Fragment, uri.Fragment == test.Fragment,
uri.User)
}
}
}
func TestEnsureHasSource(t *testing.T) {
gitLocalDir := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(gitLocalDir)
tests := []struct {
name string
cfg AppConfig
components app.ComponentReferences
repositories []*app.SourceRepository
expectedErr string
dontExpectToBuild bool
}{
{
name: "One requiresSource, multiple repositories",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: true,
}),
},
repositories: mockSourceRepositories(t, gitLocalDir),
expectedErr: "there are multiple code locations provided - use one of the following suggestions",
},
{
name: "Multiple requiresSource, multiple repositories",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: true,
}),
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: true,
}),
},
repositories: mockSourceRepositories(t, gitLocalDir),
expectedErr: "Use '[image]~[repo]' to declare which code goes with which image",
},
{
name: "One requiresSource, no repositories",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: true,
}),
},
repositories: []*app.SourceRepository{},
expectedErr: "",
dontExpectToBuild: true,
},
{
name: "Multiple requiresSource, no repositories",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: true,
}),
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: true,
}),
},
repositories: []*app.SourceRepository{},
expectedErr: "",
dontExpectToBuild: true,
},
{
name: "Successful - one repository",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: false,
}),
},
repositories: mockSourceRepositories(t, gitLocalDir)[:1],
expectedErr: "",
},
{
name: "Successful - no requiresSource",
components: app.ComponentReferences{
app.ComponentReference(&app.ComponentInput{
ExpectToBuild: false,
}),
},
repositories: mockSourceRepositories(t, gitLocalDir),
expectedErr: "",
},
}
for _, test := range tests {
err := EnsureHasSource(test.components, test.repositories, &test.cfg.GenerationInputs)
if err != nil {
if !strings.Contains(err.Error(), test.expectedErr) {
t.Errorf("%s: Invalid error: Expected %s, got %v", test.name, test.expectedErr, err)
}
} else if len(test.expectedErr) != 0 {
t.Errorf("%s: Expected %s error but got none", test.name, test.expectedErr)
}
if test.dontExpectToBuild {
for _, comp := range test.components {
if comp.NeedsSource() {
t.Errorf("%s: expected component reference to not require source.", test.name)
}
}
}
}
}
func TestParseRepository(t *testing.T) {
gitLocalDir := test.CreateLocalGitDirectory(t)
defer os.RemoveAll(gitLocalDir)
tests := map[string]url.URL{
"[email protected]:user/repo.git": {
Scheme: "ssh",
Host: "github.com",
User: url.User("git"),
Path: "user/repo.git",
},
"git://github.com/user/repo.git": {
Scheme: "git",
Host: "github.com",
Path: "/user/repo.git",
},
"git://github.com/user/repo": {
Scheme: "git",
Host: "github.com",
Path: "/user/repo",
},
"http://github.com/user/repo.git": {
Scheme: "http",
Host: "github.com",
Path: "/user/repo.git",
},
"http://github.com/user/repo": {
Scheme: "http",
Host: "github.com",
Path: "/user/repo",
},
"https://github.com/user/repo.git": {
Scheme: "https",
Host: "github.com",
Path: "/user/repo.git",
},
"https://github.com/user/repo": {
Scheme: "https",
Host: "github.com",
Path: "/user/repo",
},
"file://" + gitLocalDir: {
Scheme: "file",
Path: gitLocalDir,
},
gitLocalDir: {
Scheme: "file",
Path: gitLocalDir,
},
"[email protected]:repositories/authooks": {
Scheme: "ssh",
Host: "192.168.122.1",
User: url.User("git"),
Path: "repositories/authooks",
},
"[email protected]:/var/git/eap-ulx.git": {
Scheme: "ssh",
Host: "build.ulx.hu",
User: url.User("mbalazs"),
Path: "/var/git/eap-ulx.git",
},
"ssh://git@[2001:db8::1]/repository.git": {
Scheme: "ssh",
Host: "[2001:db8::1]",
User: url.User("git"),
Path: "/repository.git",
},
"ssh://[email protected]:8080/foo/bar": {
Scheme: "ssh",
Host: "mydomain.com:8080",
User: url.User("git"),
Path: "/foo/bar",
},
"git@[2001:db8::1]:repository.git": {
Scheme: "ssh",
Host: "[2001:db8::1]",
User: url.User("git"),
Path: "repository.git",
},
"git@[2001:db8::1]:/repository.git": {
Scheme: "ssh",
Host: "[2001:db8::1]",
User: url.User("git"),
Path: "/repository.git",
},
}
for scenario, want := range tests {
got, err := ParseRepository(scenario)
if err != nil {
t.Errorf("ParseRepository returned err: %v", err)
}
// go1.5 added the RawPath field to url.URL; it is not a field we need to manipulate with the
// ParseRepository path, but it impacts the values set in our test results array and doing a
// DeepEqual compare; hence, we have reverted back to a field by field compare (which
// this test originally did)
if got.Scheme != want.Scheme ||
got.Host != want.Host ||
got.Path != want.Path ||
(got.User != nil && want.User != nil && got.User.Username() != want.User.Username()) ||
(got.User == nil && want.User != nil) ||
(got.User != nil && want.User == nil) {
t.Errorf("%s: got %#v, want %#v", scenario, *got, want)
}
}
}