fix: improve fake driver

so that Create() and Fork() return the clone URL and add some more tests

scm/driver/fake/fake.go

@@ -11,8 +11,8 @@ import (
 // scm operations have been performed
 func NewDefault() (*scm.Client, *Data) {
  data := NewData()
- data.CurrentUser.Login = "dummy"
- data.CurrentUser.Name = "dummy"
+ data.CurrentUser.Login = "fakeuser"
+ data.CurrentUser.Name = "fakeuser"
  data.ContentDir = "test_data"
 
  client := &wrapper{new(scm.Client)}
@@ -34,6 +34,7 @@ func NewDefault() (*scm.Client, *Data) {
  client.Reviews = &reviewService{client: client, data: data}
  client.Users = &userService{client: client, data: data}
 
+ client.Username = data.CurrentUser.Login
  // TODO
  /*
  client.Webhooks = &webhookService{client}

scm/driver/fake/repo.go

@@ -153,12 +153,18 @@ func (s *repositoryService) ListStatus(ctx context.Context, repo string, ref str
 
 func (s *repositoryService) Create(ctx context.Context, input *scm.RepositoryInput) (*scm.Repository, *scm.Response, error) {
  s.data.CreateRepositories = append(s.data.CreateRepositories, input)
- fullName := scm.Join(input.Namespace, input.Name)
+ namespace := input.Namespace
+ if namespace == "" {
+ namespace = s.client.Username
+ }
+ fullName := scm.Join(namespace, input.Name)
+ link := fmt.Sprintf("https://fake.com/%s.git", fullName)
  repo := &scm.Repository{
- Namespace: input.Namespace,
+ Namespace: namespace,
  Name: input.Name,
  FullName: fullName,
- Link: fmt.Sprintf("https://fake.com/%s.git", fullName),
+ Link: link,
+ Clone: link,
  Created: time.Now(),
  }
  s.data.Repositories = append(s.data.Repositories, repo)

scm/driver/fake/repo_test.go

@@ -1,16 +1,18 @@
-package fake
+package fake_test
 
 import (
  "context"
+ "github.com/jenkins-x/go-scm/scm/driver/fake"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
  "testing"
 
  "github.com/google/go-cmp/cmp"
  "github.com/jenkins-x/go-scm/scm"
 )
 
 func TestHookCreateDelete(t *testing.T) {
-
- client, _ := NewDefault()
+ client, _ := fake.NewDefault()
 
  in := &scm.HookInput{
  Target: "https://example.com",
@@ -58,3 +60,35 @@ func TestHookCreateDelete(t *testing.T) {
  t.Fatal("expect no hooks")
  }
 }
+
+func TestForkRepository(t *testing.T) {
+ client, _ := fake.NewDefault()
+
+ org := "jenkins-x"
+ repoName := "go-scm"
+ username := client.Username
+ expectedGitURL := "https://fake.com/" + username + "/" + repoName + ".git"
+ fullName := scm.Join(org, repoName)
+ forkFullName := scm.Join(username, repoName)
+
+ ctx := context.TODO()
+
+ fake.AssertNoRepoExists(t, ctx, client, fullName)
+ fake.AssertNoRepoExists(t, ctx, client, forkFullName)
+
+ repo, _, err := client.Repositories.Create(ctx, &scm.RepositoryInput{
+ Namespace: org,
+ Name: repoName,
+ })
+ require.NoError(t, err, "failed to create repo %s", fullName)
+ require.NotNil(t, repo, "no repo returned for create repo %s", fullName)
+
+ fake.AssertRepoExists(t, ctx, client, fullName)
+
+ repo, _, err = client.Repositories.Fork(ctx, &scm.RepositoryInput{
+ Name: repoName,
+ }, repoName)
+
+ repository := fake.AssertRepoExists(t, ctx, client, forkFullName)
+ assert.Equal(t, expectedGitURL, repository.Clone, "forked repository clone URL")
+}

scm/driver/fake/test_helpers.go

@@ -0,0 +1,35 @@
+package fake
+
+import (
+ "context"
+ "github.com/jenkins-x/go-scm/scm"
+ "github.com/stretchr/testify/require"
+ "testing"
+)
+
+// AssertRepoExists asserts that the repository exists
+func AssertRepoExists(t *testing.T, ctx context.Context, client *scm.Client, repo string) *scm.Repository {
+ require.NotEmpty(t, repo, "no repository name")
+ require.NotNil(t, client, "no scm client")
+ require.NotNil(t, client.Repositories, "scm client does not support Repositories")
+
+ repository, _, err := client.Repositories.Find(ctx, repo)
+
+ if err != nil && scm.IsScmNotFound(err) {
+ err = nil
+ }
+ require.NoError(t, err, "failed to find repo %s", repo)
+ require.NotNil(t, repository, "no repository returned for %s", repo)
+ return repository
+}
+
+// AssertNoRepoExists asserts that the repository does not exist
+func AssertNoRepoExists(t *testing.T, ctx context.Context, client *scm.Client, repo string) {
+ require.NotEmpty(t, repo, "no repository name")
+ require.NotNil(t, client, "no scm client")
+ require.NotNil(t, client.Repositories, "scm client does not support Repositories")
+
+ _, _, err := client.Repositories.Find(ctx, repo)
+ require.Error(t, err, "expected not found error when looking up repo %s", repo)
+ require.True(t, scm.IsScmNotFound(err), "should have returned an is not found error for repo %s", repo)
+}

scm/factory/examples/repo/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+ "context"
+ "fmt"
+ "github.com/jenkins-x/go-scm/scm"
+ "os"
+
+ "github.com/jenkins-x/go-scm/scm/factory"
+ "github.com/jenkins-x/go-scm/scm/factory/examples/helpers"
+)
+
+func main() {
+ args := os.Args
+ if len(args) == 1 {
+ fmt.Printf("usage: repoName")
+ return
+ }
+
+ client, err := factory.NewClientFromEnvironment()
+ if err != nil {
+ helpers.Fail(err)
+ return
+ }
+ ctx := context.Background()
+
+ name := args[1]
+ fmt.Printf("finding repository %s\n", name)
+
+ repo, _, err := client.Repositories.Find(ctx, name)
+ if scm.IsScmNotFound(err) {
+ fmt.Printf("not found\n")
+ return
+ }
+ if err != nil {
+ fmt.Printf("failed: %s\n", err.Error())
+ return
+ }
+ fmt.Printf("found %#v\n", repo)
+}

scm/util.go

@@ -89,3 +89,13 @@ func ConvertStatusInputToStatus(input *StatusInput) *Status {
  Target: input.Target,
  }
 }
+
+// IsScmNotFound returns true if the resource is not found
+func IsScmNotFound(err error) bool {
+ if err != nil {
+ // I think that we should instead rely on the http status (404)
+ // until jenkins-x go-scm is updated t return that in the error this works for github and gitlab
+ return strings.Contains(err.Error(), ErrNotFound.Error())
+ }
+ return false
+}