Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test runs only with pattern: os != 'android'
- Manifest: browser/components/aiwindow/models/tests/xpcshell/xpcshell.toml
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/**
* Tests for validating tool definitions in Tools.sys.mjs
*
* The tests are designed to verify that tool definitions are in compliance
* with the OpenAI API standard.
*
* These tests ensure that:
* 1. Tool definitions have the correct structure
* 2. Parameters match what the actual functions accept
* 3. Required fields are present and correctly specified
* 4. Parameter types are valid and consistent
*/
const { toolsConfig, TOOLS } = ChromeUtils.importESModule(
"moz-src:///browser/components/aiwindow/models/Tools.sys.mjs"
);
/**
* Test that all tool definitions have the required top-level structure
*/
add_task(function test_toolDefinitions_structure() {
Assert.ok(Array.isArray(toolsConfig), "toolsConfig should be an array");
Assert.equal(
toolsConfig.length,
TOOLS.length,
"toolsConfig length should match TOOLS length"
);
for (const [index, toolDef] of toolsConfig.entries()) {
Assert.equal(
toolDef.type,
"function",
`Tool ${index} should have type "function"`
);
Assert.ok(
toolDef.function,
`Tool ${index} should have a function property`
);
Assert.equal(
typeof toolDef.function.name,
"string",
`Tool ${index} function.name should be a string`
);
Assert.greater(
toolDef.function.name.length,
0,
`Tool ${index} function.name should not be empty`
);
Assert.equal(
typeof toolDef.function.description,
"string",
`Tool ${index} function.description should be a string`
);
Assert.greater(
toolDef.function.description.length,
0,
`Tool ${index} function.description should not be empty`
);
Assert.ok(
toolDef.function.parameters,
`Tool ${index} should have parameters`
);
Assert.equal(
toolDef.function.parameters.type,
"object",
`Tool ${index} parameters.type should be "object"`
);
}
});
/**
* Test that all tool names in TOOLS array match the tool definitions
*/
add_task(function test_toolDefinitions_names_match_constants() {
const definedNames = toolsConfig.map(t => t.function.name);
const expectedNames = TOOLS;
Assert.deepEqual(
definedNames.sort(),
expectedNames.sort(),
"Tool names in toolsConfig should match TOOLS constant"
);
});
/**
* Test that all parameter types are valid JSON Schema types
*/
add_task(function test_parameter_types_are_valid() {
const validTypes = [
"string",
"number",
"integer",
"boolean",
"array",
"object",
"null",
];
for (const toolDef of toolsConfig) {
const props = toolDef.function.parameters.properties;
for (const [paramName, paramDef] of Object.entries(props)) {
Assert.ok(
validTypes.includes(paramDef.type),
`Parameter ${paramName} in ${toolDef.function.name} should have valid JSON Schema type`
);
// If it's an array, check items type
if (paramDef.type === "array" && paramDef.items) {
Assert.ok(
validTypes.includes(paramDef.items.type),
`Array items type for ${paramName} in ${toolDef.function.name} should be valid`
);
}
}
}
});
/**
* Test that all parameters have non-empty descriptions
*/
add_task(function test_parameter_descriptions_are_meaningful() {
for (const toolDef of toolsConfig) {
const props = toolDef.function.parameters.properties;
for (const [paramName, paramDef] of Object.entries(props)) {
Assert.greater(
paramDef.description.length,
10,
`Parameter ${paramName} in ${toolDef.function.name} should have meaningful description (>10 chars)`
);
// Check nested items descriptions for arrays
if (paramDef.type === "array" && paramDef.items?.description) {
Assert.greater(
paramDef.items.description.length,
10,
`Array items description for ${paramName} in ${toolDef.function.name} should be meaningful`
);
}
}
}
});
/**
* Test that required parameters are actually defined in properties
*/
add_task(function test_required_parameters_exist_in_properties() {
for (const toolDef of toolsConfig) {
const params = toolDef.function.parameters;
if (params.required) {
Assert.ok(
Array.isArray(params.required),
`Tool ${toolDef.function.name} required field should be an array if present`
);
for (const requiredParam of params.required) {
Assert.ok(
params.properties[requiredParam],
`Required parameter ${requiredParam} in ${toolDef.function.name} should exist in properties`
);
}
}
}
});