初始提交: Gitea 项目代码
This commit is contained in:
root
@@ -0,0 +1,105 @@
|
||||
// Copyright 2023 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"gitea.dev/modules/log"
|
||||
)
|
||||
|
||||
type LogChecker struct {
|
||||
*log.EventWriterBaseImpl
|
||||
|
||||
filterMessages []string
|
||||
filtered []bool
|
||||
|
||||
stopMark string
|
||||
stopped bool
|
||||
|
||||
mu sync.Mutex
|
||||
}
|
||||
|
||||
func (lc *LogChecker) Run(ctx context.Context) {
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case event, ok := <-lc.Queue:
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
lc.checkLogEvent(event)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (lc *LogChecker) checkLogEvent(event *log.EventFormatted) {
|
||||
lc.mu.Lock()
|
||||
defer lc.mu.Unlock()
|
||||
for i, msg := range lc.filterMessages {
|
||||
if strings.Contains(event.Origin.MsgSimpleText, msg) {
|
||||
lc.filtered[i] = true
|
||||
}
|
||||
}
|
||||
if strings.Contains(event.Origin.MsgSimpleText, lc.stopMark) {
|
||||
lc.stopped = true
|
||||
}
|
||||
}
|
||||
|
||||
var checkerIndex atomic.Int64
|
||||
|
||||
func NewLogChecker(namePrefix string) (logChecker *LogChecker, cancel func()) {
|
||||
logger := log.GetManager().GetLogger(namePrefix)
|
||||
newCheckerIndex := checkerIndex.Add(1)
|
||||
writerName := namePrefix + "-" + strconv.FormatInt(newCheckerIndex, 10)
|
||||
|
||||
lc := &LogChecker{}
|
||||
lc.EventWriterBaseImpl = log.NewEventWriterBase(writerName, "test-log-checker", log.WriterMode{})
|
||||
logger.AddWriters(lc)
|
||||
return lc, func() { _ = logger.RemoveWriter(writerName) }
|
||||
}
|
||||
|
||||
// Filter will make the `Check` function to check if these logs are outputted.
|
||||
func (lc *LogChecker) Filter(msgs ...string) *LogChecker {
|
||||
lc.mu.Lock()
|
||||
defer lc.mu.Unlock()
|
||||
lc.filterMessages = make([]string, len(msgs))
|
||||
copy(lc.filterMessages, msgs)
|
||||
lc.filtered = make([]bool, len(lc.filterMessages))
|
||||
return lc
|
||||
}
|
||||
|
||||
func (lc *LogChecker) StopMark(msg string) *LogChecker {
|
||||
lc.mu.Lock()
|
||||
defer lc.mu.Unlock()
|
||||
lc.stopMark = msg
|
||||
lc.stopped = false
|
||||
return lc
|
||||
}
|
||||
|
||||
// Check returns the filtered slice and whether the stop mark is reached.
|
||||
func (lc *LogChecker) Check(d time.Duration) (filtered []bool, stopped bool) {
|
||||
stop := time.Now().Add(d)
|
||||
|
||||
for {
|
||||
lc.mu.Lock()
|
||||
stopped = lc.stopped
|
||||
lc.mu.Unlock()
|
||||
|
||||
if time.Now().After(stop) || stopped {
|
||||
lc.mu.Lock()
|
||||
f := make([]bool, len(lc.filtered))
|
||||
copy(f, lc.filtered)
|
||||
lc.mu.Unlock()
|
||||
return f, stopped
|
||||
}
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
// Copyright 2023 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.dev/modules/log"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestLogChecker(t *testing.T) {
|
||||
lc, cleanup := NewLogChecker(log.DEFAULT)
|
||||
defer cleanup()
|
||||
|
||||
lc.Filter("First", "Third").StopMark("End")
|
||||
log.Info("test")
|
||||
|
||||
filtered, stopped := lc.Check(100 * time.Millisecond)
|
||||
assert.ElementsMatch(t, []bool{false, false}, filtered)
|
||||
assert.False(t, stopped)
|
||||
|
||||
log.Info("First")
|
||||
filtered, stopped = lc.Check(100 * time.Millisecond)
|
||||
assert.ElementsMatch(t, []bool{true, false}, filtered)
|
||||
assert.False(t, stopped)
|
||||
|
||||
log.Info("Second")
|
||||
filtered, stopped = lc.Check(100 * time.Millisecond)
|
||||
assert.ElementsMatch(t, []bool{true, false}, filtered)
|
||||
assert.False(t, stopped)
|
||||
|
||||
log.Info("Third")
|
||||
filtered, stopped = lc.Check(100 * time.Millisecond)
|
||||
assert.ElementsMatch(t, []bool{true, true}, filtered)
|
||||
assert.False(t, stopped)
|
||||
|
||||
log.Info("End")
|
||||
filtered, stopped = lc.Check(100 * time.Millisecond)
|
||||
assert.ElementsMatch(t, []bool{true, true}, filtered)
|
||||
assert.True(t, stopped)
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
// Copyright 2017 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package test
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"archive/zip"
|
||||
"bytes"
|
||||
"compress/gzip"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"gitea.dev/modules/json"
|
||||
"gitea.dev/modules/util"
|
||||
)
|
||||
|
||||
// RedirectURL returns the redirect URL of a http response.
|
||||
// It also works for JSONRedirect: `{"redirect": "..."}`
|
||||
// FIXME: it should separate the logic of checking from header and JSON body
|
||||
func RedirectURL(resp http.ResponseWriter) string {
|
||||
loc := resp.Header().Get("Location")
|
||||
if loc != "" {
|
||||
return loc
|
||||
}
|
||||
if r, ok := resp.(*httptest.ResponseRecorder); ok {
|
||||
m := map[string]any{}
|
||||
err := json.Unmarshal(r.Body.Bytes(), &m)
|
||||
if err == nil {
|
||||
if loc, ok := m["redirect"].(string); ok {
|
||||
return loc
|
||||
}
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func ParseJSONError(buf []byte) (ret struct {
|
||||
ErrorMessage string `json:"errorMessage"`
|
||||
RenderFormat string `json:"renderFormat"`
|
||||
},
|
||||
) {
|
||||
_ = json.Unmarshal(buf, &ret)
|
||||
return ret
|
||||
}
|
||||
|
||||
func ParseJSONRedirect(buf []byte) (ret struct {
|
||||
Redirect *string `json:"redirect"`
|
||||
},
|
||||
) {
|
||||
_ = json.Unmarshal(buf, &ret)
|
||||
return ret
|
||||
}
|
||||
|
||||
func IsNormalPageCompleted(s string) bool {
|
||||
return strings.Contains(s, `<footer class="page-footer"`) && strings.Contains(s, `</html>`)
|
||||
}
|
||||
|
||||
func MockVariableValue[T any](p *T, v ...T) (reset func()) {
|
||||
old := *p
|
||||
if len(v) > 0 {
|
||||
*p = v[0]
|
||||
}
|
||||
return func() { *p = old }
|
||||
}
|
||||
|
||||
func ReadAllTarGzContent(r io.Reader) (map[string]string, error) {
|
||||
gzr, err := gzip.NewReader(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
content := make(map[string]string)
|
||||
|
||||
tr := tar.NewReader(gzr)
|
||||
for {
|
||||
hd, err := tr.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
buf, err := io.ReadAll(tr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
content[hd.Name] = string(buf)
|
||||
}
|
||||
return content, nil
|
||||
}
|
||||
|
||||
func WriteTarArchive(files map[string]string) *bytes.Buffer {
|
||||
return WriteTarCompression(func(w io.Writer) io.WriteCloser { return util.NopCloser{Writer: w} }, files)
|
||||
}
|
||||
|
||||
func WriteZipArchive(files map[string]string) *bytes.Buffer {
|
||||
buf := &bytes.Buffer{}
|
||||
zw := zip.NewWriter(buf)
|
||||
for name, content := range files {
|
||||
w, _ := zw.Create(name)
|
||||
_, _ = w.Write([]byte(content))
|
||||
}
|
||||
_ = zw.Close()
|
||||
return buf
|
||||
}
|
||||
|
||||
func WriteTarCompression[F func(io.Writer) io.WriteCloser | func(io.Writer) (io.WriteCloser, error)](compression F, files map[string]string) *bytes.Buffer {
|
||||
buf := &bytes.Buffer{}
|
||||
var cw io.WriteCloser
|
||||
switch compressFunc := any(compression).(type) {
|
||||
case func(io.Writer) io.WriteCloser:
|
||||
cw = compressFunc(buf)
|
||||
case func(io.Writer) (io.WriteCloser, error):
|
||||
cw, _ = compressFunc(buf)
|
||||
}
|
||||
tw := tar.NewWriter(cw)
|
||||
|
||||
for name, content := range files {
|
||||
hdr := &tar.Header{
|
||||
Name: name,
|
||||
Mode: 0o600,
|
||||
Size: int64(len(content)),
|
||||
}
|
||||
_ = tw.WriteHeader(hdr)
|
||||
_, _ = tw.Write([]byte(content))
|
||||
}
|
||||
_ = tw.Close()
|
||||
_ = cw.Close()
|
||||
return buf
|
||||
}
|
||||
|
||||
func CompressGzip(content string) *bytes.Buffer {
|
||||
buf := &bytes.Buffer{}
|
||||
cw := gzip.NewWriter(buf)
|
||||
_, _ = cw.Write([]byte(content))
|
||||
_ = cw.Close()
|
||||
return buf
|
||||
}
|
||||
|
||||
var AllowSkipExternalService = sync.OnceValue(func() bool {
|
||||
isLocalTesting := os.Getenv("CI") == ""
|
||||
ciSkipExternal, _ := strconv.ParseBool(os.Getenv("GITEA_TEST_CI_SKIP_EXTERNAL"))
|
||||
return isLocalTesting || ciSkipExternal
|
||||
})
|
||||
|
||||
type TestingT interface {
|
||||
Helper()
|
||||
Skipf(format string, args ...any)
|
||||
Errorf(format string, args ...any)
|
||||
Fatalf(format string, args ...any)
|
||||
}
|
||||
|
||||
func ExternalServiceHTTP(t TestingT, envVarName, def string) string {
|
||||
t.Helper()
|
||||
val := util.IfZero(os.Getenv(envVarName), def)
|
||||
if val == "" {
|
||||
if AllowSkipExternalService() {
|
||||
t.Skipf("skipping test because %s is not set", envVarName)
|
||||
} else {
|
||||
t.Fatalf("%s is not set, but skipping is not allowed in CI", envVarName)
|
||||
}
|
||||
}
|
||||
// minio's endpoint is "host:port" pattern
|
||||
testURL := util.Iif(strings.Contains(val, "://"), val, "http://"+val)
|
||||
resp, err := http.Get(testURL)
|
||||
if err != nil {
|
||||
if AllowSkipExternalService() {
|
||||
t.Skipf("skipping test because %s is not ready", val)
|
||||
} else {
|
||||
t.Fatalf("%s is not ready, but skipping is not allowed in CI", val)
|
||||
}
|
||||
} else {
|
||||
_ = resp.Body.Close()
|
||||
}
|
||||
return val
|
||||
}
|
||||
Reference in New Issue
Block a user