kubricate/dist/cjs/secret/SecretInjectionBuilder.test.js

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

"use strict";

var _vitest = /*#__PURE__*/require("vitest");
var _SecretInjectionBuilder = /*#__PURE__*/require("./SecretInjectionBuilder.js");
/* eslint-disable @typescript-eslint/no-explicit-any */

const createMockProvider = supportedStrategies => ({
  supportedStrategies,
  targetKind: 'Deployment',
  getTargetPath: _vitest.vi.fn(strategy => [`spec.template.spec.containers[${strategy.containerIndex ?? 0}].env`])
});
const createMockStack = () => ({
  registerSecretInjection: _vitest.vi.fn(),
  getComposer: _vitest.vi.fn()
});
(0, _vitest.describe)('SecretInjectionBuilder', () => {
  let stack;
  let provider;
  (0, _vitest.beforeEach)(() => {
    stack = createMockStack();
    provider = createMockProvider(['env']);
    stack.getComposer.mockReturnValue({
      findResourceIdsByKind: () => ['my-deployment']
    });
  });
  (0, _vitest.it)('injects using default strategy when only one kind is supported', () => {
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.inject().resolveInjection();
    (0, _vitest.expect)(stack.registerSecretInjection).toHaveBeenCalledWith(_vitest.expect.objectContaining({
      meta: {
        secretName: 'MY_SECRET',
        targetName: 'MY_SECRET'
      },
      path: ['spec.template.spec.containers[0].env']
    }));
  });
  (0, _vitest.it)('injects using custom kind and options', () => {
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.inject('env', {
      containerIndex: 1
    }).resolveInjection();
    (0, _vitest.expect)(stack.registerSecretInjection).toHaveBeenCalledWith(_vitest.expect.objectContaining({
      path: ['spec.template.spec.containers[1].env']
    }));
  });
  (0, _vitest.it)('overrides target name via .forName()', () => {
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.forName('API_KEY').inject().resolveInjection();
    (0, _vitest.expect)(stack.registerSecretInjection).toHaveBeenCalledWith(_vitest.expect.objectContaining({
      meta: _vitest.expect.objectContaining({
        targetName: 'API_KEY'
      })
    }));
  });
  (0, _vitest.it)('resolves resourceId from intoResource', () => {
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.intoResource('my-deployment').inject().resolveInjection();
    (0, _vitest.expect)(stack.registerSecretInjection).toHaveBeenCalledWith(_vitest.expect.objectContaining({
      resourceId: 'my-deployment'
    }));
  });
  (0, _vitest.it)('resolves resourceId from defaultResourceId', () => {
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider',
      defaultResourceId: 'default-deploy'
    });
    builder.inject().resolveInjection();
    (0, _vitest.expect)(stack.registerSecretInjection).toHaveBeenCalledWith(_vitest.expect.objectContaining({
      resourceId: 'default-deploy'
    }));
  });
  (0, _vitest.it)('throws if inject() is called with no args and provider supports multiple kinds', () => {
    const multiKindProvider = createMockProvider(['env', 'annotation']);
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', multiKindProvider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    (0, _vitest.expect)(() => builder.inject()).toThrowError(/requires a strategy because provider supports multiple strategies/);
  });
  (0, _vitest.it)('throws if no composer exists and resourceId is not set', () => {
    stack.getComposer.mockReturnValue(undefined);
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.inject();
    (0, _vitest.expect)(() => builder.resolveInjection()).toThrowError(/No resource composer found/);
  });
  (0, _vitest.it)('throws if multiple resource IDs found', () => {
    stack.getComposer.mockReturnValue({
      findResourceIdsByKind: () => ['res1', 'res2']
    });
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.inject();
    (0, _vitest.expect)(() => builder.resolveInjection()).toThrowError(/Multiple resourceIds found/);
  });
  (0, _vitest.it)('throws if no matching resource ID found', () => {
    stack.getComposer.mockReturnValue({
      findResourceIdsByKind: () => []
    });
    const builder = new _SecretInjectionBuilder.SecretInjectionBuilder(stack, 'MY_SECRET', provider, {
      secretManagerId: 1,
      providerId: 'my-provider'
    });
    builder.inject();
    (0, _vitest.expect)(() => builder.resolveInjection()).toThrowError(/Could not resolve resourceId/);
  });
});
//# sourceMappingURL=SecretInjectionBuilder.test.js.map