kubricate/dist/cjs/secret/orchestrator/SecretManagerEngine.test.js

A TypeScript framework for building reusable, type-safe Kubernetes infrastructure — without the YAML mess.

"use strict";

var _vitest = /*#__PURE__*/require("vitest");
var _SecretManager = /*#__PURE__*/require("../SecretManager.js");
var _SecretRegistry = /*#__PURE__*/require("../SecretRegistry.js");
var _SecretManagerEngine = /*#__PURE__*/require("./SecretManagerEngine.js");
/* eslint-disable @typescript-eslint/no-explicit-any */

(0, _vitest.describe)('SecretManagerEngine', () => {
  let mockSecretManager;
  let mockConnector;
  let mockProvider;
  let mockLogger;
  let effectsOptions;
  let config;
  (0, _vitest.beforeEach)(() => {
    mockConnector = {
      getWorkingDir: _vitest.vi.fn(() => undefined),
      setWorkingDir: _vitest.vi.fn(),
      load: _vitest.vi.fn(() => Promise.resolve()),
      get: _vitest.vi.fn(key => ({
        value: `secret-${key}`
      }))
    };
    mockProvider = {
      prepare: _vitest.vi.fn((name, value) => [{
        type: 'kubectl',
        value
      }])
    };
    mockSecretManager = {
      getSecrets: _vitest.vi.fn(() => ({
        DB_PASSWORD: {
          name: 'mock',
          connector: 'env',
          provider: 'k8s'
        }
      })),
      resolveConnector: _vitest.vi.fn(() => mockConnector),
      resolveProvider: _vitest.vi.fn(() => mockProvider)
    };
    mockLogger = {
      info: _vitest.vi.fn(),
      warn: _vitest.vi.fn(),
      debug: _vitest.vi.fn()
    };
    effectsOptions = {
      workingDir: '/test'
    };
    config = {
      stacks: {
        auth: {
          getSecretManagers: () => ({
            main: mockSecretManager
          })
        }
      },
      secret: {
        secretSpec: mockSecretManager
      }
    };
  });
  (0, _vitest.it)('should collect secret managers from config', () => {
    const engine = new _SecretManagerEngine.SecretManagerEngine({
      config,
      effectOptions: effectsOptions,
      logger: mockLogger
    });
    const result = engine.collect();
    (0, _vitest.expect)(Object.keys(result)).toContain('default');
    (0, _vitest.expect)(result['default'].secretManager).toBe(mockSecretManager);
  });
  (0, _vitest.it)('should validate secret managers', async () => {
    const engine = new _SecretManagerEngine.SecretManagerEngine({
      config,
      effectOptions: effectsOptions,
      logger: mockLogger
    });
    const managers = engine.collect();
    await engine.validate(managers);
    (0, _vitest.expect)(mockConnector.load).toHaveBeenCalledWith(['DB_PASSWORD']);
    (0, _vitest.expect)(mockConnector.get).toHaveBeenCalledWith('DB_PASSWORD');
  });
  (0, _vitest.it)('should prepare effects correctly', async () => {
    const engine = new _SecretManagerEngine.SecretManagerEngine({
      config,
      effectOptions: effectsOptions,
      logger: mockLogger
    });
    const managers = engine.collect();
    const effects = await engine.prepareEffects(managers);
    (0, _vitest.expect)(effects).toHaveLength(1);
    (0, _vitest.expect)(effects[0].type).toBe('kubectl');
    (0, _vitest.expect)(effects[0].value.value).toBe('secret-DB_PASSWORD');
  });
});
(0, _vitest.describe)('SecretManagerEngine.collect()', () => {
  const mockLogger = {
    info: _vitest.vi.fn(),
    warn: _vitest.vi.fn(),
    debug: _vitest.vi.fn()
  };
  (0, _vitest.it)('collects a single manager (legacy mode)', () => {
    const manager = new _SecretManager.SecretManager();
    const engine = new _SecretManagerEngine.SecretManagerEngine({
      logger: mockLogger,
      effectOptions: {},
      config: {
        secret: {
          secretSpec: manager
        },
        stacks: {}
      }
    });
    const result = engine.collect();
    (0, _vitest.expect)(result).toEqual({
      default: {
        name: 'default',
        secretManager: manager
      }
    });
  });
  (0, _vitest.it)('collects multiple managers from registry', () => {
    const registry = new _SecretRegistry.SecretRegistry().add('svc1', new _SecretManager.SecretManager()).add('svc2', new _SecretManager.SecretManager());
    const engine = new _SecretManagerEngine.SecretManagerEngine({
      logger: mockLogger,
      effectOptions: {},
      config: {
        secret: {
          secretSpec: registry
        },
        stacks: {}
      }
    });
    const result = engine.collect();
    (0, _vitest.expect)(Object.keys(result)).toEqual(['svc1', 'svc2']);
    (0, _vitest.expect)(result.svc1.secretManager).toBeInstanceOf(_SecretManager.SecretManager);
    (0, _vitest.expect)(result.svc2.secretManager).toBeInstanceOf(_SecretManager.SecretManager);
  });
  (0, _vitest.it)('throws if neither manager nor registry are defined', () => {
    const engine = new _SecretManagerEngine.SecretManagerEngine({
      logger: mockLogger,
      effectOptions: {},
      config: {
        secret: {},
        stacks: {}
      }
    });
    (0, _vitest.expect)(() => engine.collect()).toThrowError(/No secret manager or secret registry/);
  });
});
//# sourceMappingURL=SecretManagerEngine.test.js.map