code.gitea.io/gitea@v1.22.3/models/repo/repo_test.go (about)

     1  // Copyright 2017 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package repo_test
     5  
     6  import (
     7  	"testing"
     8  
     9  	"code.gitea.io/gitea/models/db"
    10  	repo_model "code.gitea.io/gitea/models/repo"
    11  	"code.gitea.io/gitea/models/unit"
    12  	"code.gitea.io/gitea/models/unittest"
    13  	user_model "code.gitea.io/gitea/models/user"
    14  	"code.gitea.io/gitea/modules/markup"
    15  	"code.gitea.io/gitea/modules/optional"
    16  	"code.gitea.io/gitea/modules/setting"
    17  	"code.gitea.io/gitea/modules/test"
    18  
    19  	"github.com/stretchr/testify/assert"
    20  )
    21  
    22  var (
    23  	countRepospts        = repo_model.CountRepositoryOptions{OwnerID: 10}
    24  	countReposptsPublic  = repo_model.CountRepositoryOptions{OwnerID: 10, Private: optional.Some(false)}
    25  	countReposptsPrivate = repo_model.CountRepositoryOptions{OwnerID: 10, Private: optional.Some(true)}
    26  )
    27  
    28  func TestGetRepositoryCount(t *testing.T) {
    29  	assert.NoError(t, unittest.PrepareTestDatabase())
    30  
    31  	ctx := db.DefaultContext
    32  	count, err1 := repo_model.CountRepositories(ctx, countRepospts)
    33  	privateCount, err2 := repo_model.CountRepositories(ctx, countReposptsPrivate)
    34  	publicCount, err3 := repo_model.CountRepositories(ctx, countReposptsPublic)
    35  	assert.NoError(t, err1)
    36  	assert.NoError(t, err2)
    37  	assert.NoError(t, err3)
    38  	assert.Equal(t, int64(3), count)
    39  	assert.Equal(t, privateCount+publicCount, count)
    40  }
    41  
    42  func TestGetPublicRepositoryCount(t *testing.T) {
    43  	assert.NoError(t, unittest.PrepareTestDatabase())
    44  
    45  	count, err := repo_model.CountRepositories(db.DefaultContext, countReposptsPublic)
    46  	assert.NoError(t, err)
    47  	assert.Equal(t, int64(1), count)
    48  }
    49  
    50  func TestGetPrivateRepositoryCount(t *testing.T) {
    51  	assert.NoError(t, unittest.PrepareTestDatabase())
    52  
    53  	count, err := repo_model.CountRepositories(db.DefaultContext, countReposptsPrivate)
    54  	assert.NoError(t, err)
    55  	assert.Equal(t, int64(2), count)
    56  }
    57  
    58  func TestRepoAPIURL(t *testing.T) {
    59  	assert.NoError(t, unittest.PrepareTestDatabase())
    60  	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 10})
    61  
    62  	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user12/repo10", repo.APIURL())
    63  }
    64  
    65  func TestWatchRepo(t *testing.T) {
    66  	assert.NoError(t, unittest.PrepareTestDatabase())
    67  
    68  	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
    69  	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
    70  
    71  	assert.NoError(t, repo_model.WatchRepo(db.DefaultContext, user, repo, true))
    72  	unittest.AssertExistsAndLoadBean(t, &repo_model.Watch{RepoID: repo.ID, UserID: user.ID})
    73  	unittest.CheckConsistencyFor(t, &repo_model.Repository{ID: repo.ID})
    74  
    75  	assert.NoError(t, repo_model.WatchRepo(db.DefaultContext, user, repo, false))
    76  	unittest.AssertNotExistsBean(t, &repo_model.Watch{RepoID: repo.ID, UserID: user.ID})
    77  	unittest.CheckConsistencyFor(t, &repo_model.Repository{ID: repo.ID})
    78  }
    79  
    80  func TestMetas(t *testing.T) {
    81  	assert.NoError(t, unittest.PrepareTestDatabase())
    82  
    83  	repo := &repo_model.Repository{Name: "testRepo"}
    84  	repo.Owner = &user_model.User{Name: "testOwner"}
    85  	repo.OwnerName = repo.Owner.Name
    86  
    87  	repo.Units = nil
    88  
    89  	metas := repo.ComposeMetas(db.DefaultContext)
    90  	assert.Equal(t, "testRepo", metas["repo"])
    91  	assert.Equal(t, "testOwner", metas["user"])
    92  
    93  	externalTracker := repo_model.RepoUnit{
    94  		Type: unit.TypeExternalTracker,
    95  		Config: &repo_model.ExternalTrackerConfig{
    96  			ExternalTrackerFormat: "https://someurl.com/{user}/{repo}/{issue}",
    97  		},
    98  	}
    99  
   100  	testSuccess := func(expectedStyle string) {
   101  		repo.Units = []*repo_model.RepoUnit{&externalTracker}
   102  		repo.RenderingMetas = nil
   103  		metas := repo.ComposeMetas(db.DefaultContext)
   104  		assert.Equal(t, expectedStyle, metas["style"])
   105  		assert.Equal(t, "testRepo", metas["repo"])
   106  		assert.Equal(t, "testOwner", metas["user"])
   107  		assert.Equal(t, "https://someurl.com/{user}/{repo}/{issue}", metas["format"])
   108  	}
   109  
   110  	testSuccess(markup.IssueNameStyleNumeric)
   111  
   112  	externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = markup.IssueNameStyleAlphanumeric
   113  	testSuccess(markup.IssueNameStyleAlphanumeric)
   114  
   115  	externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = markup.IssueNameStyleNumeric
   116  	testSuccess(markup.IssueNameStyleNumeric)
   117  
   118  	externalTracker.ExternalTrackerConfig().ExternalTrackerStyle = markup.IssueNameStyleRegexp
   119  	testSuccess(markup.IssueNameStyleRegexp)
   120  
   121  	repo, err := repo_model.GetRepositoryByID(db.DefaultContext, 3)
   122  	assert.NoError(t, err)
   123  
   124  	metas = repo.ComposeMetas(db.DefaultContext)
   125  	assert.Contains(t, metas, "org")
   126  	assert.Contains(t, metas, "teams")
   127  	assert.Equal(t, "org3", metas["org"])
   128  	assert.Equal(t, ",owners,team1,", metas["teams"])
   129  }
   130  
   131  func TestGetRepositoryByURL(t *testing.T) {
   132  	assert.NoError(t, unittest.PrepareTestDatabase())
   133  
   134  	t.Run("InvalidPath", func(t *testing.T) {
   135  		repo, err := repo_model.GetRepositoryByURL(db.DefaultContext, "something")
   136  
   137  		assert.Nil(t, repo)
   138  		assert.Error(t, err)
   139  	})
   140  
   141  	t.Run("ValidHttpURL", func(t *testing.T) {
   142  		test := func(t *testing.T, url string) {
   143  			repo, err := repo_model.GetRepositoryByURL(db.DefaultContext, url)
   144  
   145  			assert.NotNil(t, repo)
   146  			assert.NoError(t, err)
   147  
   148  			assert.Equal(t, repo.ID, int64(2))
   149  			assert.Equal(t, repo.OwnerID, int64(2))
   150  		}
   151  
   152  		test(t, "https://try.gitea.io/user2/repo2")
   153  		test(t, "https://try.gitea.io/user2/repo2.git")
   154  	})
   155  
   156  	t.Run("ValidGitSshURL", func(t *testing.T) {
   157  		test := func(t *testing.T, url string) {
   158  			repo, err := repo_model.GetRepositoryByURL(db.DefaultContext, url)
   159  
   160  			assert.NotNil(t, repo)
   161  			assert.NoError(t, err)
   162  
   163  			assert.Equal(t, repo.ID, int64(2))
   164  			assert.Equal(t, repo.OwnerID, int64(2))
   165  		}
   166  
   167  		test(t, "git+ssh://sshuser@try.gitea.io/user2/repo2")
   168  		test(t, "git+ssh://sshuser@try.gitea.io/user2/repo2.git")
   169  
   170  		test(t, "git+ssh://try.gitea.io/user2/repo2")
   171  		test(t, "git+ssh://try.gitea.io/user2/repo2.git")
   172  	})
   173  
   174  	t.Run("ValidImplicitSshURL", func(t *testing.T) {
   175  		test := func(t *testing.T, url string) {
   176  			repo, err := repo_model.GetRepositoryByURL(db.DefaultContext, url)
   177  
   178  			assert.NotNil(t, repo)
   179  			assert.NoError(t, err)
   180  
   181  			assert.Equal(t, repo.ID, int64(2))
   182  			assert.Equal(t, repo.OwnerID, int64(2))
   183  		}
   184  
   185  		test(t, "sshuser@try.gitea.io:user2/repo2")
   186  		test(t, "sshuser@try.gitea.io:user2/repo2.git")
   187  
   188  		test(t, "try.gitea.io:user2/repo2")
   189  		test(t, "try.gitea.io:user2/repo2.git")
   190  	})
   191  }
   192  
   193  func TestComposeSSHCloneURL(t *testing.T) {
   194  	defer test.MockVariableValue(&setting.SSH, setting.SSH)()
   195  	defer test.MockVariableValue(&setting.Repository, setting.Repository)()
   196  
   197  	setting.SSH.User = "git"
   198  
   199  	// test SSH_DOMAIN
   200  	setting.SSH.Domain = "domain"
   201  	setting.SSH.Port = 22
   202  	setting.Repository.UseCompatSSHURI = false
   203  	assert.Equal(t, "git@domain:user/repo.git", repo_model.ComposeSSHCloneURL("user", "repo"))
   204  	setting.Repository.UseCompatSSHURI = true
   205  	assert.Equal(t, "ssh://git@domain/user/repo.git", repo_model.ComposeSSHCloneURL("user", "repo"))
   206  	// test SSH_DOMAIN while use non-standard SSH port
   207  	setting.SSH.Port = 123
   208  	setting.Repository.UseCompatSSHURI = false
   209  	assert.Equal(t, "ssh://git@domain:123/user/repo.git", repo_model.ComposeSSHCloneURL("user", "repo"))
   210  	setting.Repository.UseCompatSSHURI = true
   211  	assert.Equal(t, "ssh://git@domain:123/user/repo.git", repo_model.ComposeSSHCloneURL("user", "repo"))
   212  
   213  	// test IPv6 SSH_DOMAIN
   214  	setting.Repository.UseCompatSSHURI = false
   215  	setting.SSH.Domain = "::1"
   216  	setting.SSH.Port = 22
   217  	assert.Equal(t, "git@[::1]:user/repo.git", repo_model.ComposeSSHCloneURL("user", "repo"))
   218  	setting.SSH.Port = 123
   219  	assert.Equal(t, "ssh://git@[::1]:123/user/repo.git", repo_model.ComposeSSHCloneURL("user", "repo"))
   220  }