LibreChat/helm/librechat/tests/channel_gateway_render_test.mjs
Dustin Healy 1f27f5848a
📦 feat: Package Shared Slack Workspace Deployments (#17815)
* feat: Package Shared Slack Workspace Deployments

* fix: Require Explicit Shared Slack Deployment Prerequisites

* fix: Validate Public Slack Deployment Origins

* fix: Keep Shared Slack App Setup in Organization Administration

* 🔧 fix: Validate Shared Gateway Deployment Prerequisites
2026-11-10 21:04:10 -08:00

470 lines
18 KiB
JavaScript

import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { copyFileSync, mkdtempSync, readFileSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { resolve, join } from 'node:path';
import { fileURLToPath } from 'node:url';
import yaml from 'js-yaml';
import { loadConfig, loadBootstrap } from '../../../packages/channel-gateway/src/config.ts';
const chart = fileURLToPath(new URL('..', import.meta.url));
const fixture = mkdtempSync(join(tmpdir(), 'channel-gateway-chart-'));
try {
// Render the real gateway and main Service without downloading unrelated subcharts.
mkdirSync(join(fixture, 'templates'));
writeFileSync(
join(fixture, 'templates', '_mongodb.tpl'),
`
{{- define "mongodb.secretName" -}}fixture-mongodb{{- end -}}
{{- define "mongodb.service.nameOverride" -}}fixture-mongodb{{- end -}}
`,
);
const metadata = yaml.load(readFileSync(resolve(chart, 'Chart.yaml'), 'utf8'));
delete metadata.dependencies;
writeFileSync(join(fixture, 'Chart.yaml'), yaml.dump(metadata));
const defaults = yaml.load(readFileSync(resolve(chart, 'values.yaml'), 'utf8'));
for (const name of ['mongodb', 'meilisearch', 'redis']) defaults[name].enabled = false;
writeFileSync(join(fixture, 'values.yaml'), yaml.dump(defaults));
for (const file of [
'_helpers.tpl',
'service.yaml',
'deployment.yaml',
'configmap-env.yaml',
'serviceaccount.yaml',
'channel-gateway.yaml',
'channel-gateway-ingress.yaml',
'ingress.yaml',
]) {
copyFileSync(resolve(chart, 'templates', file), join(fixture, 'templates', file));
}
function render(values = {}, platform = {}, kubeVersion) {
writeFileSync(join(fixture, 'platform.yaml'), yaml.dump(platform));
return yaml
.loadAll(
execFileSync(
'helm',
[
'template',
'fixture',
fixture,
'-f',
join(fixture, 'platform.yaml'),
...(kubeVersion ? ['--kube-version', kubeVersion] : []),
...Object.entries(values).flatMap(([key, value]) => [
typeof value === 'boolean' ? '--set' : '--set-string',
`${key}=${value}`,
]),
],
{ encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
),
)
.filter(Boolean);
}
assert.equal(
render().filter((doc) => doc.kind === 'Deployment').length,
1,
'disabled gateway must leave only the application Deployment',
);
const enabled = {
'channelGateway.enabled': true,
'channelGateway.channelId': 'connection',
'image.tag': 'v1.2.3',
};
assert.throws(() => render({ 'channelGateway.enabled': true }), /Set image.tag/);
assert.throws(() => render({ ...enabled, 'image.tag': '' }), /Set image.tag/);
assert.throws(
() => render({ ...enabled, 'image.tag': '', 'channelGateway.image.tag': 'v1.2.3' }),
/Set image.tag/,
);
assert.throws(
() => render({ ...enabled, 'channelGateway.channelId': '' }),
/channelGateway.channelId/,
);
assert.throws(
() => render({ ...enabled, 'channelGateway.mode': 'invalid' }),
/channelGateway.mode/,
);
assert.throws(() => render({ ...enabled, 'channelGateway.mode': 'shared' }), /empty channelId/);
const shared = {
...enabled,
'channelGateway.mode': 'shared',
'channelGateway.channelId': '',
};
assert.throws(
() => render({ ...shared, 'mongodb.enabled': true }),
/transaction-capable MongoDB/,
);
assert.throws(
() => render({ ...shared, 'mongodb.enabled': true, 'mongodb.architecture': 'standalone' }),
/transaction-capable MongoDB/,
);
assert.doesNotThrow(() =>
render({ ...shared, 'mongodb.enabled': true, 'mongodb.architecture': 'replicaset' }),
);
for (const platform of [
{ librechat: { configEnv: { MONGO_URI: 'mongodb://external/LibreChat' } } },
{
global: {
librechat: {
env: [
{ name: 'MONGO_URI', valueFrom: { secretKeyRef: { name: 'external-db', key: 'uri' } } },
],
},
},
},
{
librechat: { injectBundledCredentials: { mongodb: false } },
global: { librechat: { existingSecretName: 'external-db' } },
},
])
assert.doesNotThrow(() => render({ ...shared, 'mongodb.enabled': true }, platform));
assert.throws(
() => render({ ...shared, 'channelGateway.tenantId': 'org.a' }),
/default tenantId/,
);
const sharedDeployment = render(shared).find(
(doc) =>
doc.kind === 'Deployment' && doc.spec.template.spec.containers[0].name === 'channel-gateway',
);
const sharedEnv = sharedDeployment.spec.template.spec.containers[0].env;
for (const name of ['CHANNEL_ID', 'CHANNEL_TENANT_ID', 'SLACK_APP_TOKEN'])
assert(!sharedEnv.some((entry) => entry.name === name), `shared pods must not import ${name}`);
const bootstrap = loadBootstrap({
...Object.fromEntries(
sharedEnv.filter((entry) => 'value' in entry).map((entry) => [entry.name, entry.value]),
),
CHANNEL_SERVICE_TOKEN: 'fixture',
});
assert.equal(
bootstrap.mode,
'shared',
'rendered shared pods must select the actual shared runtime',
);
assert.equal(sharedDeployment.spec.strategy.type, 'RollingUpdate');
for (const count of ['0', '-1', '1.5', 'invalid'])
assert.throws(
() => render({ ...shared, 'channelGateway.replicaCount': count }),
/positive integer/,
);
assert.throws(
() => render({ ...enabled, 'channelGateway.replicaCount': '2' }),
/Single gateway mode/,
);
const sharedDocs = render(
{ ...shared, 'channelGateway.replicaCount': '2' },
{
channelGateway: {
existingSecretName: 'service-credentials',
ingress: { enabled: true, host: 'slack.example.test' },
},
},
);
const gatewayPod = sharedDocs.find(
(doc) => doc.kind === 'Deployment' && doc.metadata.name === sharedDeployment.metadata.name,
);
assert.equal(gatewayPod.spec.replicas, 2);
assert.deepEqual(gatewayPod.spec.strategy.rollingUpdate, { maxSurge: 1, maxUnavailable: 0 });
const apiPod = sharedDocs.find((doc) => doc.kind === 'Deployment' && doc !== gatewayPod);
const apiEnv = Object.fromEntries(
apiPod.spec.template.spec.containers[0].env.map((entry) => [entry.name, entry]),
);
assert.equal(apiEnv.CHANNEL_SERVICE_TOKEN.valueFrom.secretKeyRef.name, 'service-credentials');
for (const key of [
'SLACK_APP_ID',
'SLACK_CLIENT_ID',
'SLACK_CLIENT_SECRET',
'SLACK_SIGNING_SECRET',
])
assert.equal(
apiEnv[key],
undefined,
'organization app credentials must not be injected by the chart',
);
const appDefaults = sharedDocs.find(
(doc) => doc.kind === 'ConfigMap' && doc.metadata.name.endsWith('-configenv'),
).data;
assert.equal(appDefaults.SLACK_WORKSPACES_ENABLED, 'true');
assert.equal(appDefaults.SLACK_GATEWAY_URL, 'https://slack.example.test');
const gatewaySecrets = gatewayPod.spec.template.spec.containers[0].env.filter(
(entry) => entry.valueFrom,
);
assert.deepEqual(
gatewaySecrets.map((entry) => entry.name),
['CHANNEL_SERVICE_TOKEN'],
);
const explicit = render(shared, {
global: {
librechat: {
env: [
{
name: 'CHANNEL_SERVICE_TOKEN',
valueFrom: { secretKeyRef: { name: 'explicit', key: 'service' } },
},
],
},
},
}).find(
(doc) => doc.kind === 'Deployment' && doc.metadata.name !== sharedDeployment.metadata.name,
);
const explicitEnv = explicit.spec.template.spec.containers[0].env;
assert.equal(explicitEnv.filter((entry) => entry.name === 'CHANNEL_SERVICE_TOKEN').length, 1);
assert.equal(
explicitEnv.find((entry) => entry.name === 'CHANNEL_SERVICE_TOKEN').valueFrom.secretKeyRef.name,
'explicit',
);
assert.throws(
() => render({ ...enabled, 'global.librechat.existingSecretName': '' }),
/existingSecretName/,
);
for (const overrides of [
{},
{ 'librechat.configEnv.APP_TITLE': 'Example Agents' },
{ 'librechat.configEnv.APP_TITLE': 'é'.repeat(40) },
{ 'librechat.configEnv.APP_TITLE': '😀'.repeat(20) },
{ 'librechat.configEnv.APP_TITLE': '\ufeff Example Agents \ufeff' },
{ 'librechat.configEnv.APP_TITLE': 'x'.repeat(41), 'channelGateway.appTitle': 'Short Title' },
{
'librechat.configEnv.APP_TITLE': 'Example Agents',
'channelGateway.appTitle': 'Custom Agents',
},
{ fullnameOverride: 'a'.repeat(47) + '-channel-gateway' },
{ 'channelGateway.image.tag': 'a'.repeat(128) },
{ 'channelGateway.image.tag': '_custom_' },
{ 'image.tag': 'v1.2.3-rc1', 'service.port': '9090' },
{
'channelGateway.image.tag': 'v1.2.4',
'channelGateway.existingSecretName': 'gateway-only',
'channelGateway.slackAppTokenKey': '',
fullnameOverride: 'a'.repeat(63),
},
]) {
const docs = render({ ...enabled, ...overrides });
const deployment = docs.find(
(doc) =>
doc.kind === 'Deployment' &&
doc.spec.template.spec.containers.some((container) => container.name === 'channel-gateway'),
);
const service = docs.find(
(doc) => doc.metadata.name === deployment.metadata.name && doc.kind === 'Service',
);
const mainService = docs.find((doc) => doc.kind === 'Service' && doc !== service);
const pod = deployment.spec.template;
const container = pod.spec.containers[0];
const env = Object.fromEntries(container.env.map((entry) => [entry.name, entry]));
const matches = (selector) =>
Object.entries(selector).every(([key, value]) => pod.metadata.labels[key] === value);
assert(!matches(mainService.spec.selector), 'application traffic must never reach the gateway');
assert(matches(service.spec.selector));
assert(matches(deployment.spec.selector.matchLabels));
assert(deployment.metadata.name.length <= 63);
const version =
overrides['channelGateway.image.tag'] || overrides['image.tag'] || enabled['image.tag'];
const labelVersion = version.slice(0, 63).replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, '');
assert.equal(deployment.metadata.labels['app.kubernetes.io/version'], labelVersion);
assert.equal(pod.metadata.labels['app.kubernetes.io/version'], labelVersion);
assert.equal(service.metadata.labels['app.kubernetes.io/version'], labelVersion);
assert.equal(service.spec.type, 'ClusterIP');
assert.equal(
container.image,
`ghcr.io/librechat-ai/librechat-channel-gateway:${overrides['channelGateway.image.tag'] || overrides['image.tag'] || enabled['image.tag']}`,
);
assert.equal(
env.LIBRECHAT_INTERNAL_URL.value,
`http://${mainService.metadata.name}:${overrides['service.port'] || 3080}`,
);
assert.equal(
env.CHANNEL_SERVICE_TOKEN.valueFrom.secretKeyRef.name,
overrides['channelGateway.existingSecretName'] || 'librechat-credentials-env',
);
assert.equal(
container.envFrom,
undefined,
'gateway must not import unrelated application secrets',
);
assert.equal(
env.APP_TITLE.value,
(
overrides['channelGateway.appTitle'] ||
overrides['librechat.configEnv.APP_TITLE'] ||
'LibreChat'
).trim(),
);
const runtime = loadConfig({
CHANNEL_SERVICE_TOKEN: 'fixture',
CHANNEL_TENANT_ID: '_',
CHANNEL_ID: 'fixture',
APP_TITLE: env.APP_TITLE.value,
});
assert.equal(
runtime.APP_TITLE,
env.APP_TITLE.value,
'accepted Helm titles must satisfy the actual runtime schema',
);
assert.notEqual(deployment.metadata.name, mainService.metadata.name);
assert.equal(Boolean(env.SLACK_APP_TOKEN), overrides['channelGateway.slackAppTokenKey'] !== '');
assert.equal(container.livenessProbe.httpGet.path, '/livez');
assert.equal(container.readinessProbe.httpGet.path, '/readyz');
assert.equal(pod.spec.automountServiceAccountToken, false);
assert.equal(container.securityContext.readOnlyRootFilesystem, true);
assert.equal(deployment.spec.strategy.type, 'Recreate');
}
for (const title of ['x'.repeat(41), '😀'.repeat(21), '<title>', 'a|b', '\u0085', '\ufeff']) {
assert.throws(
() => render(enabled, { librechat: { configEnv: { APP_TITLE: title } } }),
/channelGateway.appTitle/,
);
assert.throws(
() => render({ ...enabled, 'channelGateway.appTitle': title }),
/channelGateway.appTitle/,
);
}
assert.doesNotThrow(
() => render({}, { librechat: { configEnv: { APP_TITLE: 'x'.repeat(41) } } }),
'disabled gateways must not restrict the application title',
);
assert.throws(
() => render({}, { channelGateway: { ingress: { enabled: true } } }),
/Enable channelGateway/,
);
assert.throws(
() => render(enabled, { channelGateway: { ingress: { enabled: true } } }),
/ingress.host/,
);
assert.throws(
() =>
render(
enabled,
{ channelGateway: { ingress: { enabled: true, host: 'gateway.example.test' } } },
'1.18.20',
),
/Kubernetes 1.19/,
);
const webhooks = render(enabled, {
ingress: {
enabled: true,
className: 'platform-controller',
annotations: { apiOnly: 'fixture' },
hosts: [{ host: 'gateway.example.test', paths: [{ path: '/', pathType: 'Prefix' }] }],
},
channelGateway: {
slackAppTokenKey: '',
ingress: {
enabled: true,
host: 'gateway.example.test',
annotations: { callback: 'fixture' },
tls: [{ hosts: ['gateway.example.test'], secretName: 'gateway-tls' }],
},
},
});
const webhookDeployment = webhooks.find(
(doc) =>
doc.kind === 'Deployment' && doc.spec.template.spec.containers[0].name === 'channel-gateway',
);
const webhookIngress = webhooks.find(
(doc) => doc.kind === 'Ingress' && doc.metadata.name === webhookDeployment.metadata.name,
);
const apiIngress = webhooks.find((doc) => doc.kind === 'Ingress' && doc !== webhookIngress);
assert.equal(webhookIngress.spec.ingressClassName, 'platform-controller');
assert.equal(webhookIngress.spec.tls[0].secretName, 'gateway-tls');
assert.equal(
webhookIngress.metadata.annotations.apiOnly,
undefined,
'API rewrite annotations must not alter gateway callbacks',
);
assert.deepEqual(
webhookIngress.spec.rules[0].http.paths.map((route) => route.path),
['/slack/events', '/slack/interactions'],
);
for (const route of webhookIngress.spec.rules[0].http.paths) {
assert.equal(route.pathType, 'Prefix');
assert.equal(route.backend.service.name, webhookDeployment.metadata.name);
assert.equal(route.backend.service.port.number, 8080);
assert.notEqual(
route.backend.service.name,
apiIngress.spec.rules[0].http.paths[0].backend.service.name,
);
}
assert(
!webhookDeployment.spec.template.spec.containers[0].env.some(
(entry) => entry.name === 'SLACK_APP_TOKEN',
),
);
const ownClass = render(enabled, {
channelGateway: {
ingress: { enabled: true, host: 'gateway.example.test', className: 'gateway-controller' },
},
}).find((doc) => doc.kind === 'Ingress');
assert.equal(ownClass.spec.ingressClassName, 'gateway-controller');
const platform = {
serviceAccount: { create: false, name: 'workload-account' },
enableServiceLinks: false,
hostAliases: [{ ip: '127.0.0.2', hostnames: ['fixture.invalid'] }],
dnsPolicy: 'ClusterFirst',
dnsConfig: { options: [{ name: 'ndots', value: '2' }] },
imagePullSecrets: [{ name: 'registry-credentials' }],
nodeSelector: { 'kubernetes.io/os': 'linux' },
tolerations: [{ key: 'dedicated', operator: 'Exists', effect: 'NoSchedule' }],
affinity: { podAntiAffinity: { preferredDuringSchedulingIgnoredDuringExecution: [] } },
podAnnotations: { platform: 'fixture' },
podLabels: { platform: 'fixture' },
deploymentAnnotations: { platform: 'fixture' },
deploymentLabels: { platform: 'fixture' },
securityContext: { runAsUser: 10001 },
};
const deployments = render(enabled, platform).filter((doc) => doc.kind === 'Deployment');
const gateway = deployments.find(
(doc) => doc.spec.template.spec.containers[0].name === 'channel-gateway',
);
const app = deployments.find((doc) => doc !== gateway);
const spec = gateway.spec.template.spec;
for (const key of [
'serviceAccountName',
'enableServiceLinks',
'hostAliases',
'dnsPolicy',
'dnsConfig',
'imagePullSecrets',
'nodeSelector',
'tolerations',
'affinity',
]) {
assert.deepEqual(spec[key], app.spec.template.spec[key], `gateway must honor shared ${key}`);
if (key !== 'serviceAccountName')
assert.deepEqual(spec[key], platform[key], `configured ${key} must survive rendering`);
}
assert.equal(spec.serviceAccountName, 'workload-account');
assert.equal(spec.enableServiceLinks, false);
assert.equal(spec.containers[0].securityContext.runAsUser, 10001);
assert.equal(spec.containers[0].securityContext.readOnlyRootFilesystem, true);
assert.equal(spec.automountServiceAccountToken, false);
assert.equal(gateway.spec.template.metadata.annotations.platform, 'fixture');
assert.equal(gateway.spec.template.metadata.labels.platform, 'fixture');
assert.equal(gateway.metadata.annotations.platform, 'fixture');
assert.equal(gateway.metadata.labels.platform, 'fixture');
assert.equal(spec.containers[0].envFrom, undefined);
const defaultGateway = render(enabled).find(
(doc) =>
doc.kind === 'Deployment' && doc.spec.template.spec.containers[0].name === 'channel-gateway',
);
assert.equal(defaultGateway.spec.template.spec.serviceAccountName, 'fixture-librechat');
assert.equal(defaultGateway.spec.template.spec.enableServiceLinks, true);
const clearedSecurity = render(enabled, { securityContext: null, podSecurityContext: null }).find(
(doc) =>
doc.kind === 'Deployment' && doc.spec.template.spec.containers[0].name === 'channel-gateway',
);
assert.equal(clearedSecurity.spec.template.spec.containers[0].securityContext.runAsUser, 1000);
assert.deepEqual(
clearedSecurity.spec.template.spec.containers[0].securityContext.capabilities.drop,
['ALL'],
);
assert.equal(
app.metadata.labels['app.kubernetes.io/version'],
metadata.appVersion,
'existing application labels must remain unchanged',
);
console.log(
'PASS: optional gateway rendering, image matching, secret isolation, selectors and probes',
);
} finally {
rmSync(fixture, { recursive: true, force: true });
}