John Dvorak
717ae1031e
Zanzibar-style authorization graph engine (direct/chain/TTU/defeasible/ binary modes, condensed snapshots, value relations) with 39 rigor test campaigns. Includes fixes for snapshot binary writer/reader format mismatch (snapshot-of-snapshot corruption), possibility write-boundary validation, empty-graph snapshot serialization, relation lookup cache direction collision, config-redefinition cache invalidation, binary threshold semantics, defeasible compiled routing, and comparator reason whitelisting.
348 lines
12 KiB
JavaScript
348 lines
12 KiB
JavaScript
/**
|
|
* Expression Parsing Tests
|
|
*
|
|
* Tests the expression parsing capabilities of the Evidence DSL,
|
|
* focusing on operator precedence, associativity, and complex expressions.
|
|
*/
|
|
|
|
import { DSLCompiler } from '../DSLCompiler.js';
|
|
|
|
export class ExpressionTests {
|
|
constructor() {
|
|
this.arbiter = null;
|
|
this.compiler = null;
|
|
this.testResults = [];
|
|
}
|
|
|
|
setup(arbiter) {
|
|
this.arbiter = arbiter;
|
|
this.compiler = new DSLCompiler(arbiter);
|
|
}
|
|
|
|
runAllTests() {
|
|
console.log('=== Expression Parsing Tests ===\n');
|
|
|
|
this.testArithmeticPrecedence();
|
|
this.testLogicalPrecedence();
|
|
this.testComparisonOperators();
|
|
this.testTemporalExpressions();
|
|
this.testUnaryOperators();
|
|
this.testAttributeAccess();
|
|
this.testFunctionCalls();
|
|
this.testComplexExpressions();
|
|
this.testExpressionErrors();
|
|
|
|
return this.getTestResults();
|
|
}
|
|
|
|
testArithmeticPrecedence() {
|
|
console.log('Testing Arithmetic Operator Precedence...');
|
|
|
|
const testCases = [
|
|
{
|
|
input: '1 + 2 * 3',
|
|
expected: 'Should evaluate as 1 + (2 * 3) = 7',
|
|
description: 'Multiplication before addition'
|
|
},
|
|
{
|
|
input: '10 - 3 * 2',
|
|
expected: 'Should evaluate as 10 - (3 * 2) = 4',
|
|
description: 'Multiplication before subtraction'
|
|
},
|
|
{
|
|
input: '8 / 2 * 4',
|
|
expected: 'Should evaluate as (8 / 2) * 4 = 16',
|
|
description: 'Left-associative division and multiplication'
|
|
},
|
|
{
|
|
input: '2 + 3 * 4 - 5',
|
|
expected: 'Should evaluate as 2 + (3 * 4) - 5 = 9',
|
|
description: 'Mixed arithmetic with correct precedence'
|
|
},
|
|
{
|
|
input: '(1 + 2) * 3',
|
|
expected: 'Should evaluate as (1 + 2) * 3 = 9',
|
|
description: 'Parentheses override precedence'
|
|
}
|
|
];
|
|
|
|
testCases.forEach(({ input, expected, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-arithmetic-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Arithmetic precedence test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testLogicalPrecedence() {
|
|
console.log('Testing Logical Operator Precedence...');
|
|
|
|
const testCases = [
|
|
{
|
|
input: 'true && false || true',
|
|
expected: 'Should evaluate as (true && false) || true = true',
|
|
description: 'AND before OR'
|
|
},
|
|
{
|
|
input: 'false || true && false',
|
|
expected: 'Should evaluate as false || (true && false) = false',
|
|
description: 'AND before OR (alternative)'
|
|
},
|
|
{
|
|
input: 'NOT true && false',
|
|
expected: 'Should evaluate as (NOT true) && false = false',
|
|
description: 'NOT before AND'
|
|
},
|
|
{
|
|
input: 'true && NOT false',
|
|
expected: 'Should evaluate as true && (NOT false) = true',
|
|
description: 'NOT before AND (alternative)'
|
|
},
|
|
{
|
|
input: '(true || false) && true',
|
|
expected: 'Should evaluate as (true || false) && true = true',
|
|
description: 'Parentheses override logical precedence'
|
|
}
|
|
];
|
|
|
|
testCases.forEach(({ input, expected, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-logical-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Logical precedence test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testComparisonOperators() {
|
|
console.log('Testing Comparison Operators...');
|
|
|
|
const testCases = [
|
|
{ input: '1 == 1', description: 'Equality comparison' },
|
|
{ input: '1 != 2', description: 'Inequality comparison' },
|
|
{ input: '5 > 3', description: 'Greater than' },
|
|
{ input: '3 < 5', description: 'Less than' },
|
|
{ input: '4 >= 4', description: 'Greater than or equal' },
|
|
{ input: '4 <= 4', description: 'Less than or equal' },
|
|
{ input: '1 == 1 && 2 > 1', description: 'Comparison with logical operators' },
|
|
{ input: '1 + 2 == 3', description: 'Arithmetic in comparison' }
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-comparison-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Comparison test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testTemporalExpressions() {
|
|
console.log('Testing Temporal Expressions...');
|
|
|
|
const testCases = [
|
|
{ input: 'user.lastActive within 1h', description: 'Temporal within expression' },
|
|
{ input: 'user.lastLogin within 24h', description: 'Temporal within with hours' },
|
|
{ input: 'user.createdAt within 7d', description: 'Temporal within with days' },
|
|
{ input: 'user.lastActivity within 1h && user.isActive', description: 'Temporal with logical operators' }
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-temporal-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Temporal test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testUnaryOperators() {
|
|
console.log('Testing Unary Operators...');
|
|
|
|
const testCases = [
|
|
{ input: 'NOT true', description: 'NOT operator' },
|
|
{ input: '!false', description: 'Alternative NOT operator' },
|
|
{ input: 'NOT (true && false)', description: 'NOT with parenthesized expression' },
|
|
{ input: 'NOT user.isSuspended', description: 'NOT with attribute access' }
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-unary-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Unary test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testAttributeAccess() {
|
|
console.log('Testing Attribute Access...');
|
|
|
|
const testCases = [
|
|
{ input: 'user.role', description: 'Simple attribute access' },
|
|
{ input: 'user.profile.name', description: 'Nested attribute access' },
|
|
{ input: 'user.permissions[0]', description: 'Array access' },
|
|
{ input: 'user.role.permissions[0]', description: 'Nested attribute with array access' },
|
|
{ input: 'user.isActive && user.role == "admin"', description: 'Attribute access in logical expression' }
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-attribute-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Attribute access test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testFunctionCalls() {
|
|
console.log('Testing Function Calls...');
|
|
|
|
const testCases = [
|
|
{ input: 'hasRole(user, "admin")', description: 'Simple function call' },
|
|
{ input: 'isMember(user, group)', description: 'Function call with variables' },
|
|
{ input: 'hasPermission(user, resource, "read")', description: 'Function call with multiple arguments' },
|
|
{ input: 'hasRole(user, "admin") && isActive(user)', description: 'Multiple function calls' },
|
|
{ input: 'hasRole(user, user.role)', description: 'Function call with attribute access' }
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-function-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Function call test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testComplexExpressions() {
|
|
console.log('Testing Complex Expressions...');
|
|
|
|
const testCases = [
|
|
{
|
|
input: 'user.isActive && (hasRole(user, "admin") || hasPermission(user, resource, "read"))',
|
|
description: 'Complex logical expression with function calls'
|
|
},
|
|
{
|
|
input: 'user.balance > 100 && user.isActive && NOT user.isSuspended',
|
|
description: 'Multiple conditions with NOT'
|
|
},
|
|
{
|
|
input: 'user.lastActive within 1h && (user.role == "admin" || user.hasEmergencyAccess)',
|
|
description: 'Temporal with logical conditions'
|
|
},
|
|
{
|
|
input: 'hasRole(user, "admin") && user.isActive && NOT (user.isSuspended || user.isBlacklisted)',
|
|
description: 'Complex negation with multiple conditions'
|
|
},
|
|
{
|
|
input: 'user.score > 0.8 && user.isTrusted && user.lastActivity within 24h',
|
|
description: 'Multiple attribute conditions with temporal'
|
|
}
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-complex-${Date.now()}`);
|
|
this.assert(result.success, `${description} should parse successfully`);
|
|
console.log(` ✓ ${description}`);
|
|
} catch (error) {
|
|
this.fail(`Complex expression test: ${description}`, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
testExpressionErrors() {
|
|
console.log('Testing Expression Error Handling...');
|
|
|
|
const testCases = [
|
|
{
|
|
input: 'user.role ==',
|
|
description: 'Incomplete comparison should fail'
|
|
},
|
|
{
|
|
input: 'user.role &&',
|
|
description: 'Incomplete logical expression should fail'
|
|
},
|
|
{
|
|
input: 'hasRole(user,)',
|
|
description: 'Function call with missing argument should fail'
|
|
},
|
|
{
|
|
input: 'user.role == "admin" &&',
|
|
description: 'Incomplete logical expression should fail'
|
|
}
|
|
];
|
|
|
|
testCases.forEach(({ input, description }) => {
|
|
try {
|
|
const dsl = `evidence test() { ${input} }`;
|
|
const result = this.compiler.compile(dsl, `test-error-${Date.now()}`);
|
|
this.assert(!result.success, `${description} should fail to parse`);
|
|
console.log(` ✓ ${description} (correctly failed)`);
|
|
} catch (error) {
|
|
// Expected to fail
|
|
console.log(` ✓ ${description} (correctly failed)`);
|
|
}
|
|
});
|
|
}
|
|
|
|
assert(condition, message) {
|
|
if (!condition) {
|
|
throw new Error(`Assertion failed: ${message}`);
|
|
}
|
|
}
|
|
|
|
fail(testName, error) {
|
|
console.log(` ✗ ${testName} failed: ${error.message}`);
|
|
this.testResults.push({
|
|
test: testName,
|
|
status: 'FAILED',
|
|
error: error.message
|
|
});
|
|
}
|
|
|
|
getTestResults() {
|
|
const passed = this.testResults.filter(r => r.status === 'PASSED').length;
|
|
const failed = this.testResults.filter(r => r.status === 'FAILED').length;
|
|
const total = this.testResults.length;
|
|
|
|
return {
|
|
total: total,
|
|
passed: passed,
|
|
failed: failed,
|
|
success: failed === 0,
|
|
results: this.testResults
|
|
};
|
|
}
|
|
}
|
|
|
|
export function runExpressionTests(arbiter) {
|
|
const test = new ExpressionTests();
|
|
test.setup(arbiter);
|
|
return test.runAllTests();
|
|
}
|