@balena/abstract-sql-compiler 10.2.3-build-renovate-major-22-node-d6c0f904df738bdfb51aa65395e2b146a26000e6-1 → 10.2.3-build-tests-0edb21cc4ee30ead2a6eeb290623f3a0adc7a0fe-1

package/test/abstract-sql/math.ts

@@ -1,22 +1,11 @@
-import type { AnyTypeNodes } from '../../src/AbstractSQLCompiler';
-
-type TestCb = (
-	result: { query: string },
-	sqlEquals: (a: string, b: string) => void,
-) => void;
-import $test from './test';
-const test = $test as (
-	query: AnyTypeNodes,
-	binds: any[][] | TestCb,
-	cb?: TestCb,
-) => void;
+import test from './test';
 
 describe('Add', () => {
 	test(
 		['SelectQuery', ['Select', [['Add', ['Number', 5], ['Number', 3]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement', () => {
-				sqlEquals(result.query, 'SELECT 5 + 3');
+				sqlEquals(result, 'SELECT 5 + 3');
 			});
 		},
 	);
@@ -27,7 +16,7 @@ describe('Subtract', () => {
 		['SelectQuery', ['Select', [['Subtract', ['Number', 5], ['Number', 3]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Subtract statement', () => {
-				sqlEquals(result.query, 'SELECT 5 - 3');
+				sqlEquals(result, 'SELECT 5 - 3');
 			});
 		},
 	);
@@ -38,7 +27,7 @@ describe('Multiply', () => {
 		['SelectQuery', ['Select', [['Multiply', ['Number', 5], ['Number', 3]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement', () => {
-				sqlEquals(result.query, 'SELECT 5 * 3');
+				sqlEquals(result, 'SELECT 5 * 3');
 			});
 		},
 	);
@@ -49,7 +38,7 @@ describe('Divide', () => {
 		['SelectQuery', ['Select', [['Divide', ['Number', 10], ['Number', 5]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Divide statement', () => {
-				sqlEquals(result.query, 'SELECT 10 / 5');
+				sqlEquals(result, 'SELECT 10 / 5');
 			});
 		},
 	);
@@ -63,7 +52,7 @@ describe('BitwiseAnd', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid BitwiseAnd statement', () => {
-				sqlEquals(result.query, 'SELECT 10 & 5');
+				sqlEquals(result, 'SELECT 10 & 5');
 			});
 		},
 	);
@@ -77,7 +66,7 @@ describe('BitwiseShiftRight', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid BitwiseShiftRight statement', () => {
-				sqlEquals(result.query, 'SELECT 10 >> 5');
+				sqlEquals(result, 'SELECT 10 >> 5');
 			});
 		},
 	);
@@ -88,7 +77,7 @@ describe('Round', () => {
 		['SelectQuery', ['Select', [['Round', ['Number', 10.4]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Round statement', () => {
-				sqlEquals(result.query, `SELECT ROUND(10.4)`);
+				sqlEquals(result, `SELECT ROUND(10.4)`);
 			});
 		},
 	);
@@ -99,7 +88,7 @@ describe('Floor', () => {
 		['SelectQuery', ['Select', [['Floor', ['Number', 10.4]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Floor statement', () => {
-				sqlEquals(result.query, `SELECT FLOOR(10.4)`);
+				sqlEquals(result, `SELECT FLOOR(10.4)`);
 			});
 		},
 	);
@@ -110,7 +99,7 @@ describe('Ceiling', () => {
 		['SelectQuery', ['Select', [['Ceiling', ['Number', 10.4]]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Ceiling statement', () => {
-				sqlEquals(result.query, `SELECT CEILING(10.4)`);
+				sqlEquals(result, `SELECT CEILING(10.4)`);
 			});
 		},
 	);
@@ -128,7 +117,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement when the first operand is a Multiply', () => {
-				sqlEquals(result.query, 'SELECT (2 * 3) + 4');
+				sqlEquals(result, 'SELECT (2 * 3) + 4');
 			});
 		},
 	);
@@ -143,7 +132,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement when the second operand is a Multiply', () => {
-				sqlEquals(result.query, 'SELECT 2 + (3 * 4)');
+				sqlEquals(result, 'SELECT 2 + (3 * 4)');
 			});
 		},
 	);
@@ -164,7 +153,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement of two Multiplications', () => {
-				sqlEquals(result.query, 'SELECT (2 * 3) + (4 * 5)');
+				sqlEquals(result, 'SELECT (2 * 3) + (4 * 5)');
 			});
 		},
 	);
@@ -179,7 +168,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement when the first operand is an Add', () => {
-				sqlEquals(result.query, 'SELECT (2 + 3) * 4');
+				sqlEquals(result, 'SELECT (2 + 3) * 4');
 			});
 		},
 	);
@@ -194,7 +183,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement when the second operand is an Add', () => {
-				sqlEquals(result.query, 'SELECT 2 * (3 + 4)');
+				sqlEquals(result, 'SELECT 2 * (3 + 4)');
 			});
 		},
 	);
@@ -215,7 +204,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement of two Additions', () => {
-				sqlEquals(result.query, 'SELECT (2 + 3) * (4 + 5)');
+				sqlEquals(result, 'SELECT (2 + 3) * (4 + 5)');
 			});
 		},
 	);
@@ -236,7 +225,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Subtract statement of two Multiplications', () => {
-				sqlEquals(result.query, 'SELECT (2 * 3) - (4 * 5)');
+				sqlEquals(result, 'SELECT (2 * 3) - (4 * 5)');
 			});
 		},
 	);
@@ -257,7 +246,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Subtract statement of two Divisions', () => {
-				sqlEquals(result.query, 'SELECT (2 / 3) - (4 / 5)');
+				sqlEquals(result, 'SELECT (2 / 3) - (4 / 5)');
 			});
 		},
 	);
@@ -278,7 +267,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Divide statement of two Additions', () => {
-				sqlEquals(result.query, 'SELECT (2 + 3) / (4 + 5)');
+				sqlEquals(result, 'SELECT (2 + 3) / (4 + 5)');
 			});
 		},
 	);
@@ -299,7 +288,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Divide statement of two Subtractions', () => {
-				sqlEquals(result.query, 'SELECT (2 - 3) / (4 - 5)');
+				sqlEquals(result, 'SELECT (2 - 3) / (4 - 5)');
 			});
 		},
 	);
@@ -322,7 +311,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement when there are nested Additions', () => {
-				sqlEquals(result.query, 'SELECT (2 + 3) + (4 + 5)');
+				sqlEquals(result, 'SELECT (2 + 3) + (4 + 5)');
 			});
 		},
 	);
@@ -343,7 +332,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement when there are nested Subtractions', () => {
-				sqlEquals(result.query, 'SELECT (2 - 3) + (4 - 5)');
+				sqlEquals(result, 'SELECT (2 - 3) + (4 - 5)');
 			});
 		},
 	);
@@ -364,7 +353,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Subtract statement when there are nested Additions', () => {
-				sqlEquals(result.query, 'SELECT (2 + 3) - (4 + 5)');
+				sqlEquals(result, 'SELECT (2 + 3) - (4 + 5)');
 			});
 		},
 	);
@@ -385,7 +374,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Add statement when there are nested Subtractions', () => {
-				sqlEquals(result.query, 'SELECT (2 - 3) - (4 - 5)');
+				sqlEquals(result, 'SELECT (2 - 3) - (4 - 5)');
 			});
 		},
 	);
@@ -408,7 +397,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement when there are nested Multiplications', () => {
-				sqlEquals(result.query, 'SELECT (2 * 3) * (4 * 5)');
+				sqlEquals(result, 'SELECT (2 * 3) * (4 * 5)');
 			});
 		},
 	);
@@ -429,7 +418,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement when there are nested Divisions', () => {
-				sqlEquals(result.query, 'SELECT (2 / 3) * (4 / 5)');
+				sqlEquals(result, 'SELECT (2 / 3) * (4 / 5)');
 			});
 		},
 	);
@@ -450,7 +439,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Divide statement when there are nested Multiplications', () => {
-				sqlEquals(result.query, 'SELECT (2 * 3) / (4 * 5)');
+				sqlEquals(result, 'SELECT (2 * 3) / (4 * 5)');
 			});
 		},
 	);
@@ -471,7 +460,7 @@ describe('Math Operator Precedence', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Multiply statement when there are nested Divisions', () => {
-				sqlEquals(result.query, 'SELECT (2 / 3) / (4 / 5)');
+				sqlEquals(result, 'SELECT (2 / 3) / (4 / 5)');
 			});
 		},
 	);

package/test/abstract-sql/nested-in-optimisations.ts

@@ -1,16 +1,5 @@
 import { stripIndent } from 'common-tags';
-import type { AnyTypeNodes } from '../../src/AbstractSQLCompiler';
-
-type TestCb = (
-	result: { query: string },
-	sqlEquals: (a: string, b: string) => void,
-) => void;
-import $test from './test';
-const test = $test as (
-	query: AnyTypeNodes,
-	binds: any[][] | TestCb,
-	cb?: TestCb,
-) => void;
+import test from './test';
 
 describe('Nested OR EQUALs should create a single IN statement', () => {
 	test(
@@ -44,7 +33,7 @@ describe('Nested OR EQUALs should create a single IN statement', () => {
 		(result, sqlEquals) => {
 			it('should produce a single IN statement', () => {
 				sqlEquals(
-					result.query,
+					result,
 					stripIndent`
 						SELECT 1
 						FROM "table"
@@ -100,7 +89,7 @@ describe('Nested AND NOT EQUALs should create a single NOT IN statement', () =>
 		(result, sqlEquals) => {
 			it('should produce a single IN statement', () => {
 				sqlEquals(
-					result.query,
+					result,
 					stripIndent`
 						SELECT 1
 						FROM "table"
@@ -145,7 +134,7 @@ describe('OR IN/EQUALs should create a single IN statement', () => {
 		(result, sqlEquals) => {
 			it('should produce a single in statement', () => {
 				sqlEquals(
-					result.query,
+					result,
 					stripIndent`
 						SELECT 1
 						FROM "table"
@@ -198,7 +187,7 @@ describe('AND NOT IN/NOT EQUALs should create a single NOT IN statement', () =>
 		(result, sqlEquals) => {
 			it('should produce a single not in statement', () => {
 				sqlEquals(
-					result.query,
+					result,
 					stripIndent`
 						SELECT 1
 						FROM "table"

package/test/abstract-sql/not-not-optimisations.ts

@@ -1,22 +1,11 @@
 import { stripIndent } from 'common-tags';
-import type { AnyTypeNodes } from '../../src/AbstractSQLCompiler';
-
-type TestCb = (
-	result: { query: string },
-	sqlEquals: (a: string, b: string) => void,
-) => void;
-import $test from './test';
-const test = $test as (
-	query: AnyTypeNodes,
-	binds: any[][] | TestCb,
-	cb?: TestCb,
-) => void;
+import test from './test';
 
 describe('NOT(NOT(...)) should cancel each other out', () => {
 	test(['Not', ['Not', ['Boolean', true]]], [], (result, sqlEquals) => {
 		it('should produce a query using the boolean directly', () => {
 			sqlEquals(
-				result.query,
+				result,
 				stripIndent`
 						SELECT TRUE AS "result";
 					`,

package/test/abstract-sql/test.ts

@@ -0,0 +1,192 @@
+import * as AbstractSQLCompiler from '../..';
+
+import { expect } from 'chai';
+import _ from 'lodash';
+
+type ExpectedBindings = Array<
+	AbstractSQLCompiler.Binding | AbstractSQLCompiler.Binding[]
+>;
+const bindingsTest = function (
+	actualBindings: AbstractSQLCompiler.Binding[],
+	expectedBindings: AbstractSQLCompiler.Binding[] | false = false,
+) {
+	if (expectedBindings === false) {
+		it('should not have any bindings', () => {
+			expect(actualBindings).to.be.empty;
+		});
+	} else {
+		it('should have matching bindings', () => {
+			expect(actualBindings).to.deep.equal(expectedBindings);
+		});
+	}
+};
+
+type SqlEquals = (
+	actual:
+		| AbstractSQLCompiler.SqlResult
+		| AbstractSQLCompiler.SqlResult[]
+		| string,
+	expected: string,
+) => void;
+const equals: SqlEquals = (actual, expected) => {
+	if (typeof actual !== 'string') {
+		if (Array.isArray(actual)) {
+			throw new Error('Expected a single query, got multiple');
+		}
+		actual = actual.query;
+	}
+	expect(actual).to.equal(expected);
+};
+const sqlEquals = {
+	websql: equals,
+	mysql: equals,
+	postgres(actual, expected) {
+		let num = 1;
+		while (_.includes(expected, '?')) {
+			expected = expected.replace('?', '$' + num);
+			num++;
+		}
+		equals(actual, expected);
+	},
+} satisfies Record<string, SqlEquals>;
+
+type ExpectationSuccessFn = (
+	result:
+		| AbstractSQLCompiler.SqlResult
+		| [AbstractSQLCompiler.SqlResult, AbstractSQLCompiler.SqlResult],
+	sqlEquals: SqlEquals,
+) => void;
+type ExpectationFailFn = (result: Error) => void;
+type ExpectationFn<ExpectFail extends boolean> = ExpectFail extends true
+	? ExpectationFailFn
+	: ExpectationSuccessFn;
+
+function runExpectation<ExpectFail extends boolean>(
+	describe: Mocha.SuiteFunction,
+	engine: keyof typeof sqlEquals,
+	expectFailure: ExpectFail,
+	input: AbstractSQLCompiler.AbstractSqlQuery,
+	expectedBindings: ExpectedBindings | false,
+	expectation: ExpectationFn<ExpectFail>,
+): void;
+function runExpectation<ExpectFail extends boolean>(
+	describe: Mocha.SuiteFunction,
+	engine: keyof typeof sqlEquals,
+	expectFailure: ExpectFail,
+	input: AbstractSQLCompiler.AbstractSqlQuery,
+	expectation: ExpectationFn<ExpectFail>,
+): void;
+function runExpectation<ExpectFail extends boolean>(
+	describe: Mocha.SuiteFunction,
+	engine: keyof typeof sqlEquals,
+	expectFailure: ExpectFail,
+	input: AbstractSQLCompiler.AbstractSqlQuery,
+	...args:
+		| [expectation: ExpectationFn<ExpectFail>]
+		| [
+				expectedBindings: ExpectedBindings | false,
+				expectation: ExpectationFn<ExpectFail>,
+		  ]
+): void {
+	let expectedBindings: ExpectedBindings | false = false;
+	let expectation: ExpectationFn<ExpectFail>;
+	switch (args.length) {
+		case 1:
+			[expectation] = args;
+			break;
+		case 2:
+			[expectedBindings, expectation] = args;
+			break;
+	}
+
+	describe('Parsing ' + JSON.stringify(input), function () {
+		let result;
+		try {
+			result = AbstractSQLCompiler[engine].compileRule(input);
+		} catch (e: any) {
+			if (!expectFailure) {
+				throw e;
+			}
+			(expectation as ExpectationFailFn)(e);
+			return;
+		}
+		if (expectFailure) {
+			throw new Error("Expected failure but didn't get one");
+		}
+		if (Array.isArray(result)) {
+			for (let i = 0; i < result.length; i++) {
+				const actualResult = result[i];
+				if (expectedBindings === false) {
+					bindingsTest(actualResult.bindings, false);
+				} else if (expectedBindings[0][0] === 'Bind') {
+					bindingsTest(
+						actualResult.bindings,
+						expectedBindings as AbstractSQLCompiler.Binding[],
+					);
+				} else {
+					bindingsTest(
+						actualResult.bindings,
+						expectedBindings[i] as AbstractSQLCompiler.Binding[],
+					);
+				}
+			}
+		} else {
+			bindingsTest(
+				result.bindings,
+				expectedBindings as AbstractSQLCompiler.Binding[],
+			);
+		}
+		(expectation as ExpectationSuccessFn)(result, sqlEquals[engine]);
+	});
+}
+
+interface BoundRunExpectation<ExpectFail extends boolean> {
+	(
+		input: AbstractSQLCompiler.AbstractSqlQuery,
+		expectedBindings: ExpectedBindings | false,
+		expectation: ExpectationFn<ExpectFail>,
+	): void;
+	(
+		input: AbstractSQLCompiler.AbstractSqlQuery,
+		expectation: ExpectationFn<ExpectFail>,
+	): void;
+	(
+		input: AbstractSQLCompiler.AbstractSqlQuery,
+		...args:
+			| [expectation: ExpectationFn<ExpectFail>]
+			| [
+					expectedBindings: ExpectedBindings | false,
+					expectation: ExpectationFn<ExpectFail>,
+			  ]
+	): void;
+}
+
+type MochaBoundRunExpectation = BoundRunExpectation<false> & {
+	fail: BoundRunExpectation<true>;
+	skip: BoundRunExpectation<false>;
+	only: BoundRunExpectation<false>;
+};
+const bindRunExpectation = function (engine: keyof typeof sqlEquals) {
+	const bound: MochaBoundRunExpectation = runExpectation.bind(
+		null,
+		describe,
+		engine,
+		false,
+	);
+	bound.fail = runExpectation.bind(null, describe, engine, true);
+	bound.skip = runExpectation.bind(null, describe.skip, engine, false);
+	// eslint-disable-next-line no-only-tests/no-only-tests -- this is a false positive
+	bound.only = runExpectation.bind(null, describe.only, engine, false);
+	return bound;
+};
+
+const testFn = bindRunExpectation('postgres') as MochaBoundRunExpectation & {
+	postgres: MochaBoundRunExpectation;
+	mysql: MochaBoundRunExpectation;
+	websql: MochaBoundRunExpectation;
+};
+testFn.postgres = bindRunExpectation('postgres');
+testFn.mysql = bindRunExpectation('mysql');
+testFn.websql = bindRunExpectation('websql');
+
+export default testFn;

package/test/abstract-sql/text.ts

@@ -1,15 +1,4 @@
-import type { AnyTypeNodes } from '../../src/AbstractSQLCompiler';
-
-type TestCb = (
-	result: { query: string },
-	sqlEquals: (a: string, b: string) => void,
-) => void;
-import $test from './test';
-const test = $test as (
-	query: AnyTypeNodes,
-	binds: any[][] | TestCb,
-	cb?: TestCb,
-) => void;
+import test from './test';
 
 describe('Concatenate', () => {
 	test(
@@ -22,7 +11,7 @@ describe('Concatenate', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Concatenate statement', () => {
-				sqlEquals(result.query, `SELECT ('foo' || 'bar')`);
+				sqlEquals(result, `SELECT ('foo' || 'bar')`);
 			});
 		},
 	);
@@ -46,7 +35,7 @@ describe('ConcatenateWithSeparator', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid ConcatenateWithSeparator statement', () => {
-				sqlEquals(result.query, `SELECT CONCAT_WS('|', 'foo', 'bar')`);
+				sqlEquals(result, `SELECT CONCAT_WS('|', 'foo', 'bar')`);
 			});
 		},
 	);
@@ -70,7 +59,7 @@ describe('Replace', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Replace statement', () => {
-				sqlEquals(result.query, `SELECT REPLACE('foobar', 'bar', 'baz')`);
+				sqlEquals(result, `SELECT REPLACE('foobar', 'bar', 'baz')`);
 			});
 		},
 	);
@@ -84,7 +73,7 @@ describe('CharacterLength', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid CharacterLength statement', () => {
-				sqlEquals(result.query, `SELECT LENGTH('foobar')`);
+				sqlEquals(result, `SELECT LENGTH('foobar')`);
 			});
 		},
 	);
@@ -101,7 +90,7 @@ describe('StrPos', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid StrPos statement', () => {
-				sqlEquals(result.query, `SELECT STRPOS('foobar', 'b')`);
+				sqlEquals(result, `SELECT STRPOS('foobar', 'b')`);
 			});
 		},
 	);
@@ -125,7 +114,7 @@ describe('Substring', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Substring statement', () => {
-				sqlEquals(result.query, `SELECT SUBSTRING('foobar', 0, 5)`);
+				sqlEquals(result, `SELECT SUBSTRING('foobar', 0, 5)`);
 			});
 		},
 	);
@@ -139,7 +128,7 @@ describe('Right', () => {
 		],
 		(result, sqlEquals) => {
 			it('should produce a valid Right statement', () => {
-				sqlEquals(result.query, `SELECT RIGHT('foobar', 1)`);
+				sqlEquals(result, `SELECT RIGHT('foobar', 1)`);
 			});
 		},
 	);
@@ -150,7 +139,7 @@ describe('Lower', () => {
 		['SelectQuery', ['Select', [['Lower', ['EmbeddedText', 'FOOBAR']]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Lower statement', () => {
-				sqlEquals(result.query, `SELECT LOWER('FOOBAR')`);
+				sqlEquals(result, `SELECT LOWER('FOOBAR')`);
 			});
 		},
 	);
@@ -161,7 +150,7 @@ describe('Upper', () => {
 		['SelectQuery', ['Select', [['Upper', ['EmbeddedText', 'foobar']]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Upper statement', () => {
-				sqlEquals(result.query, `SELECT UPPER('foobar')`);
+				sqlEquals(result, `SELECT UPPER('foobar')`);
 			});
 		},
 	);
@@ -172,7 +161,7 @@ describe('Trim', () => {
 		['SelectQuery', ['Select', [['Trim', ['EmbeddedText', ' foobar ']]]]],
 		(result, sqlEquals) => {
 			it('should produce a valid Trim statement', () => {
-				sqlEquals(result.query, `SELECT TRIM(' foobar ')`);
+				sqlEquals(result, `SELECT TRIM(' foobar ')`);
 			});
 		},
 	);

package/test/odata/test.js

@@ -66,28 +66,25 @@ const sqlEquals = {
 	},
 };
 
-const runExpectation = function (
-	describe,
-	engine,
-	input,
-	method,
-	expectedBindings,
-	body,
-	expectation,
-) {
-	if (expectation == null) {
-		if (body == null) {
-			if (expectedBindings == null) {
-				expectation = method;
-				method = 'GET';
-			} else {
-				expectation = expectedBindings;
-			}
-			expectedBindings = false;
-		} else {
-			expectation = body;
-		}
-		body = {};
+const runExpectation = function (describe, engine, input, ...args) {
+	/** @type {import('@balena/odata-parser').SupportedMethod} */
+	let method = 'GET';
+	let expectedBindings = false;
+	let body = {};
+	let expectation;
+	switch (args.length) {
+		case 1:
+			[expectation] = args;
+			break;
+		case 2:
+			[method, expectation] = args;
+			break;
+		case 3:
+			[method, expectedBindings, expectation] = args;
+			break;
+		case 4:
+			[method, expectedBindings, body, expectation] = args;
+			break;
 	}
 
 	describe(