221 lines
7.1 KiB
Diff
221 lines
7.1 KiB
Diff
7a8
|
|
> "bytes"
|
|
10a12
|
|
> "io"
|
|
51,52d52
|
|
< var preparedDir string
|
|
<
|
|
180,219d179
|
|
<
|
|
< case setting.Database.Type.IsSQLite3():
|
|
< setting.Database.Path = ":memory:"
|
|
< }
|
|
<
|
|
< setting.Repository.Local.LocalCopyPath = os.TempDir()
|
|
< dir, err := os.MkdirTemp("", "prepared-forgejo")
|
|
< if err != nil {
|
|
< log.Fatal("os.MkdirTemp: %v", err)
|
|
< }
|
|
< preparedDir = dir
|
|
<
|
|
< setting.Repository.Local.LocalCopyPath, err = os.MkdirTemp("", "local-upload")
|
|
< if err != nil {
|
|
< log.Fatal("os.MkdirTemp: %v", err)
|
|
< }
|
|
<
|
|
< if err := unittest.CopyDir(path.Join(filepath.Dir(setting.AppPath), "tests/gitea-repositories-meta"), dir); err != nil {
|
|
< log.Fatal("os.RemoveAll: %v", err)
|
|
< }
|
|
< ownerDirs, err := os.ReadDir(dir)
|
|
< if err != nil {
|
|
< log.Fatal("os.ReadDir: %v", err)
|
|
< }
|
|
<
|
|
< for _, ownerDir := range ownerDirs {
|
|
< if !ownerDir.Type().IsDir() {
|
|
< continue
|
|
< }
|
|
< repoDirs, err := os.ReadDir(filepath.Join(dir, ownerDir.Name()))
|
|
< if err != nil {
|
|
< log.Fatal("os.ReadDir: %v", err)
|
|
< }
|
|
< for _, repoDir := range repoDirs {
|
|
< _ = os.MkdirAll(filepath.Join(dir, ownerDir.Name(), repoDir.Name(), "objects", "pack"), 0o755)
|
|
< _ = os.MkdirAll(filepath.Join(dir, ownerDir.Name(), repoDir.Name(), "objects", "info"), 0o755)
|
|
< _ = os.MkdirAll(filepath.Join(dir, ownerDir.Name(), repoDir.Name(), "refs", "heads"), 0o755)
|
|
< _ = os.MkdirAll(filepath.Join(dir, ownerDir.Name(), repoDir.Name(), "refs", "tag"), 0o755)
|
|
< _ = os.MkdirAll(filepath.Join(dir, ownerDir.Name(), repoDir.Name(), "refs", "pull"), 0o755)
|
|
< }
|
|
269,274c229,235
|
|
< func PrepareGitRepoDirectory(t testing.TB) {
|
|
< var err error
|
|
< setting.RepoRootPath, err = os.MkdirTemp(t.TempDir(), "forgejo-repo-rooth")
|
|
< require.NoError(t, err)
|
|
< require.NoError(t, unittest.CopyDir(preparedDir, setting.RepoRootPath))
|
|
< }
|
|
---
|
|
> func PrepareTestEnv(t testing.TB, skip ...int) func() {
|
|
> t.Helper()
|
|
> ourSkip := 1
|
|
> if len(skip) > 0 {
|
|
> ourSkip += skip[0]
|
|
> }
|
|
> deferFn := PrintCurrentTest(t, ourSkip)
|
|
276,278c237,240
|
|
< func PrepareArtifactsStorage(t testing.TB) {
|
|
< // prepare actions artifacts directory and files
|
|
< require.NoError(t, storage.Clean(storage.ActionsArtifacts))
|
|
---
|
|
> // kill all background processes to prevent them from interfering with the fixture loading
|
|
> // see https://codeberg.org/forgejo/forgejo/issues/2962
|
|
> cancelProcesses(t, 30*time.Second)
|
|
> t.Cleanup(func() { cancelProcesses(t, 0) }) // cancel remaining processes in a non-blocking way
|
|
280,288c242,266
|
|
< s, err := storage.NewStorage(setting.LocalStorageType, &setting.Storage{
|
|
< Path: filepath.Join(filepath.Dir(setting.AppPath), "tests", "testdata", "data", "artifacts"),
|
|
< })
|
|
< require.NoError(t, err)
|
|
< require.NoError(t, s.IterateObjects("", func(p string, obj storage.Object) error {
|
|
< _, err = storage.Copy(storage.ActionsArtifacts, p, s, p)
|
|
< return err
|
|
< }))
|
|
< }
|
|
---
|
|
> // load database fixtures
|
|
> require.NoError(t, unittest.LoadFixtures())
|
|
>
|
|
> // load git repo fixtures
|
|
> require.NoError(t, util.RemoveAll(setting.RepoRootPath))
|
|
> require.NoError(t, unittest.CopyDir(path.Join(filepath.Dir(setting.AppPath), "tests/gitea-repositories-meta"), setting.RepoRootPath))
|
|
> ownerDirs, err := os.ReadDir(setting.RepoRootPath)
|
|
> if err != nil {
|
|
> require.NoError(t, err, "unable to read the new repo root: %v\n", err)
|
|
> }
|
|
> for _, ownerDir := range ownerDirs {
|
|
> if !ownerDir.Type().IsDir() {
|
|
> continue
|
|
> }
|
|
> repoDirs, err := os.ReadDir(filepath.Join(setting.RepoRootPath, ownerDir.Name()))
|
|
> if err != nil {
|
|
> require.NoError(t, err, "unable to read the new repo root: %v\n", err)
|
|
> }
|
|
> for _, repoDir := range repoDirs {
|
|
> _ = os.MkdirAll(filepath.Join(setting.RepoRootPath, ownerDir.Name(), repoDir.Name(), "objects", "pack"), 0o755)
|
|
> _ = os.MkdirAll(filepath.Join(setting.RepoRootPath, ownerDir.Name(), repoDir.Name(), "objects", "info"), 0o755)
|
|
> _ = os.MkdirAll(filepath.Join(setting.RepoRootPath, ownerDir.Name(), repoDir.Name(), "refs", "heads"), 0o755)
|
|
> _ = os.MkdirAll(filepath.Join(setting.RepoRootPath, ownerDir.Name(), repoDir.Name(), "refs", "tag"), 0o755)
|
|
> }
|
|
> }
|
|
290d267
|
|
< func PrepareLFSStorage(t testing.TB) {
|
|
292c269
|
|
< // (LFS storage can be on any of several backends, including remote servers, so init it with the storage API)
|
|
---
|
|
> // (LFS storage can be on any of several backends, including remote servers, so we init it with the storage API)
|
|
302d278
|
|
< }
|
|
304d279
|
|
< func PrepareCleanPackageData(t testing.TB) {
|
|
316,323d290
|
|
< }
|
|
<
|
|
< func PrepareTestEnv(t testing.TB, skip ...int) func() {
|
|
< t.Helper()
|
|
< deferFn := PrintCurrentTest(t, util.OptionalArg(skip)+1)
|
|
<
|
|
< cancelProcesses(t, 30*time.Second)
|
|
< t.Cleanup(func() { cancelProcesses(t, 0) }) // cancel remaining processes in a non-blocking way
|
|
325,331d291
|
|
< // load database fixtures
|
|
< require.NoError(t, unittest.LoadFixtures())
|
|
<
|
|
< // do not add more Prepare* functions here, only call necessary ones in the related test functions
|
|
< PrepareGitRepoDirectory(t)
|
|
< PrepareLFSStorage(t)
|
|
< PrepareCleanPackageData(t)
|
|
337c297,301
|
|
< return testlogger.PrintCurrentTest(t, util.OptionalArg(skip)+1)
|
|
---
|
|
> actualSkip := 1
|
|
> if len(skip) > 0 {
|
|
> actualSkip = skip[0] + 1
|
|
> }
|
|
> return testlogger.PrintCurrentTest(t, actualSkip)
|
|
489a454,530
|
|
> }
|
|
>
|
|
> // Decide if two files have the same contents or not.
|
|
> // chunkSize is the size of the blocks to scan by; pass 0 to get a sensible default.
|
|
> // *Follows* symlinks.
|
|
> //
|
|
> // May return an error if something else goes wrong; in this case, you should ignore the value of 'same'.
|
|
> //
|
|
> // derived from https://stackoverflow.com/a/30038571
|
|
> // under CC-BY-SA-4.0 by several contributors
|
|
> func FileCmp(file1, file2 string, chunkSize int) (same bool, err error) {
|
|
> if chunkSize == 0 {
|
|
> chunkSize = 4 * 1024
|
|
> }
|
|
>
|
|
> // shortcuts: check file metadata
|
|
> stat1, err := os.Stat(file1)
|
|
> if err != nil {
|
|
> return false, err
|
|
> }
|
|
>
|
|
> stat2, err := os.Stat(file2)
|
|
> if err != nil {
|
|
> return false, err
|
|
> }
|
|
>
|
|
> // are inputs are literally the same file?
|
|
> if os.SameFile(stat1, stat2) {
|
|
> return true, nil
|
|
> }
|
|
>
|
|
> // do inputs at least have the same size?
|
|
> if stat1.Size() != stat2.Size() {
|
|
> return false, nil
|
|
> }
|
|
>
|
|
> // long way: compare contents
|
|
> f1, err := os.Open(file1)
|
|
> if err != nil {
|
|
> return false, err
|
|
> }
|
|
> defer f1.Close()
|
|
>
|
|
> f2, err := os.Open(file2)
|
|
> if err != nil {
|
|
> return false, err
|
|
> }
|
|
> defer f2.Close()
|
|
>
|
|
> b1 := make([]byte, chunkSize)
|
|
> b2 := make([]byte, chunkSize)
|
|
> for {
|
|
> n1, err1 := io.ReadFull(f1, b1)
|
|
> n2, err2 := io.ReadFull(f2, b2)
|
|
>
|
|
> // https://pkg.go.dev/io#Reader
|
|
> // > Callers should always process the n > 0 bytes returned
|
|
> // > before considering the error err. Doing so correctly
|
|
> // > handles I/O errors that happen after reading some bytes
|
|
> // > and also both of the allowed EOF behaviors.
|
|
>
|
|
> if !bytes.Equal(b1[:n1], b2[:n2]) {
|
|
> return false, nil
|
|
> }
|
|
>
|
|
> if (err1 == io.EOF && err2 == io.EOF) || (err1 == io.ErrUnexpectedEOF && err2 == io.ErrUnexpectedEOF) {
|
|
> return true, nil
|
|
> }
|
|
>
|
|
> // some other error, like a dropped network connection or a bad transfer
|
|
> if err1 != nil {
|
|
> return false, err1
|
|
> }
|
|
> if err2 != nil {
|
|
> return false, err2
|
|
> }
|
|
> }
|