memind/image-make-admin-config.test.mjs

import assert from 'node:assert/strict';
import test from 'node:test';
import {
  IMAGE_MAKE_DEFAULT_CONFIG,
  createImageMakeAdminConfigService,
  normalizeImageMakeAdminConfig,
} from './image-make-admin-config.mjs';

function createPool(initial = null) {
  let row = initial;
  return {
    async query(sql, params = []) {
      const compact = String(sql).replace(/\s+/g, ' ').trim();
      if (compact.startsWith('CREATE TABLE')) return [[]];
      if (compact.startsWith('SELECT') && compact.includes('FROM h5_image_make_admin_config')) {
        return [[row].filter(Boolean)];
      }
      if (compact.startsWith('INSERT INTO h5_image_make_admin_config')) {
        row = {
          config_json: params[1],
          secrets_ciphertext: params[2],
          secrets_iv: params[3],
          secrets_tag: params[4],
          updated_by: params[5],
          updated_at: params[6],
        };
        return [[]];
      }
      return [[]];
    },
  };
}

const dashScopeLlmProviderService = {
  async resolveDashScopeCredentials() {
    return {
      apiKey: 'sk-test-key-1234567890',
      keyId: 'vision-key-1',
      keyName: 'Qwen DashScope',
      source: 'vision',
      apiKeyMasked: 'sk-test********7890',
    };
  },
};

test('normalizeImageMakeAdminConfig keeps default provider aligned with enabled providers', () => {
  const config = normalizeImageMakeAdminConfig({
    defaultProvider: 'aliyun_bailian',
    providers: {
      aliyun_bailian: { enabled: false },
      mock: { enabled: true },
    },
  });
  assert.equal(config.defaultProvider, 'mock');
});

test('image make admin config reads DashScope key from unified model center', async () => {
  const service = createImageMakeAdminConfigService(createPool(), {
    env: { IMAGE_MAKE_TOKEN: 'runtime-token' },
    llmProviderService: dashScopeLlmProviderService,
  });
  const saved = await service.updateAdminConfig({
    defaultProvider: 'aliyun_bailian',
    providers: {
      mock: { enabled: false },
      aliyun_bailian: {
        enabled: true,
        model: 'qwen-image-plus',
        apiBase: 'https://dashscope.aliyuncs.com/api/v1',
      },
    },
  }, { updatedBy: 'admin-1' });
  assert.equal(saved.ok, true);
  assert.equal(saved.config.providers.aliyun_bailian.apiKeyConfigured, true);
  assert.match(saved.config.providers.aliyun_bailian.apiKeyMasked, /\*/);
  assert.equal(saved.config.providers.aliyun_bailian.dashScopeSource, 'vision');

  const runtime = await service.getRuntimeConfig();
  assert.equal(runtime.ok, true);
  assert.equal(runtime.defaultProvider, 'aliyun_bailian');
  assert.equal(runtime.providers.aliyun_bailian.apiKey, 'sk-test-key-1234567890');
});

test('image make admin config rejects bailian when model center has no DashScope key', async () => {
  const service = createImageMakeAdminConfigService(createPool(), {
    env: { IMAGE_MAKE_TOKEN: 'runtime-token' },
    llmProviderService: { async resolveDashScopeCredentials() { return null; } },
  });
  const result = await service.updateAdminConfig({
    defaultProvider: 'aliyun_bailian',
    providers: {
      mock: { enabled: false },
      aliyun_bailian: {
        enabled: true,
        model: 'qwen-image-plus',
        apiBase: 'https://dashscope.aliyuncs.com/api/v1',
      },
    },
  });
  assert.equal(result.ok, false);
  assert.match(result.message, /统一模型中心/);
});

test('image make admin config rejects invalid comfyui runtime', async () => {
  const service = createImageMakeAdminConfigService(createPool(), {
    env: { IMAGE_MAKE_TOKEN: 'runtime-token' },
    llmProviderService: dashScopeLlmProviderService,
  });
  const result = await service.updateAdminConfig({
    defaultProvider: 'comfyui',
    providers: {
      mock: { enabled: false },
      comfyui: { enabled: true, apiBase: 'http://127.0.0.1:8188', checkpoint: '' },
    },
  });
  assert.equal(result.ok, false);
  assert.match(result.message, /Checkpoint/);
});

test('image make runtime request authorization uses IMAGE_MAKE_TOKEN', () => {
  const service = createImageMakeAdminConfigService(createPool(), {
    env: { IMAGE_MAKE_TOKEN: 'runtime-token' },
  });
  assert.equal(service.authorizeRuntimeRequest('runtime-token'), true);
  assert.equal(service.authorizeRuntimeRequest('wrong'), false);
});

test('image make admin config falls back to legacy stored DashScope key', async () => {
  const pool = createPool();
  const service = createImageMakeAdminConfigService(pool, {
    env: { IMAGE_MAKE_TOKEN: 'runtime-token' },
    llmProviderService: { async resolveDashScopeCredentials() { return null; } },
  });
  await service.updateAdminConfig({
    defaultProvider: 'aliyun_bailian',
    providers: {
      mock: { enabled: false },
      aliyun_bailian: {
        enabled: true,
        model: 'qwen-image-plus',
        apiBase: 'https://dashscope.aliyuncs.com/api/v1',
        apiKey: 'sk-legacy-key-1234567890',
      },
    },
  }, { updatedBy: 'admin-1' });
  const runtime = await service.getRuntimeConfig();
  assert.equal(runtime.ok, true);
  assert.equal(runtime.providers.aliyun_bailian.apiKey, 'sk-legacy-key-1234567890');
});

test('image make default config starts with mock only', () => {
  const config = normalizeImageMakeAdminConfig({});
  assert.equal(config.defaultProvider, IMAGE_MAKE_DEFAULT_CONFIG.defaultProvider);
  assert.equal(config.providers.mock.enabled, true);
  assert.equal(config.providers.aliyun_bailian.enabled, false);
});