311 lines
12 KiB
Go
311 lines
12 KiB
Go
package application
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/assets"
|
|
"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/billing"
|
|
"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/providers"
|
|
"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/settings"
|
|
)
|
|
|
|
func TestDefaultSettingsServiceAppliesProviderSettingsWithoutRestart(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), ".env.local")
|
|
key := "IMAGE_GENERATE_ENGINE"
|
|
service := defaultSettingsService(func(name string) string {
|
|
if name == "ZHINIAN_SETTINGS_FILE" {
|
|
return path
|
|
}
|
|
return ""
|
|
})
|
|
value, err := service.Save(context.Background(), map[string]any{key: "evolink"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
payload, ok := value.(settings.Payload)
|
|
if !ok || payload.RestartRequired {
|
|
t.Fatalf("payload=%#v", value)
|
|
}
|
|
}
|
|
|
|
func TestBillingAccountAndSettingsUseOneRuntimeSource(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), ".env.local")
|
|
if err := os.WriteFile(path, []byte("ZHINIAN_BILLING_ACCOUNT_NAME=Original\nZHINIAN_BILLING_ACCOUNT_BANK=Old Bank\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
service := defaultSettingsService(func(name string) string {
|
|
if name == "ZHINIAN_SETTINGS_FILE" {
|
|
return path
|
|
}
|
|
return ""
|
|
})
|
|
store := settingsBillingAccountStore{service: service}
|
|
if err := store.Save(context.Background(), billing.AccountConfig{AccountName: "Updated", BankName: "New Bank", AccountNumber: "123", Contact: "Ops"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
loaded, err := store.Load(context.Background())
|
|
if err != nil || loaded.AccountName != "Updated" || loaded.BankName != "New Bank" || loaded.AccountNumber != "123" || loaded.Contact != "Ops" {
|
|
t.Fatalf("loaded=%#v err=%v", loaded, err)
|
|
}
|
|
payload, err := service.Get(context.Background())
|
|
if err != nil || fieldValueFromSettings(t, payload, "ZHINIAN_BILLING_ACCOUNT_NAME") != "Updated" {
|
|
t.Fatalf("settings payload=%#v err=%v", payload, err)
|
|
}
|
|
}
|
|
|
|
func fieldValueFromSettings(t *testing.T, value any, key string) string {
|
|
t.Helper()
|
|
payload := value.(settings.Payload)
|
|
for _, group := range payload.Groups {
|
|
for _, field := range group.Fields {
|
|
if field.Key == key {
|
|
return field.Value
|
|
}
|
|
}
|
|
}
|
|
t.Fatalf("settings field %s not found", key)
|
|
return ""
|
|
}
|
|
|
|
func TestRuntimeHealthDetailsMatchTypeScriptDefaultsAndConfiguredModes(t *testing.T) {
|
|
values := map[string]string{
|
|
"VOLCENGINE_ACCESS_KEY_ID": "access",
|
|
"VOLCENGINE_SECRET_ACCESS_KEY": "secret",
|
|
"SEEDANCE_API_KEY": "seedance-key",
|
|
"VIDEO_GENERATE_ENGINE": "seedance",
|
|
"ZHINIAN_AUTH_REQUIRED": "true",
|
|
"ZHINIAN_AUTH_SESSION_SECRET": "session-secret",
|
|
}
|
|
details := runtimeHealthDetails(func(name string) string { return values[name] })
|
|
if details.VisualAPIMode != "volcengine" || details.EvolinkMode != "missing" || details.SeedanceMode != "seedance" || details.BailianMode != "missing" || details.AuthMode != "configured" {
|
|
t.Fatalf("details = %+v", details)
|
|
}
|
|
if len(details.Capabilities) != 2 {
|
|
t.Fatalf("capabilities = %#v, want image and Seedance", details.Capabilities)
|
|
}
|
|
image := details.Capabilities[0].(map[string]any)
|
|
video := details.Capabilities[1].(map[string]any)
|
|
if image["id"] != "image.generate" || image["engineLabel"] != "即梦" || video["id"] != "video.generate" || video["engineLabel"] != "Seedance" {
|
|
t.Fatalf("capabilities = %#v", details.Capabilities)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeProviderJobBuilderRefreshesDatabaseSettings(t *testing.T) {
|
|
settingsPath := filepath.Join(t.TempDir(), ".env.local")
|
|
fallback := func(name string) string {
|
|
if name == "ZHINIAN_SETTINGS_FILE" {
|
|
return settingsPath
|
|
}
|
|
return ""
|
|
}
|
|
repository := &applicationRuntimeSettingsRepository{values: map[string]string{
|
|
"EVOLINK_API_KEY": "evolink-secret",
|
|
"EVOLINK_IMAGE_MODEL": "database-image-model",
|
|
"EVOLINK_IMAGE_QUALITY": "high",
|
|
"IMAGE_GENERATE_ENGINE": "evolink",
|
|
}}
|
|
service := databaseSettingsService(fallback, repository)
|
|
builder := runtimeProviderJobBuilder{fallback: fallback, settings: service, enforceAvailability: true}
|
|
command, err := builder.Build(context.Background(), "owner", "", "image.generate", "", map[string]any{"prompt": "draw"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var request providers.Request
|
|
if err := json.Unmarshal(command.Job.RequestPayload, &request); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if command.Job.Provider != "evolink" || command.Job.ReqKey != "database-image-model" || request.Settings["quality"] != "high" {
|
|
t.Fatalf("job=%#v request=%#v", command.Job, request)
|
|
}
|
|
repository.values = map[string]string{
|
|
"BAILIAN_API_KEY": "bailian-secret",
|
|
"BAILIAN_IMAGE_MODEL": "database-bailian-model",
|
|
"IMAGE_GENERATE_ENGINE": "bailian",
|
|
}
|
|
command, err = builder.Build(context.Background(), "owner", "", "image.generate", "", map[string]any{"prompt": "draw again"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if command.Job.Provider != "bailian" || command.Job.ReqKey != "database-bailian-model" {
|
|
t.Fatalf("refreshed job=%#v", command.Job)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeProviderResolverUsesLatestDatabaseCredential(t *testing.T) {
|
|
var authorizations []string
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
|
|
authorizations = append(authorizations, request.Header.Get("Authorization"))
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"id":"task-1","status":"queued"}`))
|
|
}))
|
|
defer server.Close()
|
|
settingsPath := filepath.Join(t.TempDir(), ".env.local")
|
|
fallback := func(name string) string {
|
|
if name == "ZHINIAN_SETTINGS_FILE" {
|
|
return settingsPath
|
|
}
|
|
return ""
|
|
}
|
|
repository := &applicationRuntimeSettingsRepository{values: map[string]string{
|
|
"EVOLINK_API_KEY": "database-secret-1",
|
|
"EVOLINK_BASE_URL": server.URL,
|
|
}}
|
|
service := databaseSettingsService(fallback, repository)
|
|
resolver := newRuntimeProviderResolver(fallback, service)
|
|
adapter, err := resolver.Resolve(context.Background(), "evolink")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := adapter.Submit(context.Background(), providers.Request{Capability: "image.generate", Prompt: "draw"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
repository.values["EVOLINK_API_KEY"] = "database-secret-2"
|
|
adapter, err = resolver.Resolve(context.Background(), "evolink")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := adapter.Submit(context.Background(), providers.Request{Capability: "image.generate", Prompt: "draw again"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(authorizations, []string{"Bearer database-secret-1", "Bearer database-secret-2"}) {
|
|
t.Fatalf("authorizations=%#v", authorizations)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeHealthDetailsReportConfiguredProvidersAndImageEngine(t *testing.T) {
|
|
values := map[string]string{
|
|
"IMAGE_GENERATE_ENGINE": "bailian",
|
|
"BAILIAN_API_KEY": "bailian-key",
|
|
}
|
|
details := runtimeHealthDetails(func(name string) string { return values[name] })
|
|
if details.VisualAPIMode != "missing" || details.EvolinkMode != "missing" || details.SeedanceMode != "missing" || details.BailianMode != "bailian" || details.AuthMode != "disabled" {
|
|
t.Fatalf("details = %+v", details)
|
|
}
|
|
image := details.Capabilities[0].(map[string]any)
|
|
if image["engine"] != "bailian" || image["engineLabel"] != "阿里云百炼" || image["reqKey"] != "wan2.7-image-pro" {
|
|
t.Fatalf("image capability = %#v", image)
|
|
}
|
|
}
|
|
|
|
func TestProviderUnavailableMessagesIdentifyOnlyMissingCredentials(t *testing.T) {
|
|
values := map[string]string{
|
|
"VOLCENGINE_ACCESS_KEY_ID": "access",
|
|
"VOLCENGINE_SECRET_ACCESS_KEY": "secret",
|
|
"EVOLINK_API_KEY": "evolink",
|
|
"BAILIAN_API_KEY": "bailian",
|
|
}
|
|
missing := providerUnavailableMessages(func(name string) string { return values[name] })
|
|
if len(missing) != 1 || !strings.Contains(missing["seedance"], "SEEDANCE_API_KEY") {
|
|
t.Fatalf("missing = %#v", missing)
|
|
}
|
|
}
|
|
|
|
func TestProviderTargetsNeverSelectRemovedProvider(t *testing.T) {
|
|
getenv := func(string) string { return "" }
|
|
for engine, target := range providerImageTargets(getenv) {
|
|
if target.Provider == "mock" {
|
|
t.Fatalf("image engine %s selected removed provider", engine)
|
|
}
|
|
}
|
|
for engine, target := range providerVideoTargets(getenv) {
|
|
if target.Provider == "mock" {
|
|
t.Fatalf("video engine %s selected removed provider", engine)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCapabilitySummaryMatchesConfiguredDefaultVideoEngine(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name, engine, wantEngine, wantProvider, wantModel string
|
|
}{
|
|
{name: "Bailian default", engine: "", wantEngine: "bailian", wantProvider: "bailian", wantModel: "wan2.7-i2v-2026-04-25"},
|
|
{name: "Seedance configured", engine: "seedance", wantEngine: "seedance", wantProvider: "seedance", wantModel: "doubao-seedance-2-0-260128"},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
values := map[string]string{"VIDEO_GENERATE_ENGINE": test.engine}
|
|
value, err := capabilitySummary(func(name string) string { return values[name] })(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
capabilities := value.([]any)
|
|
video := capabilities[1].(map[string]any)
|
|
if video["engine"] != test.wantEngine || video["provider"] != test.wantProvider || video["reqKey"] != test.wantModel {
|
|
t.Fatalf("video capability = %#v", video)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRemoteAssetMaximumDefaultsToTwentyMiB(t *testing.T) {
|
|
getenv := func(string) string { return "" }
|
|
if got := remoteAssetMaxBytes(getenv); got != 20<<20 {
|
|
t.Fatalf("remote asset maximum = %d, want %d", got, int64(20<<20))
|
|
}
|
|
getenv = func(string) string { return "3145728" }
|
|
if got := remoteAssetMaxBytes(getenv); got != 3<<20 {
|
|
t.Fatalf("configured remote asset maximum = %d, want %d", got, int64(3<<20))
|
|
}
|
|
}
|
|
|
|
func TestPrefixedBlobStoreKeepsApplicationStoragePathStable(t *testing.T) {
|
|
inner := &recordingBlobStore{}
|
|
store := prefixedBlobStore{prefix: "tenant-prefix", store: inner}
|
|
stored, err := store.Put(context.Background(), "uploads/day/file.png", bytes.NewReader([]byte("x")), 1, "image/png")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if stored.Key != "uploads/day/file.png" || inner.putKey != "tenant-prefix/uploads/day/file.png" {
|
|
t.Fatalf("stored=%#v inner=%q", stored, inner.putKey)
|
|
}
|
|
_, _ = store.Read(context.Background(), stored.Key)
|
|
_ = store.Delete(context.Background(), stored.Key)
|
|
if !reflect.DeepEqual([]string{inner.readKey, inner.deleteKey}, []string{"tenant-prefix/uploads/day/file.png", "tenant-prefix/uploads/day/file.png"}) {
|
|
t.Fatalf("read/delete=%q/%q", inner.readKey, inner.deleteKey)
|
|
}
|
|
}
|
|
|
|
type recordingBlobStore struct{ putKey, readKey, deleteKey string }
|
|
|
|
type applicationRuntimeSettingsRepository struct{ values map[string]string }
|
|
|
|
func (repository *applicationRuntimeSettingsRepository) LoadRuntimeSettings(context.Context, []string) (map[string]string, error) {
|
|
values := map[string]string{}
|
|
for key, value := range repository.values {
|
|
values[key] = value
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func (repository *applicationRuntimeSettingsRepository) SaveRuntimeSettings(_ context.Context, values map[string]string) error {
|
|
if repository.values == nil {
|
|
repository.values = map[string]string{}
|
|
}
|
|
for key, value := range values {
|
|
repository.values[key] = value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *recordingBlobStore) Put(_ context.Context, key string, _ io.Reader, _ int64, _ string) (assets.StoredObject, error) {
|
|
s.putKey = key
|
|
return assets.StoredObject{Key: key, URL: "https://cdn.example/" + key}, nil
|
|
}
|
|
func (s *recordingBlobStore) Read(_ context.Context, key string) (assets.Blob, error) {
|
|
s.readKey = key
|
|
return assets.Blob{Body: io.NopCloser(bytes.NewReader(nil))}, nil
|
|
}
|
|
func (s *recordingBlobStore) Delete(_ context.Context, key string) error {
|
|
s.deleteKey = key
|
|
return nil
|
|
}
|