github/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-04-19 08:58:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: dedupe voice-call provider config validation cases

Browse Source
This commit is contained in:
Peter Steinberger
2026-02-19 09:24:00 +00:00
parent ba7be018da
commit c241bf0049
1 changed files with 46 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
extensions/voice-call/src/config.test.ts
View File

@@ -62,26 +62,15 @@ describe("validateProviderConfig", () => {
}); });
describe("twilio provider", () => { describe("twilio provider", () => {
it("passes validation when credentials are in config", () => { it("passes validation when credentials come from config or environment", () => {
const config = createBaseConfig("twilio"); const fromConfig = createBaseConfig("twilio");
config.twilio = { accountSid: "AC123", authToken: "secret" }; fromConfig.twilio = { accountSid: "AC123", authToken: "secret" };
expect(validateProviderConfig(fromConfig)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
});
it("passes validation when credentials are in environment variables", () => {
process.env.TWILIO_ACCOUNT_SID = "AC123"; process.env.TWILIO_ACCOUNT_SID = "AC123";
process.env.TWILIO_AUTH_TOKEN = "secret"; process.env.TWILIO_AUTH_TOKEN = "secret";
let config = createBaseConfig("twilio"); const fromEnv = resolveVoiceCallConfig(createBaseConfig("twilio"));
config = resolveVoiceCallConfig(config); expect(validateProviderConfig(fromEnv)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
}); });
it("passes validation with mixed config and env vars", () => { it("passes validation with mixed config and env vars", () => {
@@ -96,55 +85,37 @@ describe("validateProviderConfig", () => {
expect(result.errors).toEqual([]); expect(result.errors).toEqual([]);
}); });
it("fails validation when accountSid is missing everywhere", () => { it("fails validation when required twilio credentials are missing", () => {
process.env.TWILIO_AUTH_TOKEN = "secret"; process.env.TWILIO_AUTH_TOKEN = "secret";
let config = createBaseConfig("twilio"); const missingSid = validateProviderConfig(resolveVoiceCallConfig(createBaseConfig("twilio")));
config = resolveVoiceCallConfig(config); expect(missingSid.valid).toBe(false);
expect(missingSid.errors).toContain(
const result = validateProviderConfig(config);
expect(result.valid).toBe(false);
expect(result.errors).toContain(
"plugins.entries.voice-call.config.twilio.accountSid is required (or set TWILIO_ACCOUNT_SID env)", "plugins.entries.voice-call.config.twilio.accountSid is required (or set TWILIO_ACCOUNT_SID env)",
); );
});
it("fails validation when authToken is missing everywhere", () => { delete process.env.TWILIO_AUTH_TOKEN;
process.env.TWILIO_ACCOUNT_SID = "AC123"; process.env.TWILIO_ACCOUNT_SID = "AC123";
let config = createBaseConfig("twilio"); const missingToken = validateProviderConfig(
config = resolveVoiceCallConfig(config); resolveVoiceCallConfig(createBaseConfig("twilio")),
);
const result = validateProviderConfig(config); expect(missingToken.valid).toBe(false);
expect(missingToken.errors).toContain(
expect(result.valid).toBe(false);
expect(result.errors).toContain(
"plugins.entries.voice-call.config.twilio.authToken is required (or set TWILIO_AUTH_TOKEN env)", "plugins.entries.voice-call.config.twilio.authToken is required (or set TWILIO_AUTH_TOKEN env)",
); );
}); });
}); });
describe("telnyx provider", () => { describe("telnyx provider", () => {
it("passes validation when credentials are in config", () => { it("passes validation when credentials come from config or environment", () => {
const config = createBaseConfig("telnyx"); const fromConfig = createBaseConfig("telnyx");
config.telnyx = { apiKey: "KEY123", connectionId: "CONN456", publicKey: "public-key" }; fromConfig.telnyx = { apiKey: "KEY123", connectionId: "CONN456", publicKey: "public-key" };
expect(validateProviderConfig(fromConfig)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
});
it("passes validation when credentials are in environment variables", () => {
process.env.TELNYX_API_KEY = "KEY123"; process.env.TELNYX_API_KEY = "KEY123";
process.env.TELNYX_CONNECTION_ID = "CONN456"; process.env.TELNYX_CONNECTION_ID = "CONN456";
process.env.TELNYX_PUBLIC_KEY = "public-key"; process.env.TELNYX_PUBLIC_KEY = "public-key";
let config = createBaseConfig("telnyx"); const fromEnv = resolveVoiceCallConfig(createBaseConfig("telnyx"));
config = resolveVoiceCallConfig(config); expect(validateProviderConfig(fromEnv)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
}); });
it("fails validation when apiKey is missing everywhere", () => { it("fails validation when apiKey is missing everywhere", () => {
@@ -160,67 +131,45 @@ describe("validateProviderConfig", () => {
); );
}); });
it("fails validation when allowlist inbound policy lacks public key", () => { it("requires a public key unless signature verification is skipped", () => {
const config = createBaseConfig("telnyx"); const missingPublicKey = createBaseConfig("telnyx");
config.inboundPolicy = "allowlist"; missingPublicKey.inboundPolicy = "allowlist";
config.telnyx = { apiKey: "KEY123", connectionId: "CONN456" }; missingPublicKey.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
const missingPublicKeyResult = validateProviderConfig(missingPublicKey);
const result = validateProviderConfig(config); expect(missingPublicKeyResult.valid).toBe(false);
expect(missingPublicKeyResult.errors).toContain(
expect(result.valid).toBe(false);
expect(result.errors).toContain(
"plugins.entries.voice-call.config.telnyx.publicKey is required (or set TELNYX_PUBLIC_KEY env)", "plugins.entries.voice-call.config.telnyx.publicKey is required (or set TELNYX_PUBLIC_KEY env)",
); );
});
it("passes validation when allowlist inbound policy has public key", () => { const withPublicKey = createBaseConfig("telnyx");
const config = createBaseConfig("telnyx"); withPublicKey.inboundPolicy = "allowlist";
config.inboundPolicy = "allowlist"; withPublicKey.telnyx = {
config.telnyx = {
apiKey: "KEY123", apiKey: "KEY123",
connectionId: "CONN456", connectionId: "CONN456",
publicKey: "public-key", publicKey: "public-key",
}; };
expect(validateProviderConfig(withPublicKey)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config); const skippedVerification = createBaseConfig("telnyx");
skippedVerification.skipSignatureVerification = true;
expect(result.valid).toBe(true); skippedVerification.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
expect(result.errors).toEqual([]); expect(validateProviderConfig(skippedVerification)).toMatchObject({
}); valid: true,
errors: [],
it("passes validation when skipSignatureVerification is true (even without public key)", () => { });
const config = createBaseConfig("telnyx");
config.skipSignatureVerification = true;
config.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
}); });
}); });
describe("plivo provider", () => { describe("plivo provider", () => {
it("passes validation when credentials are in config", () => { it("passes validation when credentials come from config or environment", () => {
const config = createBaseConfig("plivo"); const fromConfig = createBaseConfig("plivo");
config.plivo = { authId: "MA123", authToken: "secret" }; fromConfig.plivo = { authId: "MA123", authToken: "secret" };
expect(validateProviderConfig(fromConfig)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
});
it("passes validation when credentials are in environment variables", () => {
process.env.PLIVO_AUTH_ID = "MA123"; process.env.PLIVO_AUTH_ID = "MA123";
process.env.PLIVO_AUTH_TOKEN = "secret"; process.env.PLIVO_AUTH_TOKEN = "secret";
let config = createBaseConfig("plivo"); const fromEnv = resolveVoiceCallConfig(createBaseConfig("plivo"));
config = resolveVoiceCallConfig(config); expect(validateProviderConfig(fromEnv)).toMatchObject({ valid: true, errors: [] });
const result = validateProviderConfig(config);
expect(result.valid).toBe(true);
expect(result.errors).toEqual([]);
}); });
it("fails validation when authId is missing everywhere", () => { it("fails validation when authId is missing everywhere", () => {