mirror of
https://github.com/go-gitea/gitea.git
synced 2026-11-19 15:14:40 +09:00
Adds audit actions for security-relevant changes that were not logged at all, and records a few remaining events on paths that skipped them: - Account login prohibition (`user:status:prohibitlogin`) and the organization setting that lets repository admins change team access - Actions runner registration tokens issued, runners removed or enabled/disabled, and Actions variables, for every scope - Instance config changes, including maintenance mode (`system:config:update`) - Deploy token regeneration and pull mirror address changes - Review deletion and dismissal, package removal, and release and tag removal - Repository restores via `gitea admin restore-repo`, OAuth2 secret rotation on API update, and SSH keys added or removed by authentication source sync The authentication source SSH key sync moved from the asymkey model to the asymkey service so it can record events. Follow-up to https://github.com/go-gitea/gitea/pull/40317 and https://github.com/go-gitea/gitea/pull/40322. --------- Co-authored-by: silverwind <me@silverwind.io>
444 lines
16 KiB
Go
444 lines
16 KiB
Go
// Copyright 2018 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package release
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
audit_model "gitea.dev/models/audit"
|
|
"gitea.dev/models/db"
|
|
issues_model "gitea.dev/models/issues"
|
|
repo_model "gitea.dev/models/repo"
|
|
"gitea.dev/models/unittest"
|
|
user_model "gitea.dev/models/user"
|
|
"gitea.dev/modules/git"
|
|
"gitea.dev/modules/setting"
|
|
api "gitea.dev/modules/structs"
|
|
"gitea.dev/modules/test"
|
|
"gitea.dev/modules/timeutil"
|
|
"gitea.dev/services/attachment"
|
|
"gitea.dev/services/context/upload"
|
|
|
|
_ "gitea.dev/models/actions"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
unittest.MainTest(m)
|
|
}
|
|
|
|
func TestRelease_Create(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
|
|
gitRepo, err := git.OpenRepository(t.Context(), repo)
|
|
assert.NoError(t, err)
|
|
defer gitRepo.Close()
|
|
|
|
for _, testCase := range []struct {
|
|
tagName, target string
|
|
isDraft, isPrerelease bool
|
|
}{
|
|
{"v0.1", "master", false, false},
|
|
{"v0.1.1", "65f1bf27bc3bf70f64657658635e66094edbcb4d", false, false},
|
|
{"v0.1.2", "65f1bf2", false, false},
|
|
{"v0.1.3", "65f1bf2", true, false},
|
|
{"v0.1.4", "65f1bf2", false, true},
|
|
} {
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, &repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: testCase.tagName,
|
|
Target: testCase.target,
|
|
Title: testCase.tagName + " is released",
|
|
Note: testCase.tagName + " is released",
|
|
IsDraft: testCase.isDraft,
|
|
IsPrerelease: testCase.isPrerelease,
|
|
IsTag: false,
|
|
}, nil, "", ""))
|
|
}
|
|
|
|
testPlayload := "testtest"
|
|
|
|
attach, err := attachment.NewAttachment(t.Context(), &repo_model.Attachment{
|
|
RepoID: repo.ID,
|
|
UploaderID: user.ID,
|
|
Name: "test.txt",
|
|
}, strings.NewReader(testPlayload), int64(len([]byte(testPlayload))))
|
|
assert.NoError(t, err)
|
|
|
|
release := repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: "v0.1.5",
|
|
Target: "65f1bf2",
|
|
Title: "v0.1.5 is released",
|
|
Note: "v0.1.5 is released",
|
|
IsDraft: false,
|
|
IsPrerelease: false,
|
|
IsTag: true,
|
|
}
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, &release, []string{attach.UUID}, "test", ""))
|
|
}
|
|
|
|
func TestRelease_Update(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
|
|
gitRepo, err := git.OpenRepository(t.Context(), repo)
|
|
assert.NoError(t, err)
|
|
defer gitRepo.Close()
|
|
|
|
// Advance a mocked clock between create and update instead of sleeping, so the
|
|
// timestamp-sensitive assertions below stay deterministic.
|
|
fakeNow := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
defer timeutil.MockSet(fakeNow)()
|
|
advance := func() { fakeNow = fakeNow.Add(time.Second); timeutil.MockSet(fakeNow) }
|
|
|
|
// Test a changed release
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, &repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: "v1.1.1",
|
|
Target: "master",
|
|
Title: "v1.1.1 is released",
|
|
Note: "v1.1.1 is released",
|
|
IsDraft: false,
|
|
IsPrerelease: false,
|
|
IsTag: false,
|
|
}, nil, "", ""))
|
|
release, err := repo_model.GetRelease(t.Context(), repo.ID, "v1.1.1")
|
|
assert.NoError(t, err)
|
|
releaseCreatedUnix := release.CreatedUnix
|
|
releasePublishedUnix := release.PublishedUnix
|
|
advance()
|
|
release.Note = "Changed note"
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, nil, ""))
|
|
release, err = repo_model.GetReleaseByID(t.Context(), release.ID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
|
|
assert.Equal(t, releasePublishedUnix, release.PublishedUnix, "editing does not republish")
|
|
|
|
// Test a changed draft
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, &repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: "v1.2.1",
|
|
Target: "65f1bf2",
|
|
Title: "v1.2.1 is draft",
|
|
Note: "v1.2.1 is draft",
|
|
IsDraft: true,
|
|
IsPrerelease: false,
|
|
IsTag: false,
|
|
}, nil, "", ""))
|
|
release, err = repo_model.GetRelease(t.Context(), repo.ID, "v1.2.1")
|
|
assert.NoError(t, err)
|
|
releaseCreatedUnix = release.CreatedUnix
|
|
advance()
|
|
release.Title = "Changed title"
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, nil, ""))
|
|
release, err = repo_model.GetReleaseByID(t.Context(), release.ID)
|
|
assert.NoError(t, err)
|
|
assert.Less(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
|
|
assert.Zero(t, release.PublishedUnix, "a draft is unpublished")
|
|
|
|
// Test publishing and withdrawing that draft
|
|
release.IsDraft = false
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, nil, ""))
|
|
release, err = repo_model.GetReleaseByID(t.Context(), release.ID)
|
|
assert.NoError(t, err)
|
|
assert.NotZero(t, release.PublishedUnix, "publishing stamps the publication time")
|
|
release.IsDraft = true
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, nil, ""))
|
|
release, err = repo_model.GetReleaseByID(t.Context(), release.ID)
|
|
assert.NoError(t, err)
|
|
assert.Zero(t, release.PublishedUnix, "withdrawing unpublishes it again")
|
|
|
|
// Test a changed pre-release
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, &repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: "v1.3.1",
|
|
Target: "65f1bf2",
|
|
Title: "v1.3.1 is pre-released",
|
|
Note: "v1.3.1 is pre-released",
|
|
IsDraft: false,
|
|
IsPrerelease: true,
|
|
IsTag: false,
|
|
}, nil, "", ""))
|
|
release, err = repo_model.GetRelease(t.Context(), repo.ID, "v1.3.1")
|
|
assert.NoError(t, err)
|
|
releaseCreatedUnix = release.CreatedUnix
|
|
advance()
|
|
release.Title = "Changed title"
|
|
release.Note = "Changed note"
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, nil, ""))
|
|
release, err = repo_model.GetReleaseByID(t.Context(), release.ID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
|
|
|
|
// Test create release
|
|
release = &repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: "v1.1.2",
|
|
Target: "",
|
|
Title: "v1.1.2 is released",
|
|
Note: "v1.1.2 is released",
|
|
IsDraft: true,
|
|
IsPrerelease: false,
|
|
IsTag: false,
|
|
}
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, release, nil, "", ""))
|
|
assert.Positive(t, release.ID)
|
|
assert.Empty(t, release.Attachments)
|
|
|
|
release.IsDraft = false
|
|
tagName := release.TagName
|
|
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, nil, ""))
|
|
release, err = repo_model.GetReleaseByID(t.Context(), release.ID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, tagName, release.TagName)
|
|
|
|
// Add new attachments
|
|
samplePayload := "testtest"
|
|
attach, err := attachment.NewAttachment(t.Context(), &repo_model.Attachment{
|
|
RepoID: repo.ID,
|
|
UploaderID: user.ID,
|
|
Name: "test.txt",
|
|
}, strings.NewReader(samplePayload), int64(len([]byte(samplePayload))))
|
|
assert.NoError(t, err)
|
|
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, []string{attach.UUID}, nil, nil, ""))
|
|
unsavedRelease := &repo_model.Release{}
|
|
release.Attachments = nil
|
|
assert.NoError(t, repo_model.GetReleaseAttachments(t.Context(), unsavedRelease, release))
|
|
assert.Empty(t, unsavedRelease.Attachments)
|
|
assert.Len(t, release.Attachments, 1)
|
|
assert.Equal(t, attach.UUID, release.Attachments[0].UUID)
|
|
assert.Equal(t, release.ID, release.Attachments[0].ReleaseID)
|
|
assert.Equal(t, attach.Name, release.Attachments[0].Name)
|
|
|
|
// update the attachment name
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, map[string]string{
|
|
attach.UUID: "test2.txt",
|
|
}, ""))
|
|
release.Attachments = nil
|
|
assert.NoError(t, repo_model.GetReleaseAttachments(t.Context(), release))
|
|
assert.Len(t, release.Attachments, 1)
|
|
assert.Equal(t, attach.UUID, release.Attachments[0].UUID)
|
|
assert.Equal(t, release.ID, release.Attachments[0].ReleaseID)
|
|
assert.Equal(t, "test2.txt", release.Attachments[0].Name)
|
|
|
|
defer test.MockVariableValue(&setting.Repository.Release.AllowedTypes, ".zip")()
|
|
err = UpdateRelease(t.Context(), user, gitRepo, release, nil, nil, map[string]string{
|
|
attach.UUID: "test.exe",
|
|
}, "")
|
|
assert.Error(t, err)
|
|
assert.True(t, upload.IsErrFileTypeForbidden(err))
|
|
release.Attachments = nil
|
|
assert.NoError(t, repo_model.GetReleaseAttachments(t.Context(), release))
|
|
assert.Len(t, release.Attachments, 1)
|
|
assert.Equal(t, "test2.txt", release.Attachments[0].Name)
|
|
|
|
// delete the attachment
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, release, nil, []string{attach.UUID}, nil, ""))
|
|
release.Attachments = nil
|
|
assert.NoError(t, repo_model.GetReleaseAttachments(t.Context(), release))
|
|
assert.Empty(t, release.Attachments)
|
|
}
|
|
|
|
func TestRelease_createTag(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
|
|
gitRepo, err := git.OpenRepository(t.Context(), repo)
|
|
assert.NoError(t, err)
|
|
defer gitRepo.Close()
|
|
|
|
// Advance a mocked clock between create and update instead of sleeping, so the
|
|
// timestamp-sensitive assertions below stay deterministic.
|
|
fakeNow := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
defer timeutil.MockSet(fakeNow)()
|
|
advance := func() { fakeNow = fakeNow.Add(time.Second); timeutil.MockSet(fakeNow) }
|
|
|
|
for _, testCase := range []struct {
|
|
tagName, target, state string
|
|
isDraft, isPrerelease bool
|
|
}{
|
|
// Test a changed release
|
|
{"v2.1.1", "master", "released", false, false},
|
|
// Test a changed draft
|
|
{"v2.2.1", "65f1bf2", "draft", true, false},
|
|
// Test a changed pre-release
|
|
{"v2.3.1", "65f1bf2", "pre-released", false, true},
|
|
} {
|
|
release := &repo_model.Release{
|
|
RepoID: repo.ID,
|
|
Repo: repo,
|
|
PublisherID: user.ID,
|
|
Publisher: user,
|
|
TagName: testCase.tagName,
|
|
Target: testCase.target,
|
|
Title: testCase.tagName + " is " + testCase.state,
|
|
Note: testCase.tagName + " is " + testCase.state,
|
|
IsDraft: testCase.isDraft,
|
|
IsPrerelease: testCase.isPrerelease,
|
|
IsTag: false,
|
|
}
|
|
err = createTag(t.Context(), gitRepo, release, "")
|
|
assert.NoError(t, err)
|
|
if !testCase.isDraft && !testCase.isPrerelease {
|
|
assert.NotEmpty(t, release.CreatedUnix)
|
|
}
|
|
releaseCreatedUnix := release.CreatedUnix
|
|
advance()
|
|
if testCase.isDraft || testCase.isPrerelease {
|
|
release.Title = "Changed title"
|
|
}
|
|
if !testCase.isDraft {
|
|
release.Note = "Changed note"
|
|
}
|
|
err = createTag(t.Context(), gitRepo, release, "")
|
|
assert.NoError(t, err)
|
|
if testCase.isDraft {
|
|
assert.Less(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
|
|
} else {
|
|
assert.Equal(t, int64(releaseCreatedUnix), int64(release.CreatedUnix))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreateNewTag(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
|
|
assert.NoError(t, CreateNewTag(t.Context(), user, repo, "master", "v2.0",
|
|
"v2.0 is released \n\n BUGFIX: .... \n\n 123"))
|
|
}
|
|
|
|
func TestDeleteReleaseByIDAuditEvents(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
defer test.MockVariableValue(&setting.Audit.RecordOutput, setting.AuditRecordOutputDatabase)()
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
|
|
for _, id := range []int64{1, 3} {
|
|
rel := unittest.AssertExistsAndLoadBean(t, &repo_model.Release{ID: id})
|
|
assert.NoError(t, DeleteReleaseByID(t.Context(), repo, rel, user, rel.IsTag))
|
|
}
|
|
unittest.AssertCount(t, &audit_model.Event{Action: audit_model.RepositoryReleaseRemove}, 1)
|
|
unittest.AssertCount(t, &audit_model.Event{Action: audit_model.RepositoryTagRemove}, 1)
|
|
}
|
|
|
|
func TestCreateReleaseReaction(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 4})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
release := unittest.AssertExistsAndLoadBean(t, &repo_model.Release{ID: 1})
|
|
|
|
assert.Equal(t, []string{"+1", "laugh", "hooray", "heart", "rocket", "eyes"}, AllowedReleaseReactions())
|
|
|
|
_, err := CreateReleaseReaction(t.Context(), user, release, "heart")
|
|
assert.NoError(t, err)
|
|
assert.NoError(t, DeleteReleaseByID(t.Context(), repo, release, user, false))
|
|
unittest.AssertNotExistsBean(t, &issues_model.Reaction{ReleaseID: release.ID})
|
|
|
|
assert.NoError(t, db.Insert(t.Context(), &user_model.Blocking{BlockerID: repo.OwnerID, BlockeeID: user.ID}))
|
|
_, err = CreateReleaseReaction(t.Context(), user, release, "heart")
|
|
assert.ErrorIs(t, err, user_model.ErrBlockedUser)
|
|
}
|
|
|
|
func TestRelease_LatestByCommitDateUnlessSet(t *testing.T) {
|
|
assert.NoError(t, unittest.PrepareTestDatabase())
|
|
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
|
|
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
|
|
gitRepo, err := git.OpenRepository(t.Context(), repo)
|
|
assert.NoError(t, err)
|
|
defer gitRepo.Close()
|
|
|
|
newRelease := func(tagName, target string, makeLatest api.MakeLatest) *repo_model.Release {
|
|
rel := &repo_model.Release{
|
|
RepoID: repo.ID, Repo: repo, PublisherID: user.ID, Publisher: user,
|
|
TagName: tagName, Target: target, Title: tagName,
|
|
}
|
|
assert.NoError(t, CreateRelease(t.Context(), gitRepo, rel, nil, "", makeLatest))
|
|
return rel
|
|
}
|
|
|
|
recent := newRelease("v9.9-recent", "DefaultBranch", "")
|
|
// released afterwards, but from an older commit, so it must not take over as the latest release
|
|
old := newRelease("v9.9-old", "master", "")
|
|
|
|
oldCommit, err := gitRepo.GetBranchCommit(t.Context(), "master")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, oldCommit.Committer.When.Unix(), int64(old.CreatedUnix), "a release is dated by the commit it points at")
|
|
assert.Greater(t, int64(old.PublishedUnix), int64(old.CreatedUnix), "but its publication time is now")
|
|
|
|
assertLatest := func(expected *repo_model.Release) {
|
|
latest, err := repo_model.GetLatestRelease(t.Context(), unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repo.ID}))
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, expected.TagName, latest.TagName)
|
|
}
|
|
updateRelease := func(rel *repo_model.Release, makeLatest api.MakeLatest) {
|
|
assert.NoError(t, UpdateRelease(t.Context(), user, gitRepo, rel, nil, nil, nil, makeLatest))
|
|
}
|
|
assertLatest(recent)
|
|
|
|
updateRelease(old, api.MakeLatestTrue)
|
|
assertLatest(old)
|
|
newRelease("v9.9-backport", "master", "")
|
|
assertLatest(old)
|
|
|
|
old.IsPrerelease = true
|
|
updateRelease(old, "")
|
|
assertLatest(recent)
|
|
old.IsPrerelease = false
|
|
updateRelease(old, "")
|
|
assertLatest(recent)
|
|
|
|
updateRelease(old, api.MakeLatestTrue)
|
|
newer := newRelease("v9.9-newer", "DefaultBranch", "")
|
|
assertLatest(newer)
|
|
|
|
updateRelease(old, api.MakeLatestTrue)
|
|
updateRelease(newer, api.MakeLatestLegacy)
|
|
assert.Zero(t, unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repo.ID}).LatestReleaseID)
|
|
assertLatest(newer)
|
|
|
|
updateRelease(old, api.MakeLatestTrue)
|
|
assert.NoError(t, DeleteReleaseByID(t.Context(), repo, old, user, false))
|
|
assert.Zero(t, unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repo.ID}).LatestReleaseID)
|
|
assertLatest(newer)
|
|
|
|
newRelease("v9.9-newest", "DefaultBranch", api.MakeLatestFalse)
|
|
assertLatest(newer)
|
|
updateRelease(newer, api.MakeLatestFalse)
|
|
assertLatest(newer)
|
|
}
|