cneicy
a5f7b8e586
Publish Docker image (Multi-arch) / Build & push (amd64) (push) Failing after 1m40s
Release (Linux, macOS, Windows) / Linux Release (push) Failing after 42m16s
Publish Docker image (Multi-arch) / Build & push (arm64) (push) Canceled after 0s
Release (Linux, macOS, Windows) / macOS Release (push) Canceled after 0s
Release (Linux, macOS, Windows) / Windows Release (push) Canceled after 0s
Publish Docker image (Multi-arch) / Create multi-arch manifests (push) Canceled after 0s
Sync production source including routing, billing, Astra detection and public uptime. Update custom build instructions and license packaging.
202 lines
12 KiB
Go
202 lines
12 KiB
Go
package controller
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"github.com/QuantumNous/new-api/common"
|
|
"github.com/QuantumNous/new-api/middleware"
|
|
"github.com/QuantumNous/new-api/model"
|
|
fingerprint "github.com/QuantumNous/new-api/pkg/model_fingerprint"
|
|
"github.com/QuantumNous/new-api/service"
|
|
"github.com/QuantumNous/new-api/setting"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/glebarez/sqlite"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/driver/mysql"
|
|
"gorm.io/driver/postgres"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/schema"
|
|
"net/http/httptest"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestStatusPageDatabaseMatrix(t *testing.T) {
|
|
for _, dialect := range []string{"sqlite", "mysql", "postgres"} {
|
|
t.Run(dialect, func(t *testing.T) {
|
|
var driver gorm.Dialector
|
|
switch dialect {
|
|
case "sqlite":
|
|
driver = sqlite.Open(":memory:")
|
|
case "mysql":
|
|
if os.Getenv("TEST_MYSQL_DSN") == "" {
|
|
t.Skip("TEST_MYSQL_DSN unset")
|
|
}
|
|
driver = mysql.Open(os.Getenv("TEST_MYSQL_DSN"))
|
|
case "postgres":
|
|
if os.Getenv("TEST_POSTGRES_DSN") == "" {
|
|
t.Skip("TEST_POSTGRES_DSN unset")
|
|
}
|
|
driver = postgres.Open(os.Getenv("TEST_POSTGRES_DSN"))
|
|
}
|
|
db, err := gorm.Open(driver, &gorm.Config{NamingStrategy: schema.NamingStrategy{TablePrefix: fmt.Sprintf("status_%d_", time.Now().UnixNano())}})
|
|
require.NoError(t, err)
|
|
conn, err := db.DB()
|
|
require.NoError(t, err)
|
|
conn.SetMaxOpenConns(1)
|
|
oldDB, oldLog := model.DB, model.LOG_DB
|
|
oldType, oldLogType := common.MainDatabaseType(), common.LogDatabaseType()
|
|
oldRedis, oldSecret, oldSecure := common.RedisEnabled, common.SessionSecret, common.SessionCookieSecure
|
|
oldGroups := setting.UserUsableGroups2JSONString()
|
|
model.DB, model.LOG_DB = db, db
|
|
common.SetDatabaseTypes(common.DatabaseType(dialect), common.DatabaseType(dialect))
|
|
common.RedisEnabled, common.SessionSecret, common.SessionCookieSecure = false, "status-test-only", true
|
|
rows := []any{&model.Option{}, &model.Channel{}, &model.Ability{}, &model.SystemTask{}, &model.DetectionRun{}, &model.DetectionCall{}, &model.DetectionSchedule{}, &model.Log{}, &model.PerfMetric{}, &model.User{}, &model.UserSession{}}
|
|
require.NoError(t, db.AutoMigrate(rows...))
|
|
require.NoError(t, db.Table("audit_logs").AutoMigrate(&model.AuditLog{}))
|
|
t.Cleanup(func() {
|
|
require.NoError(t, db.Migrator().DropTable("audit_logs"))
|
|
for _, row := range rows {
|
|
require.NoError(t, db.Migrator().DropTable(row))
|
|
}
|
|
model.DB, model.LOG_DB = oldDB, oldLog
|
|
common.SetDatabaseTypes(oldType, oldLogType)
|
|
common.RedisEnabled, common.SessionSecret, common.SessionCookieSecure = oldRedis, oldSecret, oldSecure
|
|
require.NoError(t, setting.UpdateUserUsableGroupsByJSONString(oldGroups))
|
|
groupCacheSnapshot.updated = time.Time{}
|
|
require.NoError(t, conn.Close())
|
|
})
|
|
var version string
|
|
q := "select version()"
|
|
if dialect == "sqlite" {
|
|
q = "select sqlite_version()"
|
|
}
|
|
require.NoError(t, db.Raw(q).Scan(&version).Error)
|
|
t.Log("database version:", version)
|
|
require.NoError(t, setting.UpdateUserUsableGroupsByJSONString(`{"internal":"","shared":"","hidden":""}`))
|
|
now := time.Now().Unix()
|
|
channels := []model.Channel{{Id: 1, Name: "private-channel", Key: "private-key", Group: "internal,shared", Models: fingerprint.Model, Status: 1}, {Id: 2, Group: "hidden", Models: fingerprint.Model, Status: 1}, {Id: 3, Group: "internal", Models: "disabled-model", Status: 2}}
|
|
require.NoError(t, db.Create(&channels).Error)
|
|
abilities := []model.Ability{{Group: "internal", Model: fingerprint.Model, ChannelId: 1, Enabled: true}, {Group: "shared", Model: fingerprint.Model, ChannelId: 1, Enabled: true}, {Group: "hidden", Model: fingerprint.Model, ChannelId: 2, Enabled: true}, {Group: "internal", Model: "disabled-model", ChannelId: 3, Enabled: true}, {Group: "internal", Model: "disabled-ability", ChannelId: 1}}
|
|
require.NoError(t, db.Create(&abilities).Error)
|
|
state, err := common.Marshal(service.AstraSamplingState{Rounds: []service.AstraSamplingRound{{ID: "old-round", ChannelID: 1, StartedAt: now - 20, FinishedAt: now - 10, Result: fingerprint.Result{Status: "match", Closest: fingerprint.Model, ValidSamples: 3}}}})
|
|
require.NoError(t, err)
|
|
require.NoError(t, db.Create(&model.SystemTask{TaskID: "old-task", Type: service.AstraSamplingTaskType, Status: model.SystemTaskStatusSucceeded, CreatedAt: now - 20, State: string(state)}).Error)
|
|
runs := []model.DetectionRun{{ID: "old-work", RequestKey: "old-work", ChannelID: 1, GroupName: "internal", Kind: "pelican", Status: "succeeded", Quality: "normal", CreatedAt: now - 20, Settled: true, HTML: "<h1>art</h1>", Charged: 17}, {ID: "in-flight", RequestKey: "in-flight", ChannelID: 1, Kind: "pelican", Status: "running", CreatedAt: now - 10}, {ID: "hidden-art", RequestKey: "hidden-art", ChannelID: 2, Kind: "pelican", Status: "succeeded", CreatedAt: now - 20, HTML: "hidden"}}
|
|
require.NoError(t, db.Create(&runs).Error)
|
|
tokens := map[int]string{}
|
|
for _, role := range []int{1, 10} {
|
|
require.NoError(t, db.Create(&model.User{Id: role, Username: fmt.Sprintf("role-%d", role), Role: role, Status: 1, AuthVersion: 1, AffCode: fmt.Sprintf("role-%d", role)}).Error)
|
|
sid := fmt.Sprintf("session-%d", role)
|
|
require.NoError(t, db.Create(&model.UserSession{SID: sid, UserID: role, Version: 1, UserAuthVersion: 1, Status: model.UserSessionStatusActive, RefreshHash: sid, ExpiresAt: now + 3600}).Error)
|
|
tokens[role], _, err = service.IssueAccessToken(service.AuthIdentity{UserID: role, SessionID: sid, UserAuthVersion: 1, SessionVersion: 1})
|
|
require.NoError(t, err)
|
|
}
|
|
engine := gin.New()
|
|
engine.GET("/api/uptime/status", GetGroupStatus)
|
|
engine.GET("/api/group-status", GetSiteGroupStatus)
|
|
engine.PUT("/api/uptime/group", middleware.AdminAuth(), middleware.SessionCookieOriginGuard(), UpdateStatusPageGroup)
|
|
engine.POST("/api/uptime/group/reset", middleware.AdminAuth(), middleware.SessionCookieOriginGuard(), UpdateStatusPageGroup)
|
|
engine.GET("/api/detections/artwork/:id", GetDetectionArtwork)
|
|
engine.GET("/api/group-status/artwork/:id", GetSiteDetectionArtwork)
|
|
request := func(method, path, body, token, origin string) *httptest.ResponseRecorder {
|
|
req := httptest.NewRequest(method, "https://status.test"+path, strings.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
if token != "" {
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
}
|
|
if origin != "" {
|
|
req.Header.Set("Origin", origin)
|
|
}
|
|
out := httptest.NewRecorder()
|
|
engine.ServeHTTP(out, req)
|
|
return out
|
|
}
|
|
for _, token := range []string{"", tokens[1]} {
|
|
assert.Contains(t, []int{401, 403}, request("POST", "/api/uptime/group/reset", `{"group":"internal"}`, token, "https://status.test").Code)
|
|
}
|
|
assert.Equal(t, 403, request("POST", "/api/uptime/group/reset", `{"group":"internal"}`, tokens[10], "https://evil.test").Code)
|
|
assert.Equal(t, 400, request("PUT", "/api/uptime/group", `{"group":"internal"}`, tokens[10], "https://status.test").Code)
|
|
assert.Equal(t, 404, request("POST", "/api/uptime/group/reset", `{"group":"missing"}`, tokens[10], "https://status.test").Code)
|
|
for _, body := range []string{`{"group":"internal","alias":"#688","hidden":false}`, `{"group":"hidden","alias":"secret-alias","hidden":true}`} {
|
|
res := request("PUT", "/api/uptime/group", body, tokens[10], "https://status.test")
|
|
require.Equal(t, 200, res.Code, res.Body.String())
|
|
}
|
|
var auditCount int64
|
|
require.NoError(t, db.Table("audit_logs").Count(&auditCount).Error)
|
|
assert.Greater(t, auditCount, int64(0))
|
|
groupCacheSnapshot.updated = time.Time{}
|
|
res := request("GET", "/api/uptime/status", "", "", "")
|
|
require.Equal(t, 200, res.Code, res.Body.String())
|
|
for _, secret := range []string{"internal", "secret-alias", "private-channel", "private-key", "disabled-model", "disabled-ability"} {
|
|
assert.NotContains(t, res.Body.String(), secret)
|
|
}
|
|
assert.Contains(t, res.Body.String(), "#688")
|
|
fallback := model.DetectionRun{ID:"fallback-completed",RequestKey:"fallback-completed",Kind:"pelican",ChannelID:1,GroupName:"internal",Status:"running",Quality:"normal",HTML:"<html>pelican</html>",CreatedAt:now,Deadline:now+600}
|
|
require.NoError(t,db.Create(&fallback).Error)
|
|
require.NoError(t,db.Create(&model.DetectionCall{ID:fallback.ID,RunID:fallback.ID,SecretHash:"fallback-only-test",State:"finished"}).Error)
|
|
processLocalPelican(context.Background(),fallback)
|
|
require.NoError(t,db.First(&fallback,"id = ?",fallback.ID).Error)
|
|
assert.Equal(t,"succeeded",fallback.Status)
|
|
assert.Equal(t,"unknown",fallback.Quality)
|
|
assert.Equal(t,"<html>pelican</html>",fallback.HTML)
|
|
assert.True(t,fallback.Settled)
|
|
require.NoError(t,db.Delete(&model.DetectionCall{},"id = ?",fallback.ID).Error)
|
|
require.NoError(t,db.Delete(&model.DetectionRun{},"id = ?",fallback.ID).Error)
|
|
visitorSite := request("GET", "/api/group-status", "", "", "")
|
|
require.Equal(t, 200, visitorSite.Code)
|
|
assert.Contains(t, visitorSite.Body.String(), `"group":"hidden"`)
|
|
assert.Contains(t, visitorSite.Body.String(), `"name":"internal"`)
|
|
assert.NotContains(t, visitorSite.Body.String(), "#688")
|
|
site := request("GET", "/api/group-status", "", tokens[1], "")
|
|
require.Equal(t, 200, site.Code)
|
|
assert.Contains(t, site.Body.String(), `"group":"internal"`)
|
|
assert.Contains(t, site.Body.String(), `"name":"internal"`)
|
|
assert.NotContains(t, site.Body.String(), "#688")
|
|
assert.Contains(t, site.Body.String(), `"group":"hidden"`)
|
|
adminSite := request("GET", "/api/group-status", "", tokens[10], "")
|
|
assert.Contains(t, adminSite.Body.String(), `"group":"hidden"`)
|
|
assert.Equal(t, 404, request("GET", "/api/detections/artwork/hidden-art", "", "", "").Code)
|
|
assert.Equal(t, 200, request("GET", "/api/group-status/artwork/hidden-art", "", "", "").Code)
|
|
require.Equal(t, 200, request("POST", "/api/uptime/group/reset", `{"group":"internal"}`, tokens[10], "https://status.test").Code)
|
|
require.NoError(t, db.Model(&model.DetectionRun{}).Where("id = ?", "in-flight").Updates(map[string]any{"settled": true, "status": "succeeded", "quality": "normal", "finished_at": now + 10}).Error)
|
|
groups, err := currentGroupMonitors(context.Background(), true)
|
|
require.NoError(t, err)
|
|
byGroup := map[string]Monitor{}
|
|
for _, m := range groups[0].Monitors {
|
|
byGroup[m.Group] = m
|
|
}
|
|
assert.Empty(t, byGroup["internal"].Fingerprint.History)
|
|
assert.Nil(t, byGroup["internal"].Fingerprint.Rate)
|
|
assert.Empty(t, byGroup["internal"].Pelican.History)
|
|
assert.Len(t, byGroup["shared"].Fingerprint.History, 1)
|
|
assert.Len(t, byGroup["shared"].Pelican.History, 2)
|
|
assert.True(t, byGroup["hidden"].Hidden)
|
|
assert.Equal(t, []string{fingerprint.Model}, byGroup["internal"].Models)
|
|
require.NoError(t, model.SaveStatusPageGroup(context.Background(), "internal", &model.StatusPageGroup{Alias: "#689", Hidden: true}))
|
|
settings, err := model.GetStatusPageGroups(context.Background())
|
|
require.NoError(t, err)
|
|
assert.GreaterOrEqual(t, settings["internal"].ResetBefore, now)
|
|
assert.Equal(t, "#689", settings["internal"].Alias)
|
|
require.NoError(t, model.SaveStatusPageGroup(context.Background(), "shared", &model.StatusPageGroup{Hidden: true}))
|
|
assert.Equal(t, 404, request("GET", "/api/detections/artwork/old-work", "", "", "").Code)
|
|
var retained model.DetectionRun
|
|
require.NoError(t, db.First(&retained, "id = ?", "old-work").Error)
|
|
assert.Equal(t, 17, retained.Charged)
|
|
assert.Equal(t, "<h1>art</h1>", retained.HTML)
|
|
require.NoError(t, db.Create(&model.DetectionRun{ID: "new-work", RequestKey: "new-work", ChannelID: 1, Kind: "pelican", Status: "succeeded", Quality: "normal", CreatedAt: settings["internal"].ResetBefore + 1, Settled: true}).Error)
|
|
groups, err = currentGroupMonitors(context.Background(), true)
|
|
require.NoError(t, err)
|
|
for _, m := range groups[0].Monitors {
|
|
if m.Group == "internal" {
|
|
require.Len(t, m.Pelican.History, 1)
|
|
assert.Equal(t, "new-work", m.Pelican.History[0].ID)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|