2017-04-25 02:24:51 -05:00
// Copyright 2017 The Gitea Authors. All rights reserved.
2024-01-12 05:50:29 -05:00
// Copyright 2024 The Forgejo Authors c/o Codeberg e.V.. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2017-04-25 02:24:51 -05:00
Enable forbidigo linter (#24278)
Enable [forbidigo](https://github.com/ashanbrown/forbidigo) linter which
forbids print statements. Will check how to integrate this with the
smallest impact possible, so a few `nolint` comments will likely be
required. Plan is to just go through the issues and either:
- Remove the print if it is nonsensical
- Add a `//nolint` directive if it makes sense
I don't plan on investigating the individual issues any further.
<details>
<summary>Initial Lint Results</summary>
```
modules/log/event.go:348:6: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(err)
^
modules/log/event.go:382:6: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(err)
^
modules/queue/unique_queue_disk_channel_test.go:20:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("TempDir %s\n", tmpDir)
^
contrib/backport/backport.go:168:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Backporting %s to %s as %s\n", pr, localReleaseBranch, backportBranch)
^
contrib/backport/backport.go:216:4: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Navigate to %s to open PR\n", url)
^
contrib/backport/backport.go:223:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* `xdg-open %s`\n", url)
^
contrib/backport/backport.go:233:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* `git push -u %s %s`\n", remote, backportBranch)
^
contrib/backport/backport.go:243:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Amending commit to prepend `Backport #%s` to body\n", pr)
^
contrib/backport/backport.go:272:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("* Attempting git cherry-pick --continue")
^
contrib/backport/backport.go:281:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Attempting git cherry-pick %s\n", sha)
^
contrib/backport/backport.go:297:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Current branch is %s\n", currentBranch)
^
contrib/backport/backport.go:299:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Current branch is %s - not checking out\n", currentBranch)
^
contrib/backport/backport.go:304:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* Branch %s already exists. Checking it out...\n", backportBranch)
^
contrib/backport/backport.go:308:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* `git checkout -b %s %s`\n", backportBranch, releaseBranch)
^
contrib/backport/backport.go:313:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* `git fetch %s main`\n", remote)
^
contrib/backport/backport.go:316:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(string(out))
^
contrib/backport/backport.go:319:2: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(string(out))
^
contrib/backport/backport.go:321:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("* `git fetch %s %s`\n", remote, releaseBranch)
^
contrib/backport/backport.go:324:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(string(out))
^
contrib/backport/backport.go:327:2: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(string(out))
^
models/unittest/fixtures.go:50:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("Unsupported RDBMS for integration tests")
^
models/unittest/fixtures.go:89:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("LoadFixtures failed after retries: %v\n", err)
^
models/unittest/fixtures.go:110:4: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Failed to generate sequence update: %v\n", err)
^
models/unittest/fixtures.go:117:6: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Failed to update sequence: %s Error: %v\n", value, err)
^
models/migrations/base/tests.go:118:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("Environment variable $GITEA_ROOT not set")
^
models/migrations/base/tests.go:127:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Could not find gitea binary at %s\n", setting.AppPath)
^
models/migrations/base/tests.go:134:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Environment variable $GITEA_CONF not set - defaulting to %s\n", giteaConf)
^
models/migrations/base/tests.go:145:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Unable to create temporary data path %v\n", err)
^
models/migrations/base/tests.go:154:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Unable to InitFull: %v\n", err)
^
models/migrations/v1_11/v112.go:34:5: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Error: %v", err)
^
contrib/fixtures/fixture_generation.go:36:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("CreateTestEngine: %+v", err)
^
contrib/fixtures/fixture_generation.go:40:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("PrepareTestDatabase: %+v\n", err)
^
contrib/fixtures/fixture_generation.go:46:5: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("generate '%s': %+v\n", r, err)
^
contrib/fixtures/fixture_generation.go:53:5: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("generate '%s': %+v\n", g.name, err)
^
contrib/fixtures/fixture_generation.go:71:4: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s created.\n", path)
^
services/gitdiff/gitdiff_test.go:543:2: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println(result)
^
services/gitdiff/gitdiff_test.go:560:2: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println(result)
^
services/gitdiff/gitdiff_test.go:577:2: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println(result)
^
modules/web/routing/logger_manager.go:34:2: use of `print` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
print Printer
^
modules/doctor/paths.go:109:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Warning: can't remove temporary file: '%s'\n", tmpFile.Name())
^
tests/test_utils.go:33:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf(format+"\n", args...)
^
tests/test_utils.go:61:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Environment variable $GITEA_CONF not set, use default: %s\n", giteaConf)
^
cmd/actions.go:54:9: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
_, _ = fmt.Printf("%s\n", respText)
^
cmd/admin_user_change_password.go:74:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s's password has been successfully updated!\n", user.Name)
^
cmd/admin_user_create.go:109:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("generated random password is '%s'\n", password)
^
cmd/admin_user_create.go:164:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Access token was successfully created... %s\n", t.Token)
^
cmd/admin_user_create.go:167:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("New user '%s' has been successfully created!\n", username)
^
cmd/admin_user_generate_access_token.go:74:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s\n", t.Token)
^
cmd/admin_user_generate_access_token.go:76:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Access token was successfully created: %s\n", t.Token)
^
cmd/admin_user_must_change_password.go:56:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Updated %d users setting MustChangePassword to %t\n", n, mustChangePassword)
^
cmd/convert.go:44:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("Converted successfully, please confirm your database's character set is now utf8mb4")
^
cmd/convert.go:50:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("Converted successfully, please confirm your database's all columns character is NVARCHAR now")
^
cmd/convert.go:52:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("This command can only be used with a MySQL or MSSQL database")
^
cmd/doctor.go:104:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(err)
^
cmd/doctor.go:105:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("Check if you are using the right config file. You can use a --config directive to specify one.")
^
cmd/doctor.go:243:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(err)
^
cmd/embedded.go:154:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(a.path)
^
cmd/embedded.go:198:3: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("Using app.ini at", setting.CustomConf)
^
cmd/embedded.go:217:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Extracting to %s:\n", destdir)
^
cmd/embedded.go:253:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s already exists; skipped.\n", dest)
^
cmd/embedded.go:275:2: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(dest)
^
cmd/generate.go:63:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s", internalToken)
^
cmd/generate.go:66:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("\n")
^
cmd/generate.go:78:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s", JWTSecretBase64)
^
cmd/generate.go:81:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("\n")
^
cmd/generate.go:93:2: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s", secretKey)
^
cmd/generate.go:96:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("\n")
^
cmd/keys.go:74:2: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println(strings.TrimSpace(authorizedString))
^
cmd/mailer.go:32:4: use of `fmt.Print` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Print("warning: Content is empty")
^
cmd/mailer.go:35:3: use of `fmt.Print` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Print("Proceed with sending email? [Y/n] ")
^
cmd/mailer.go:40:4: use of `fmt.Println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Println("The mail was not sent")
^
cmd/mailer.go:49:9: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
_, _ = fmt.Printf("Sent %s email(s) to all users\n", respText)
^
cmd/serv.go:147:3: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println("Gitea: SSH has been disabled")
^
cmd/serv.go:153:4: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("error showing subcommand help: %v\n", err)
^
cmd/serv.go:175:4: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println("Hi there! You've successfully authenticated with the deploy key named " + key.Name + ", but Gitea does not provide shell access.")
^
cmd/serv.go:177:4: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println("Hi there! You've successfully authenticated with the principal " + key.Content + ", but Gitea does not provide shell access.")
^
cmd/serv.go:179:4: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println("Hi there, " + user.Name + "! You've successfully authenticated with the key named " + key.Name + ", but Gitea does not provide shell access.")
^
cmd/serv.go:181:3: use of `println` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
println("If this is unexpected, please log in with password and setup Gitea under another user.")
^
cmd/serv.go:196:5: use of `fmt.Print` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Print(`{"type":"gitea","version":1}`)
^
tests/e2e/e2e_test.go:54:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Error initializing test database: %v\n", err)
^
tests/e2e/e2e_test.go:63:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("util.RemoveAll: %v\n", err)
^
tests/e2e/e2e_test.go:67:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Unable to remove repo indexer: %v\n", err)
^
tests/e2e/e2e_test.go:109:6: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%v", stdout.String())
^
tests/e2e/e2e_test.go:110:6: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%v", stderr.String())
^
tests/e2e/e2e_test.go:113:6: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%v", stdout.String())
^
tests/integration/integration_test.go:124:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Error initializing test database: %v\n", err)
^
tests/integration/integration_test.go:135:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("util.RemoveAll: %v\n", err)
^
tests/integration/integration_test.go:139:3: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("Unable to remove repo indexer: %v\n", err)
^
tests/integration/repo_test.go:357:4: use of `fmt.Printf` forbidden by pattern `^(fmt\.Print(|f|ln)|print|println)$` (forbidigo)
fmt.Printf("%s", resp.Body)
^
```
</details>
---------
Co-authored-by: Giteabot <teabot@gitea.io>
2023-04-24 04:50:58 -05:00
//nolint:forbidigo
2022-09-02 14:18:23 -05:00
package integration
2017-04-25 02:24:51 -05:00
import (
"bytes"
2019-12-15 04:51:28 -05:00
"context"
2017-04-25 02:24:51 -05:00
"fmt"
2021-04-06 11:44:02 -05:00
"hash"
"hash/fnv"
2017-04-25 02:24:51 -05:00
"io"
"net/http"
2017-05-01 19:49:55 -05:00
"net/http/cookiejar"
2017-12-03 17:46:01 -05:00
"net/http/httptest"
2017-05-01 19:49:55 -05:00
"net/url"
2017-04-25 02:24:51 -05:00
"os"
2024-03-27 16:02:51 -05:00
"os/exec"
2017-11-02 12:51:03 -05:00
"path/filepath"
2023-11-22 11:26:21 -05:00
"strconv"
2017-05-01 19:49:55 -05:00
"strings"
2022-10-20 13:20:01 -05:00
"sync/atomic"
2017-04-25 02:24:51 -05:00
"testing"
2020-06-01 20:39:44 -05:00
"time"
2017-04-25 02:24:51 -05:00
2024-03-27 16:02:51 -05:00
"code.gitea.io/gitea/cmd"
2023-01-17 16:46:03 -05:00
"code.gitea.io/gitea/models/auth"
2023-06-05 04:43:31 -05:00
"code.gitea.io/gitea/models/db"
2024-01-12 05:50:29 -05:00
repo_model "code.gitea.io/gitea/models/repo"
unit_model "code.gitea.io/gitea/models/unit"
2021-11-12 09:36:47 -05:00
"code.gitea.io/gitea/models/unittest"
2023-06-05 04:43:31 -05:00
user_model "code.gitea.io/gitea/models/user"
2024-01-12 05:50:29 -05:00
"code.gitea.io/gitea/modules/git"
2019-12-15 04:51:28 -05:00
"code.gitea.io/gitea/modules/graceful"
2021-07-24 11:03:58 -05:00
"code.gitea.io/gitea/modules/json"
2020-10-31 15:51:48 -05:00
"code.gitea.io/gitea/modules/log"
2024-04-24 16:33:08 -05:00
"code.gitea.io/gitea/modules/optional"
2017-04-25 02:24:51 -05:00
"code.gitea.io/gitea/modules/setting"
Rewrite queue (#24505)
# ⚠️ Breaking
Many deprecated queue config options are removed (actually, they should
have been removed in 1.18/1.19).
If you see the fatal message when starting Gitea: "Please update your
app.ini to remove deprecated config options", please follow the error
messages to remove these options from your app.ini.
Example:
```
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].ISSUE_INDEXER_QUEUE_TYPE`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].UPDATE_BUFFER_LEN`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [F] Please update your app.ini to remove deprecated config options
```
Many options in `[queue]` are are dropped, including:
`WRAP_IF_NECESSARY`, `MAX_ATTEMPTS`, `TIMEOUT`, `WORKERS`,
`BLOCK_TIMEOUT`, `BOOST_TIMEOUT`, `BOOST_WORKERS`, they can be removed
from app.ini.
# The problem
The old queue package has some legacy problems:
* complexity: I doubt few people could tell how it works.
* maintainability: Too many channels and mutex/cond are mixed together,
too many different structs/interfaces depends each other.
* stability: due to the complexity & maintainability, sometimes there
are strange bugs and difficult to debug, and some code doesn't have test
(indeed some code is difficult to test because a lot of things are mixed
together).
* general applicability: although it is called "queue", its behavior is
not a well-known queue.
* scalability: it doesn't seem easy to make it work with a cluster
without breaking its behaviors.
It came from some very old code to "avoid breaking", however, its
technical debt is too heavy now. It's a good time to introduce a better
"queue" package.
# The new queue package
It keeps using old config and concept as much as possible.
* It only contains two major kinds of concepts:
* The "base queue": channel, levelqueue, redis
* They have the same abstraction, the same interface, and they are
tested by the same testing code.
* The "WokerPoolQueue", it uses the "base queue" to provide "worker
pool" function, calls the "handler" to process the data in the base
queue.
* The new code doesn't do "PushBack"
* Think about a queue with many workers, the "PushBack" can't guarantee
the order for re-queued unhandled items, so in new code it just does
"normal push"
* The new code doesn't do "pause/resume"
* The "pause/resume" was designed to handle some handler's failure: eg:
document indexer (elasticsearch) is down
* If a queue is paused for long time, either the producers blocks or the
new items are dropped.
* The new code doesn't do such "pause/resume" trick, it's not a common
queue's behavior and it doesn't help much.
* If there are unhandled items, the "push" function just blocks for a
few seconds and then re-queue them and retry.
* The new code doesn't do "worker booster"
* Gitea's queue's handlers are light functions, the cost is only the
go-routine, so it doesn't make sense to "boost" them.
* The new code only use "max worker number" to limit the concurrent
workers.
* The new "Push" never blocks forever
* Instead of creating more and more blocking goroutines, return an error
is more friendly to the server and to the end user.
There are more details in code comments: eg: the "Flush" problem, the
strange "code.index" hanging problem, the "immediate" queue problem.
Almost ready for review.
TODO:
* [x] add some necessary comments during review
* [x] add some more tests if necessary
* [x] update documents and config options
* [x] test max worker / active worker
* [x] re-run the CI tasks to see whether any test is flaky
* [x] improve the `handleOldLengthConfiguration` to provide more
friendly messages
* [x] fine tune default config values (eg: length?)
## Code coverage:
2023-05-08 06:49:59 -05:00
"code.gitea.io/gitea/modules/testlogger"
2020-08-11 15:05:34 -05:00
"code.gitea.io/gitea/modules/util"
2021-01-26 10:36:53 -05:00
"code.gitea.io/gitea/modules/web"
2017-04-25 02:24:51 -05:00
"code.gitea.io/gitea/routers"
2024-02-25 05:32:59 -05:00
"code.gitea.io/gitea/services/auth/source/remote"
2024-02-27 02:12:22 -05:00
gitea_context "code.gitea.io/gitea/services/context"
2024-01-12 05:50:29 -05:00
repo_service "code.gitea.io/gitea/services/repository"
files_service "code.gitea.io/gitea/services/repository/files"
2023-06-05 04:43:31 -05:00
user_service "code.gitea.io/gitea/services/user"
2024-04-24 17:08:53 -05:00
wiki_service "code.gitea.io/gitea/services/wiki"
2022-09-02 14:18:23 -05:00
"code.gitea.io/gitea/tests"
2017-04-25 02:24:51 -05:00
2017-12-10 21:15:27 -05:00
"github.com/PuerkitoBio/goquery"
2024-01-12 05:50:29 -05:00
gouuid "github.com/google/uuid"
2023-06-27 08:00:15 -05:00
"github.com/markbates/goth"
"github.com/markbates/goth/gothic"
2024-02-25 05:32:59 -05:00
goth_gitlab "github.com/markbates/goth/providers/github"
goth_github "github.com/markbates/goth/providers/gitlab"
2023-10-01 05:58:58 -05:00
"github.com/santhosh-tekuri/jsonschema/v5"
2017-04-28 08:23:28 -05:00
"github.com/stretchr/testify/assert"
2017-04-25 02:24:51 -05:00
)
2023-08-12 11:30:16 -05:00
var testWebRoutes * web . Route
2017-04-25 02:24:51 -05:00
2019-02-12 10:09:43 -05:00
type NilResponseRecorder struct {
httptest . ResponseRecorder
Length int
}
func ( n * NilResponseRecorder ) Write ( b [ ] byte ) ( int , error ) {
2019-06-12 14:41:28 -05:00
n . Length += len ( b )
2019-02-12 10:09:43 -05:00
return len ( b ) , nil
}
// NewRecorder returns an initialized ResponseRecorder.
func NewNilResponseRecorder ( ) * NilResponseRecorder {
return & NilResponseRecorder {
ResponseRecorder : * httptest . NewRecorder ( ) ,
}
}
2021-04-06 11:44:02 -05:00
type NilResponseHashSumRecorder struct {
httptest . ResponseRecorder
Hash hash . Hash
Length int
}
func ( n * NilResponseHashSumRecorder ) Write ( b [ ] byte ) ( int , error ) {
_ , _ = n . Hash . Write ( b )
n . Length += len ( b )
return len ( b ) , nil
}
// NewRecorder returns an initialized ResponseRecorder.
func NewNilResponseHashSumRecorder ( ) * NilResponseHashSumRecorder {
return & NilResponseHashSumRecorder {
Hash : fnv . New32 ( ) ,
ResponseRecorder : * httptest . NewRecorder ( ) ,
}
}
2024-03-27 16:02:51 -05:00
// runMainApp runs the subcommand and returns its standard output. Any returned error will usually be of type *ExitError. If c.Stderr was nil, Output populates ExitError.Stderr.
func runMainApp ( subcommand string , args ... string ) ( string , error ) {
return runMainAppWithStdin ( nil , subcommand , args ... )
}
// runMainAppWithStdin runs the subcommand and returns its standard output. Any returned error will usually be of type *ExitError. If c.Stderr was nil, Output populates ExitError.Stderr.
func runMainAppWithStdin ( stdin io . Reader , subcommand string , args ... string ) ( string , error ) {
// running the main app directly will very likely mess with the testing setup (logger & co.)
// hence we run it as a subprocess and capture its output
args = append ( [ ] string { subcommand } , args ... )
cmd := exec . Command ( os . Args [ 0 ] , args ... )
cmd . Env = append ( os . Environ ( ) ,
"GITEA_TEST_CLI=true" ,
"GITEA_CONF=" + setting . CustomConf ,
"GITEA_WORK_DIR=" + setting . AppWorkPath )
cmd . Stdin = stdin
out , err := cmd . Output ( )
return string ( out ) , err
}
2017-04-25 02:24:51 -05:00
func TestMain ( m * testing . M ) {
2024-03-27 16:02:51 -05:00
// GITEA_TEST_CLI is set by runMainAppWithStdin
// inspired by https://abhinavg.net/2022/05/15/hijack-testmain/
if testCLI := os . Getenv ( "GITEA_TEST_CLI" ) ; testCLI == "true" {
app := cmd . NewMainApp ( "test-version" , "integration-test" )
args := append ( [ ] string {
"executable-name" , // unused, but expected at position 1
"--config" , os . Getenv ( "GITEA_CONF" ) ,
} ,
os . Args [ 1 : ] ... , // skip the executable name
)
if err := cmd . RunMainApp ( app , args ... ) ; err != nil {
panic ( err ) // should never happen since RunMainApp exits on error
}
return
}
Rewrite logger system (#24726)
## ⚠️ Breaking
The `log.<mode>.<logger>` style config has been dropped. If you used it,
please check the new config manual & app.example.ini to make your
instance output logs as expected.
Although many legacy options still work, it's encouraged to upgrade to
the new options.
The SMTP logger is deleted because SMTP is not suitable to collect logs.
If you have manually configured Gitea log options, please confirm the
logger system works as expected after upgrading.
## Description
Close #12082 and maybe more log-related issues, resolve some related
FIXMEs in old code (which seems unfixable before)
Just like rewriting queue #24505 : make code maintainable, clear legacy
bugs, and add the ability to support more writers (eg: JSON, structured
log)
There is a new document (with examples): `logging-config.en-us.md`
This PR is safer than the queue rewriting, because it's just for
logging, it won't break other logic.
## The old problems
The logging system is quite old and difficult to maintain:
* Unclear concepts: Logger, NamedLogger, MultiChannelledLogger,
SubLogger, EventLogger, WriterLogger etc
* Some code is diffuclt to konw whether it is right:
`log.DelNamedLogger("console")` vs `log.DelNamedLogger(log.DEFAULT)` vs
`log.DelLogger("console")`
* The old system heavily depends on ini config system, it's difficult to
create new logger for different purpose, and it's very fragile.
* The "color" trick is difficult to use and read, many colors are
unnecessary, and in the future structured log could help
* It's difficult to add other log formats, eg: JSON format
* The log outputer doesn't have full control of its goroutine, it's
difficult to make outputer have advanced behaviors
* The logs could be lost in some cases: eg: no Fatal error when using
CLI.
* Config options are passed by JSON, which is quite fragile.
* INI package makes the KEY in `[log]` section visible in `[log.sub1]`
and `[log.sub1.subA]`, this behavior is quite fragile and would cause
more unclear problems, and there is no strong requirement to support
`log.<mode>.<logger>` syntax.
## The new design
See `logger.go` for documents.
## Screenshot
<details>
</details>
## TODO
* [x] add some new tests
* [x] fix some tests
* [x] test some sub-commands (manually ....)
---------
Co-authored-by: Jason Song <i@wolfogre.com>
Co-authored-by: delvh <dev.lh@web.de>
Co-authored-by: Giteabot <teabot@gitea.io>
2023-05-21 17:35:11 -05:00
defer log . GetManager ( ) . Close ( )
2020-10-31 15:51:48 -05:00
2019-12-15 04:51:28 -05:00
managerCtx , cancel := context . WithCancel ( context . Background ( ) )
graceful . InitManager ( managerCtx )
defer cancel ( )
2022-09-02 14:18:23 -05:00
tests . InitTest ( true )
2023-08-12 11:30:16 -05:00
testWebRoutes = routers . NormalRoutes ( )
2017-04-25 02:24:51 -05:00
2020-06-01 20:39:44 -05:00
// integration test settings...
2023-02-19 11:12:01 -05:00
if setting . CfgProvider != nil {
testingCfg := setting . CfgProvider . Section ( "integration-tests" )
Rewrite queue (#24505)
# ⚠️ Breaking
Many deprecated queue config options are removed (actually, they should
have been removed in 1.18/1.19).
If you see the fatal message when starting Gitea: "Please update your
app.ini to remove deprecated config options", please follow the error
messages to remove these options from your app.ini.
Example:
```
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].ISSUE_INDEXER_QUEUE_TYPE`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].UPDATE_BUFFER_LEN`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [F] Please update your app.ini to remove deprecated config options
```
Many options in `[queue]` are are dropped, including:
`WRAP_IF_NECESSARY`, `MAX_ATTEMPTS`, `TIMEOUT`, `WORKERS`,
`BLOCK_TIMEOUT`, `BOOST_TIMEOUT`, `BOOST_WORKERS`, they can be removed
from app.ini.
# The problem
The old queue package has some legacy problems:
* complexity: I doubt few people could tell how it works.
* maintainability: Too many channels and mutex/cond are mixed together,
too many different structs/interfaces depends each other.
* stability: due to the complexity & maintainability, sometimes there
are strange bugs and difficult to debug, and some code doesn't have test
(indeed some code is difficult to test because a lot of things are mixed
together).
* general applicability: although it is called "queue", its behavior is
not a well-known queue.
* scalability: it doesn't seem easy to make it work with a cluster
without breaking its behaviors.
It came from some very old code to "avoid breaking", however, its
technical debt is too heavy now. It's a good time to introduce a better
"queue" package.
# The new queue package
It keeps using old config and concept as much as possible.
* It only contains two major kinds of concepts:
* The "base queue": channel, levelqueue, redis
* They have the same abstraction, the same interface, and they are
tested by the same testing code.
* The "WokerPoolQueue", it uses the "base queue" to provide "worker
pool" function, calls the "handler" to process the data in the base
queue.
* The new code doesn't do "PushBack"
* Think about a queue with many workers, the "PushBack" can't guarantee
the order for re-queued unhandled items, so in new code it just does
"normal push"
* The new code doesn't do "pause/resume"
* The "pause/resume" was designed to handle some handler's failure: eg:
document indexer (elasticsearch) is down
* If a queue is paused for long time, either the producers blocks or the
new items are dropped.
* The new code doesn't do such "pause/resume" trick, it's not a common
queue's behavior and it doesn't help much.
* If there are unhandled items, the "push" function just blocks for a
few seconds and then re-queue them and retry.
* The new code doesn't do "worker booster"
* Gitea's queue's handlers are light functions, the cost is only the
go-routine, so it doesn't make sense to "boost" them.
* The new code only use "max worker number" to limit the concurrent
workers.
* The new "Push" never blocks forever
* Instead of creating more and more blocking goroutines, return an error
is more friendly to the server and to the end user.
There are more details in code comments: eg: the "Flush" problem, the
strange "code.index" hanging problem, the "immediate" queue problem.
Almost ready for review.
TODO:
* [x] add some necessary comments during review
* [x] add some more tests if necessary
* [x] update documents and config options
* [x] test max worker / active worker
* [x] re-run the CI tasks to see whether any test is flaky
* [x] improve the `handleOldLengthConfiguration` to provide more
friendly messages
* [x] fine tune default config values (eg: length?)
## Code coverage:
2023-05-08 06:49:59 -05:00
testlogger . SlowTest = testingCfg . Key ( "SLOW_TEST" ) . MustDuration ( testlogger . SlowTest )
testlogger . SlowFlush = testingCfg . Key ( "SLOW_FLUSH" ) . MustDuration ( testlogger . SlowFlush )
2020-06-01 20:39:44 -05:00
}
if os . Getenv ( "GITEA_SLOW_TEST_TIME" ) != "" {
duration , err := time . ParseDuration ( os . Getenv ( "GITEA_SLOW_TEST_TIME" ) )
if err == nil {
Rewrite queue (#24505)
# ⚠️ Breaking
Many deprecated queue config options are removed (actually, they should
have been removed in 1.18/1.19).
If you see the fatal message when starting Gitea: "Please update your
app.ini to remove deprecated config options", please follow the error
messages to remove these options from your app.ini.
Example:
```
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].ISSUE_INDEXER_QUEUE_TYPE`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].UPDATE_BUFFER_LEN`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [F] Please update your app.ini to remove deprecated config options
```
Many options in `[queue]` are are dropped, including:
`WRAP_IF_NECESSARY`, `MAX_ATTEMPTS`, `TIMEOUT`, `WORKERS`,
`BLOCK_TIMEOUT`, `BOOST_TIMEOUT`, `BOOST_WORKERS`, they can be removed
from app.ini.
# The problem
The old queue package has some legacy problems:
* complexity: I doubt few people could tell how it works.
* maintainability: Too many channels and mutex/cond are mixed together,
too many different structs/interfaces depends each other.
* stability: due to the complexity & maintainability, sometimes there
are strange bugs and difficult to debug, and some code doesn't have test
(indeed some code is difficult to test because a lot of things are mixed
together).
* general applicability: although it is called "queue", its behavior is
not a well-known queue.
* scalability: it doesn't seem easy to make it work with a cluster
without breaking its behaviors.
It came from some very old code to "avoid breaking", however, its
technical debt is too heavy now. It's a good time to introduce a better
"queue" package.
# The new queue package
It keeps using old config and concept as much as possible.
* It only contains two major kinds of concepts:
* The "base queue": channel, levelqueue, redis
* They have the same abstraction, the same interface, and they are
tested by the same testing code.
* The "WokerPoolQueue", it uses the "base queue" to provide "worker
pool" function, calls the "handler" to process the data in the base
queue.
* The new code doesn't do "PushBack"
* Think about a queue with many workers, the "PushBack" can't guarantee
the order for re-queued unhandled items, so in new code it just does
"normal push"
* The new code doesn't do "pause/resume"
* The "pause/resume" was designed to handle some handler's failure: eg:
document indexer (elasticsearch) is down
* If a queue is paused for long time, either the producers blocks or the
new items are dropped.
* The new code doesn't do such "pause/resume" trick, it's not a common
queue's behavior and it doesn't help much.
* If there are unhandled items, the "push" function just blocks for a
few seconds and then re-queue them and retry.
* The new code doesn't do "worker booster"
* Gitea's queue's handlers are light functions, the cost is only the
go-routine, so it doesn't make sense to "boost" them.
* The new code only use "max worker number" to limit the concurrent
workers.
* The new "Push" never blocks forever
* Instead of creating more and more blocking goroutines, return an error
is more friendly to the server and to the end user.
There are more details in code comments: eg: the "Flush" problem, the
strange "code.index" hanging problem, the "immediate" queue problem.
Almost ready for review.
TODO:
* [x] add some necessary comments during review
* [x] add some more tests if necessary
* [x] update documents and config options
* [x] test max worker / active worker
* [x] re-run the CI tasks to see whether any test is flaky
* [x] improve the `handleOldLengthConfiguration` to provide more
friendly messages
* [x] fine tune default config values (eg: length?)
## Code coverage:
2023-05-08 06:49:59 -05:00
testlogger . SlowTest = duration
2020-06-01 20:39:44 -05:00
}
}
if os . Getenv ( "GITEA_SLOW_FLUSH_TIME" ) != "" {
duration , err := time . ParseDuration ( os . Getenv ( "GITEA_SLOW_FLUSH_TIME" ) )
if err == nil {
Rewrite queue (#24505)
# ⚠️ Breaking
Many deprecated queue config options are removed (actually, they should
have been removed in 1.18/1.19).
If you see the fatal message when starting Gitea: "Please update your
app.ini to remove deprecated config options", please follow the error
messages to remove these options from your app.ini.
Example:
```
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].ISSUE_INDEXER_QUEUE_TYPE`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [E] Removed queue option: `[indexer].UPDATE_BUFFER_LEN`. Use new options in `[queue.issue_indexer]`
2023/05/06 19:39:22 [F] Please update your app.ini to remove deprecated config options
```
Many options in `[queue]` are are dropped, including:
`WRAP_IF_NECESSARY`, `MAX_ATTEMPTS`, `TIMEOUT`, `WORKERS`,
`BLOCK_TIMEOUT`, `BOOST_TIMEOUT`, `BOOST_WORKERS`, they can be removed
from app.ini.
# The problem
The old queue package has some legacy problems:
* complexity: I doubt few people could tell how it works.
* maintainability: Too many channels and mutex/cond are mixed together,
too many different structs/interfaces depends each other.
* stability: due to the complexity & maintainability, sometimes there
are strange bugs and difficult to debug, and some code doesn't have test
(indeed some code is difficult to test because a lot of things are mixed
together).
* general applicability: although it is called "queue", its behavior is
not a well-known queue.
* scalability: it doesn't seem easy to make it work with a cluster
without breaking its behaviors.
It came from some very old code to "avoid breaking", however, its
technical debt is too heavy now. It's a good time to introduce a better
"queue" package.
# The new queue package
It keeps using old config and concept as much as possible.
* It only contains two major kinds of concepts:
* The "base queue": channel, levelqueue, redis
* They have the same abstraction, the same interface, and they are
tested by the same testing code.
* The "WokerPoolQueue", it uses the "base queue" to provide "worker
pool" function, calls the "handler" to process the data in the base
queue.
* The new code doesn't do "PushBack"
* Think about a queue with many workers, the "PushBack" can't guarantee
the order for re-queued unhandled items, so in new code it just does
"normal push"
* The new code doesn't do "pause/resume"
* The "pause/resume" was designed to handle some handler's failure: eg:
document indexer (elasticsearch) is down
* If a queue is paused for long time, either the producers blocks or the
new items are dropped.
* The new code doesn't do such "pause/resume" trick, it's not a common
queue's behavior and it doesn't help much.
* If there are unhandled items, the "push" function just blocks for a
few seconds and then re-queue them and retry.
* The new code doesn't do "worker booster"
* Gitea's queue's handlers are light functions, the cost is only the
go-routine, so it doesn't make sense to "boost" them.
* The new code only use "max worker number" to limit the concurrent
workers.
* The new "Push" never blocks forever
* Instead of creating more and more blocking goroutines, return an error
is more friendly to the server and to the end user.
There are more details in code comments: eg: the "Flush" problem, the
strange "code.index" hanging problem, the "immediate" queue problem.
Almost ready for review.
TODO:
* [x] add some necessary comments during review
* [x] add some more tests if necessary
* [x] update documents and config options
* [x] test max worker / active worker
* [x] re-run the CI tasks to see whether any test is flaky
* [x] improve the `handleOldLengthConfiguration` to provide more
friendly messages
* [x] fine tune default config values (eg: length?)
## Code coverage:
2023-05-08 06:49:59 -05:00
testlogger . SlowFlush = duration
2020-06-01 20:39:44 -05:00
}
}
2022-04-26 15:28:45 -05:00
os . Unsetenv ( "GIT_AUTHOR_NAME" )
os . Unsetenv ( "GIT_AUTHOR_EMAIL" )
os . Unsetenv ( "GIT_AUTHOR_DATE" )
os . Unsetenv ( "GIT_COMMITTER_NAME" )
os . Unsetenv ( "GIT_COMMITTER_EMAIL" )
os . Unsetenv ( "GIT_COMMITTER_DATE" )
2021-11-12 09:36:47 -05:00
err := unittest . InitFixtures (
unittest . FixturesOptions {
2021-09-24 06:32:56 -05:00
Dir : filepath . Join ( filepath . Dir ( setting . AppPath ) , "models/fixtures/" ) ,
} ,
2017-04-25 02:24:51 -05:00
)
if err != nil {
fmt . Printf ( "Error initializing test database: %v\n" , err )
os . Exit ( 1 )
}
2023-04-19 08:40:42 -05:00
// FIXME: the console logger is deleted by mistake, so if there is any `log.Fatal`, developers won't see any error message.
// Instead, "No tests were found", last nonsense log is "According to the configuration, subsequent logs will not be printed to the console"
2017-09-16 15:16:21 -05:00
exitCode := m . Run ( )
2024-03-14 08:45:41 -05:00
if err := testlogger . WriterCloser . Reset ( ) ; err != nil {
2024-04-11 00:36:59 -05:00
fmt . Printf ( "testlogger.WriterCloser.Reset: error ignored: %v\n" , err )
2024-03-14 08:45:41 -05:00
}
2019-04-11 06:49:49 -05:00
2020-08-11 15:05:34 -05:00
if err = util . RemoveAll ( setting . Indexer . IssuePath ) ; err != nil {
fmt . Printf ( "util.RemoveAll: %v\n" , err )
2017-09-16 15:16:21 -05:00
os . Exit ( 1 )
}
2020-08-11 15:05:34 -05:00
if err = util . RemoveAll ( setting . Indexer . RepoPath ) ; err != nil {
2017-10-27 01:10:54 -05:00
fmt . Printf ( "Unable to remove repo indexer: %v\n" , err )
os . Exit ( 1 )
}
2017-09-16 15:16:21 -05:00
os . Exit ( exitCode )
2017-04-25 02:24:51 -05:00
}
2017-05-01 19:49:55 -05:00
type TestSession struct {
jar http . CookieJar
}
func ( s * TestSession ) GetCookie ( name string ) * http . Cookie {
baseURL , err := url . Parse ( setting . AppURL )
if err != nil {
return nil
}
for _ , c := range s . jar . Cookies ( baseURL ) {
if c . Name == name {
return c
}
}
return nil
}
2024-03-19 08:47:48 -05:00
func ( s * TestSession ) SetCookie ( cookie * http . Cookie ) * http . Cookie {
baseURL , err := url . Parse ( setting . AppURL )
if err != nil {
return nil
}
s . jar . SetCookies ( baseURL , [ ] * http . Cookie { cookie } )
return nil
}
2023-12-21 18:59:59 -05:00
func ( s * TestSession ) MakeRequest ( t testing . TB , rw * RequestWrapper , expectedStatus int ) * httptest . ResponseRecorder {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
req := rw . Request
2017-05-01 19:49:55 -05:00
baseURL , err := url . Parse ( setting . AppURL )
assert . NoError ( t , err )
for _ , c := range s . jar . Cookies ( baseURL ) {
req . AddCookie ( c )
}
2023-12-21 18:59:59 -05:00
resp := MakeRequest ( t , rw , expectedStatus )
2017-05-01 19:49:55 -05:00
ch := http . Header { }
2019-06-12 14:41:28 -05:00
ch . Add ( "Cookie" , strings . Join ( resp . Header ( ) [ "Set-Cookie" ] , ";" ) )
2017-05-01 19:49:55 -05:00
cr := http . Request { Header : ch }
s . jar . SetCookies ( baseURL , cr . Cookies ( ) )
return resp
}
2023-12-21 18:59:59 -05:00
func ( s * TestSession ) MakeRequestNilResponseRecorder ( t testing . TB , rw * RequestWrapper , expectedStatus int ) * NilResponseRecorder {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
req := rw . Request
2019-02-12 10:09:43 -05:00
baseURL , err := url . Parse ( setting . AppURL )
assert . NoError ( t , err )
for _ , c := range s . jar . Cookies ( baseURL ) {
req . AddCookie ( c )
}
2023-12-21 18:59:59 -05:00
resp := MakeRequestNilResponseRecorder ( t , rw , expectedStatus )
2019-02-12 10:09:43 -05:00
ch := http . Header { }
2019-06-12 14:41:28 -05:00
ch . Add ( "Cookie" , strings . Join ( resp . Header ( ) [ "Set-Cookie" ] , ";" ) )
2019-02-12 10:09:43 -05:00
cr := http . Request { Header : ch }
s . jar . SetCookies ( baseURL , cr . Cookies ( ) )
return resp
}
2023-12-21 18:59:59 -05:00
func ( s * TestSession ) MakeRequestNilResponseHashSumRecorder ( t testing . TB , rw * RequestWrapper , expectedStatus int ) * NilResponseHashSumRecorder {
2021-04-06 11:44:02 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
req := rw . Request
2021-04-06 11:44:02 -05:00
baseURL , err := url . Parse ( setting . AppURL )
assert . NoError ( t , err )
for _ , c := range s . jar . Cookies ( baseURL ) {
req . AddCookie ( c )
}
2023-12-21 18:59:59 -05:00
resp := MakeRequestNilResponseHashSumRecorder ( t , rw , expectedStatus )
2021-04-06 11:44:02 -05:00
ch := http . Header { }
ch . Add ( "Cookie" , strings . Join ( resp . Header ( ) [ "Set-Cookie" ] , ";" ) )
cr := http . Request { Header : ch }
s . jar . SetCookies ( baseURL , cr . Cookies ( ) )
return resp
}
2017-06-16 23:49:45 -05:00
const userPassword = "password"
2017-08-23 02:30:33 -05:00
func emptyTestSession ( t testing . TB ) * TestSession {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2017-08-23 02:30:33 -05:00
jar , err := cookiejar . New ( nil )
assert . NoError ( t , err )
return & TestSession { jar : jar }
}
2023-01-17 16:46:03 -05:00
func getUserToken ( t testing . TB , userName string , scope ... auth . AccessTokenScope ) string {
return getTokenForLoggedInUser ( t , loginUser ( t , userName ) , scope ... )
2022-04-07 23:22:10 -05:00
}
2023-06-27 08:00:15 -05:00
func mockCompleteUserAuth ( mock func ( res http . ResponseWriter , req * http . Request ) ( goth . User , error ) ) func ( ) {
old := gothic . CompleteUserAuth
gothic . CompleteUserAuth = mock
return func ( ) {
gothic . CompleteUserAuth = old
}
}
2023-06-05 04:29:07 -05:00
func addAuthSource ( t * testing . T , payload map [ string ] string ) * auth . Source {
session := loginUser ( t , "user1" )
payload [ "_csrf" ] = GetCSRF ( t , session , "/admin/auths/new" )
req := NewRequestWithValues ( t , "POST" , "/admin/auths/new" , payload )
session . MakeRequest ( t , req , http . StatusSeeOther )
source , err := auth . GetSourceByName ( context . Background ( ) , payload [ "name" ] )
assert . NoError ( t , err )
return source
}
func authSourcePayloadOAuth2 ( name string ) map [ string ] string {
return map [ string ] string {
"type" : fmt . Sprintf ( "%d" , auth . OAuth2 ) ,
"name" : name ,
"is_active" : "on" ,
}
}
func authSourcePayloadGitLab ( name string ) map [ string ] string {
payload := authSourcePayloadOAuth2 ( name )
payload [ "oauth2_provider" ] = "gitlab"
return payload
}
func authSourcePayloadGitLabCustom ( name string ) map [ string ] string {
payload := authSourcePayloadGitLab ( name )
payload [ "oauth2_use_custom_url" ] = "on"
payload [ "oauth2_auth_url" ] = goth_gitlab . AuthURL
payload [ "oauth2_token_url" ] = goth_gitlab . TokenURL
payload [ "oauth2_profile_url" ] = goth_gitlab . ProfileURL
return payload
}
2024-02-25 05:32:59 -05:00
func authSourcePayloadGitHub ( name string ) map [ string ] string {
payload := authSourcePayloadOAuth2 ( name )
payload [ "oauth2_provider" ] = "github"
return payload
}
func authSourcePayloadGitHubCustom ( name string ) map [ string ] string {
payload := authSourcePayloadGitHub ( name )
payload [ "oauth2_use_custom_url" ] = "on"
payload [ "oauth2_auth_url" ] = goth_github . AuthURL
payload [ "oauth2_token_url" ] = goth_github . TokenURL
payload [ "oauth2_profile_url" ] = goth_github . ProfileURL
return payload
}
func createRemoteAuthSource ( t * testing . T , name , url , matchingSource string ) * auth . Source {
assert . NoError ( t , auth . CreateSource ( context . Background ( ) , & auth . Source {
Type : auth . Remote ,
Name : name ,
IsActive : true ,
Cfg : & remote . Source {
URL : url ,
MatchingSource : matchingSource ,
} ,
} ) )
source , err := auth . GetSourceByName ( context . Background ( ) , name )
assert . NoError ( t , err )
return source
}
2023-06-05 04:43:31 -05:00
func createUser ( ctx context . Context , t testing . TB , user * user_model . User ) func ( ) {
user . MustChangePassword = false
user . LowerName = strings . ToLower ( user . Name )
assert . NoError ( t , db . Insert ( ctx , user ) )
if len ( user . Email ) > 0 {
2024-02-05 09:06:51 -05:00
assert . NoError ( t , user_service . ReplacePrimaryEmailAddress ( ctx , user , user . Email ) )
2023-06-05 04:43:31 -05:00
}
return func ( ) {
assert . NoError ( t , user_service . DeleteUser ( ctx , user , true ) )
}
}
2017-06-17 10:01:03 -05:00
func loginUser ( t testing . TB , userName string ) * TestSession {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2022-12-22 08:09:35 -05:00
return loginUserWithPassword ( t , userName , userPassword )
2017-06-16 23:49:45 -05:00
}
2017-06-17 10:01:03 -05:00
func loginUserWithPassword ( t testing . TB , userName , password string ) * TestSession {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2023-11-22 11:26:21 -05:00
return loginUserWithPasswordRemember ( t , userName , password , false )
}
func loginUserWithPasswordRemember ( t testing . TB , userName , password string , rememberMe bool ) * TestSession {
t . Helper ( )
2017-06-09 19:41:36 -05:00
req := NewRequest ( t , "GET" , "/user/login" )
2017-07-07 14:36:47 -05:00
resp := MakeRequest ( t , req , http . StatusOK )
2017-05-01 19:49:55 -05:00
2017-06-17 11:29:59 -05:00
doc := NewHTMLParser ( t , resp . Body )
2017-06-16 23:49:45 -05:00
req = NewRequestWithValues ( t , "POST" , "/user/login" , map [ string ] string {
"_csrf" : doc . GetCSRF ( ) ,
"user_name" : userName ,
"password" : password ,
2023-11-22 11:26:21 -05:00
"remember" : strconv . FormatBool ( rememberMe ) ,
2017-06-16 23:49:45 -05:00
} )
2022-03-22 23:54:07 -05:00
resp = MakeRequest ( t , req , http . StatusSeeOther )
2017-05-01 19:49:55 -05:00
ch := http . Header { }
2019-06-12 14:41:28 -05:00
ch . Add ( "Cookie" , strings . Join ( resp . Header ( ) [ "Set-Cookie" ] , ";" ) )
2017-05-01 19:49:55 -05:00
cr := http . Request { Header : ch }
2017-08-23 02:30:33 -05:00
session := emptyTestSession ( t )
2017-05-01 19:49:55 -05:00
baseURL , err := url . Parse ( setting . AppURL )
assert . NoError ( t , err )
2017-08-23 02:30:33 -05:00
session . jar . SetCookies ( baseURL , cr . Cookies ( ) )
2017-05-01 19:49:55 -05:00
2017-08-23 02:30:33 -05:00
return session
2017-05-01 19:49:55 -05:00
}
2022-01-20 12:46:10 -05:00
// token has to be unique this counter take care of
2020-04-13 14:02:48 -05:00
var tokenCounter int64
2023-01-17 16:46:03 -05:00
// getTokenForLoggedInUser returns a token for a logged in user.
// The scope is an optional list of snake_case strings like the frontend form fields,
// but without the "scope_" prefix.
func getTokenForLoggedInUser ( t testing . TB , session * TestSession , scopes ... auth . AccessTokenScope ) string {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2022-12-20 20:46:16 -05:00
var token string
2018-09-10 11:15:52 -05:00
req := NewRequest ( t , "GET" , "/user/settings/applications" )
resp := session . MakeRequest ( t , req , http . StatusOK )
2022-12-20 20:46:16 -05:00
var csrf string
for _ , cookie := range resp . Result ( ) . Cookies ( ) {
if cookie . Name != "_csrf" {
continue
}
csrf = cookie . Value
break
}
if csrf == "" {
doc := NewHTMLParser ( t , resp . Body )
csrf = doc . GetCSRF ( )
}
assert . NotEmpty ( t , csrf )
2023-01-17 16:46:03 -05:00
urlValues := url . Values { }
urlValues . Add ( "_csrf" , csrf )
urlValues . Add ( "name" , fmt . Sprintf ( "api-testing-token-%d" , atomic . AddInt64 ( & tokenCounter , 1 ) ) )
for _ , scope := range scopes {
urlValues . Add ( "scope" , string ( scope ) )
}
req = NewRequestWithURLValues ( t , "POST" , "/user/settings/applications" , urlValues )
2022-12-20 20:46:16 -05:00
resp = session . MakeRequest ( t , req , http . StatusSeeOther )
// Log the flash values on failure
if ! assert . Equal ( t , resp . Result ( ) . Header [ "Location" ] , [ ] string { "/user/settings/applications" } ) {
for _ , cookie := range resp . Result ( ) . Cookies ( ) {
2023-04-13 14:45:33 -05:00
if cookie . Name != gitea_context . CookieNameFlash {
2022-12-20 20:46:16 -05:00
continue
}
flash , _ := url . ParseQuery ( cookie . Value )
for key , value := range flash {
t . Logf ( "Flash %q: %q" , key , value )
}
}
}
2018-09-10 11:15:52 -05:00
req = NewRequest ( t , "GET" , "/user/settings/applications" )
resp = session . MakeRequest ( t , req , http . StatusOK )
htmlDoc := NewHTMLParser ( t , resp . Body )
2022-12-20 20:46:16 -05:00
token = htmlDoc . doc . Find ( ".ui.info p" ) . Text ( )
2022-10-20 13:20:01 -05:00
assert . NotEmpty ( t , token )
2018-09-10 11:15:52 -05:00
return token
}
2023-12-21 18:59:59 -05:00
type RequestWrapper struct {
* http . Request
}
func ( req * RequestWrapper ) AddBasicAuth ( username string ) * RequestWrapper {
req . Request . SetBasicAuth ( username , userPassword )
return req
}
func ( req * RequestWrapper ) AddTokenAuth ( token string ) * RequestWrapper {
if token == "" {
return req
}
if ! strings . HasPrefix ( token , "Bearer " ) {
token = "Bearer " + token
}
req . Request . Header . Set ( "Authorization" , token )
return req
}
func ( req * RequestWrapper ) SetHeader ( name , value string ) * RequestWrapper {
req . Request . Header . Set ( name , value )
return req
}
func NewRequest ( t testing . TB , method , urlStr string ) * RequestWrapper {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2017-06-16 23:49:45 -05:00
return NewRequestWithBody ( t , method , urlStr , nil )
}
2023-12-21 18:59:59 -05:00
func NewRequestf ( t testing . TB , method , urlFormat string , args ... any ) * RequestWrapper {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2017-06-24 19:15:42 -05:00
return NewRequest ( t , method , fmt . Sprintf ( urlFormat , args ... ) )
}
2023-12-21 18:59:59 -05:00
func NewRequestWithValues ( t testing . TB , method , urlStr string , values map [ string ] string ) * RequestWrapper {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2017-06-16 23:49:45 -05:00
urlValues := url . Values { }
for key , value := range values {
urlValues [ key ] = [ ] string { value }
}
2023-01-17 16:46:03 -05:00
return NewRequestWithURLValues ( t , method , urlStr , urlValues )
}
2023-12-21 18:59:59 -05:00
func NewRequestWithURLValues ( t testing . TB , method , urlStr string , urlValues url . Values ) * RequestWrapper {
2023-01-17 16:46:03 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
return NewRequestWithBody ( t , method , urlStr , bytes . NewBufferString ( urlValues . Encode ( ) ) ) .
SetHeader ( "Content-Type" , "application/x-www-form-urlencoded" )
2017-06-16 23:49:45 -05:00
}
2023-12-21 18:59:59 -05:00
func NewRequestWithJSON ( t testing . TB , method , urlStr string , v any ) * RequestWrapper {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2021-03-01 16:08:10 -05:00
2017-06-16 23:49:45 -05:00
jsonBytes , err := json . Marshal ( v )
assert . NoError ( t , err )
2023-12-21 18:59:59 -05:00
return NewRequestWithBody ( t , method , urlStr , bytes . NewBuffer ( jsonBytes ) ) .
SetHeader ( "Content-Type" , "application/json" )
2017-06-09 19:41:36 -05:00
}
2023-12-21 18:59:59 -05:00
func NewRequestWithBody ( t testing . TB , method , urlStr string , body io . Reader ) * RequestWrapper {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2021-01-26 10:36:53 -05:00
if ! strings . HasPrefix ( urlStr , "http" ) && ! strings . HasPrefix ( urlStr , "/" ) {
urlStr = "/" + urlStr
}
2023-12-21 18:59:59 -05:00
req , err := http . NewRequest ( method , urlStr , body )
2017-06-09 19:41:36 -05:00
assert . NoError ( t , err )
2023-12-21 18:59:59 -05:00
req . RequestURI = urlStr
2017-06-09 19:41:36 -05:00
2023-12-21 18:59:59 -05:00
return & RequestWrapper { req }
2018-07-06 20:54:30 -05:00
}
2017-07-07 14:36:47 -05:00
const NoExpectedStatus = - 1
2023-12-21 18:59:59 -05:00
func MakeRequest ( t testing . TB , rw * RequestWrapper , expectedStatus int ) * httptest . ResponseRecorder {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
req := rw . Request
2017-12-03 17:46:01 -05:00
recorder := httptest . NewRecorder ( )
2023-04-19 08:40:42 -05:00
if req . RemoteAddr == "" {
req . RemoteAddr = "test-mock:12345"
}
2023-08-12 11:30:16 -05:00
testWebRoutes . ServeHTTP ( recorder , req )
2017-07-07 14:36:47 -05:00
if expectedStatus != NoExpectedStatus {
2023-04-19 08:40:42 -05:00
if ! assert . EqualValues ( t , expectedStatus , recorder . Code , "Request: %s %s" , req . Method , req . URL . String ( ) ) {
2017-12-10 21:15:27 -05:00
logUnexpectedResponse ( t , recorder )
}
2017-07-07 14:36:47 -05:00
}
2017-12-03 17:46:01 -05:00
return recorder
2017-04-25 02:24:51 -05:00
}
2017-06-18 04:06:17 -05:00
2023-12-21 18:59:59 -05:00
func MakeRequestNilResponseRecorder ( t testing . TB , rw * RequestWrapper , expectedStatus int ) * NilResponseRecorder {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
req := rw . Request
2019-02-12 10:09:43 -05:00
recorder := NewNilResponseRecorder ( )
2023-08-12 11:30:16 -05:00
testWebRoutes . ServeHTTP ( recorder , req )
2019-02-12 10:09:43 -05:00
if expectedStatus != NoExpectedStatus {
2021-04-06 11:44:02 -05:00
if ! assert . EqualValues ( t , expectedStatus , recorder . Code ,
"Request: %s %s" , req . Method , req . URL . String ( ) ) {
logUnexpectedResponse ( t , & recorder . ResponseRecorder )
}
}
return recorder
}
2023-12-21 18:59:59 -05:00
func MakeRequestNilResponseHashSumRecorder ( t testing . TB , rw * RequestWrapper , expectedStatus int ) * NilResponseHashSumRecorder {
2021-04-06 11:44:02 -05:00
t . Helper ( )
2023-12-21 18:59:59 -05:00
req := rw . Request
2021-04-06 11:44:02 -05:00
recorder := NewNilResponseHashSumRecorder ( )
2023-08-12 11:30:16 -05:00
testWebRoutes . ServeHTTP ( recorder , req )
2021-04-06 11:44:02 -05:00
if expectedStatus != NoExpectedStatus {
2019-02-12 10:09:43 -05:00
if ! assert . EqualValues ( t , expectedStatus , recorder . Code ,
"Request: %s %s" , req . Method , req . URL . String ( ) ) {
logUnexpectedResponse ( t , & recorder . ResponseRecorder )
}
}
return recorder
}
2017-12-10 21:15:27 -05:00
// logUnexpectedResponse logs the contents of an unexpected response.
func logUnexpectedResponse ( t testing . TB , recorder * httptest . ResponseRecorder ) {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2017-12-10 21:15:27 -05:00
respBytes := recorder . Body . Bytes ( )
if len ( respBytes ) == 0 {
2024-02-02 04:18:42 -05:00
// log the content of the flash cookie
for _ , cookie := range recorder . Result ( ) . Cookies ( ) {
if cookie . Name != gitea_context . CookieNameFlash {
continue
}
flash , _ := url . ParseQuery ( cookie . Value )
for key , value := range flash {
// the key is itself url-encoded
if flash , err := url . ParseQuery ( key ) ; err == nil {
for key , value := range flash {
t . Logf ( "FlashCookie %q: %q" , key , value )
}
} else {
t . Logf ( "FlashCookie %q: %q" , key , value )
}
}
}
2017-12-10 21:15:27 -05:00
return
} else if len ( respBytes ) < 500 {
// if body is short, just log the whole thing
2023-04-19 08:40:42 -05:00
t . Log ( "Response: " , string ( respBytes ) )
2017-12-10 21:15:27 -05:00
return
}
2023-10-23 21:54:59 -05:00
t . Log ( "Response length: " , len ( respBytes ) )
2017-12-10 21:15:27 -05:00
// log the "flash" error message, if one exists
// we must create a new buffer, so that we don't "use up" resp.Body
htmlDoc , err := goquery . NewDocumentFromReader ( bytes . NewBuffer ( respBytes ) )
if err != nil {
return // probably a non-HTML response
}
errMsg := htmlDoc . Find ( ".ui.negative.message" ) . Text ( )
if len ( errMsg ) > 0 {
t . Log ( "A flash error message was found:" , errMsg )
}
}
2023-07-04 13:36:08 -05:00
func DecodeJSON ( t testing . TB , resp * httptest . ResponseRecorder , v any ) {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2021-03-01 16:08:10 -05:00
2017-12-03 17:46:01 -05:00
decoder := json . NewDecoder ( resp . Body )
2017-06-18 04:06:17 -05:00
assert . NoError ( t , decoder . Decode ( v ) )
}
2017-07-07 14:36:47 -05:00
2022-12-17 01:22:34 -05:00
func VerifyJSONSchema ( t testing . TB , resp * httptest . ResponseRecorder , schemaFile string ) {
t . Helper ( )
schemaFilePath := filepath . Join ( filepath . Dir ( setting . AppPath ) , "tests" , "integration" , "schemas" , schemaFile )
_ , schemaFileErr := os . Stat ( schemaFilePath )
assert . Nil ( t , schemaFileErr )
2023-10-01 05:58:58 -05:00
schema , err := jsonschema . Compile ( schemaFilePath )
assert . NoError ( t , err )
2024-04-14 07:36:40 -05:00
var data any
2023-10-01 05:58:58 -05:00
err = json . Unmarshal ( resp . Body . Bytes ( ) , & data )
assert . NoError ( t , err )
2022-12-17 01:22:34 -05:00
2023-10-01 05:58:58 -05:00
schemaValidation := schema . Validate ( data )
assert . Nil ( t , schemaValidation )
2022-12-17 01:22:34 -05:00
}
2017-07-07 14:36:47 -05:00
func GetCSRF ( t testing . TB , session * TestSession , urlStr string ) string {
2019-07-28 23:15:18 -05:00
t . Helper ( )
2017-07-07 14:36:47 -05:00
req := NewRequest ( t , "GET" , urlStr )
resp := session . MakeRequest ( t , req , http . StatusOK )
doc := NewHTMLParser ( t , resp . Body )
return doc . GetCSRF ( )
}
2023-08-18 04:21:24 -05:00
func GetHTMLTitle ( t testing . TB , session * TestSession , urlStr string ) string {
t . Helper ( )
req := NewRequest ( t , "GET" , urlStr )
var resp * httptest . ResponseRecorder
if session == nil {
resp = MakeRequest ( t , req , http . StatusOK )
} else {
resp = session . MakeRequest ( t , req , http . StatusOK )
}
doc := NewHTMLParser ( t , resp . Body )
return doc . Find ( "head title" ) . Text ( )
}
2024-01-12 05:50:29 -05:00
2024-04-24 16:33:08 -05:00
type DeclarativeRepoOptions struct {
Name optional . Option [ string ]
EnabledUnits optional . Option [ [ ] unit_model . Type ]
DisabledUnits optional . Option [ [ ] unit_model . Type ]
Files optional . Option [ [ ] * files_service . ChangeRepoFile ]
2024-04-24 17:08:53 -05:00
WikiBranch optional . Option [ string ]
2024-04-29 18:35:40 -05:00
AutoInit optional . Option [ bool ]
2024-04-24 16:33:08 -05:00
}
func CreateDeclarativeRepoWithOptions ( t * testing . T , owner * user_model . User , opts DeclarativeRepoOptions ) ( * repo_model . Repository , string , func ( ) ) {
2024-01-12 05:50:29 -05:00
t . Helper ( )
2024-04-24 16:33:08 -05:00
// Not using opts.Name.ValueOrDefault() here to avoid unnecessarily
// generating an UUID when a name is specified.
var repoName string
if opts . Name . Has ( ) {
repoName = opts . Name . Value ( )
} else {
2024-01-12 05:50:29 -05:00
repoName = gouuid . NewString ( )
}
2024-04-29 18:35:40 -05:00
var autoInit bool
if opts . AutoInit . Has ( ) {
autoInit = opts . AutoInit . Value ( )
} else {
autoInit = true
}
2024-04-24 16:33:08 -05:00
// Create the repository
2024-01-12 05:50:29 -05:00
repo , err := repo_service . CreateRepository ( db . DefaultContext , owner , owner , repo_service . CreateRepoOptions {
Name : repoName ,
Description : "Temporary Repo" ,
2024-04-29 18:35:40 -05:00
AutoInit : autoInit ,
2024-01-12 05:50:29 -05:00
Gitignores : "" ,
License : "WTFPL" ,
Readme : "Default" ,
DefaultBranch : "main" ,
} )
assert . NoError ( t , err )
assert . NotEmpty ( t , repo )
2024-04-24 16:33:08 -05:00
// Populate `enabledUnits` if we have any enabled.
var enabledUnits [ ] repo_model . RepoUnit
if opts . EnabledUnits . Has ( ) {
units := opts . EnabledUnits . Value ( )
enabledUnits = make ( [ ] repo_model . RepoUnit , len ( units ) )
for i , unitType := range units {
enabledUnits [ i ] = repo_model . RepoUnit {
2024-01-12 05:50:29 -05:00
RepoID : repo . ID ,
Type : unitType ,
}
}
2024-04-24 16:33:08 -05:00
}
2024-01-12 05:50:29 -05:00
2024-04-24 16:33:08 -05:00
// Adjust the repo units according to our parameters.
if opts . EnabledUnits . Has ( ) || opts . DisabledUnits . Has ( ) {
err := repo_service . UpdateRepositoryUnits ( db . DefaultContext , repo , enabledUnits , opts . DisabledUnits . ValueOrDefault ( nil ) )
2024-01-12 05:50:29 -05:00
assert . NoError ( t , err )
}
2024-04-24 16:33:08 -05:00
// Add files, if any.
2024-01-12 05:50:29 -05:00
var sha string
2024-04-24 16:33:08 -05:00
if opts . Files . Has ( ) {
2024-04-29 18:35:40 -05:00
assert . True ( t , autoInit , "Files cannot be specified if AutoInit is disabled" )
2024-04-24 16:33:08 -05:00
files := opts . Files . Value ( )
2024-01-12 05:50:29 -05:00
resp , err := files_service . ChangeRepoFiles ( git . DefaultContext , repo , owner , & files_service . ChangeRepoFilesOptions {
Files : files ,
Message : "add files" ,
OldBranch : "main" ,
NewBranch : "main" ,
Author : & files_service . IdentityOptions {
Name : owner . Name ,
Email : owner . Email ,
} ,
Committer : & files_service . IdentityOptions {
Name : owner . Name ,
Email : owner . Email ,
} ,
Dates : & files_service . CommitDateOptions {
Author : time . Now ( ) ,
Committer : time . Now ( ) ,
} ,
} )
assert . NoError ( t , err )
assert . NotEmpty ( t , resp )
sha = resp . Commit . SHA
}
2024-04-24 17:08:53 -05:00
// If there's a Wiki branch specified, create a wiki, and a default wiki page.
if opts . WikiBranch . Has ( ) {
// Set the wiki branch in the database first
repo . WikiBranch = opts . WikiBranch . Value ( )
err := repo_model . UpdateRepositoryCols ( db . DefaultContext , repo , "wiki_branch" )
assert . NoError ( t , err )
// Initialize the wiki
err = wiki_service . InitWiki ( db . DefaultContext , repo )
assert . NoError ( t , err )
// Add a new wiki page
err = wiki_service . AddWikiPage ( db . DefaultContext , owner , repo , "Home" , "Welcome to the wiki!" , "Add a Home page" )
assert . NoError ( t , err )
}
2024-04-24 16:33:08 -05:00
// Return the repo, the top commit, and a defer-able function to delete the
// repo.
2024-01-12 05:50:29 -05:00
return repo , sha , func ( ) {
repo_service . DeleteRepository ( db . DefaultContext , owner , repo , false )
}
}
2024-04-24 16:33:08 -05:00
func CreateDeclarativeRepo ( t * testing . T , owner * user_model . User , name string , enabledUnits , disabledUnits [ ] unit_model . Type , files [ ] * files_service . ChangeRepoFile ) ( * repo_model . Repository , string , func ( ) ) {
t . Helper ( )
var opts DeclarativeRepoOptions
if name != "" {
opts . Name = optional . Some ( name )
}
if enabledUnits != nil {
opts . EnabledUnits = optional . Some ( enabledUnits )
}
if disabledUnits != nil {
opts . DisabledUnits = optional . Some ( disabledUnits )
}
if files != nil {
opts . Files = optional . Some ( files )
}
return CreateDeclarativeRepoWithOptions ( t , owner , opts )
}
