Implement CLI testing suite

Author: t-ski

examples/cli/pwd.test.js

@@ -0,0 +1,14 @@
+new CLITest("Print working directory (pwd)")
+.actual("pwd")
+.expected({
+    stdout: process.cwd()
+});
+
+new CLITest("pwd with an undefined argument")
+.actual("pwd", [ "-x" ])
+.expected({
+    stderr: [
+        "/bin/sh: line 0: pwd: -x: invalid option",
+        "pwd: usage: pwd [-LP]"
+    ]
+});

packages/@cli/README.md

@@ -12,33 +12,40 @@ npx rjs-test cli <tests-path>
 
 > Integrated in [`rapidjs-org/testing`](https://github.com/rapidjs-org/testing).
 
+## Configuration
+
+In order to define common CLI aspects, they can be defined through the static `.configure()` method:
+
+``` ts
+HTTPTest.configure(configuration: RequestOptions & {
+  commonBinary?: string;
+});
+```
+
 ## Test Anatomy
 
 ### Expressions
 
-(#### Actual)
+#### Actual
 
 ``` ts
-.actual(expression: any)
-.expected(expression: any)
+.actual(binary: string, arg?: string[])
+.actual(args: string[]) // imply binary if defined a common
 ```
 
-(#### Expected)
-
-### Value-based Assertion
+#### Expected
 
 ``` ts
-new <Suite>Test("Example label")
-.actual(<expression>)
-.expected(<expression>);
+.expected(binary: string, arg?: string[])
+.expected(args: string[]) // imply binary if defined a common
 ```
 
-### Error-based Assertion
+### Value-based Assertion
 
 ``` ts
-new <Suite>Test("Example label")
+new CLITest("List files")
 .actual(<expression>)
-.error("<error-message>", <ErrorConstructor>);
+.expected(<expression>);
 ```
 
 ## Comparison Strategy

packages/@cli/metatest/__test.env.js

@@ -0,0 +1,6 @@
+process.chdir(__dirname);
+
+
+CLITest.configure({
+    commonBinary: "pwd"
+});

packages/@cli/metatest/cli.test.js

@@ -0,0 +1,36 @@
+// With common bin
+new CLITest("Print working directory (1)")
+.actual()
+.expected({
+    stdout: __dirname
+});
+
+// With explicit bin
+new CLITest("Print working directory (2)")
+.actual("pwd")
+.expected({
+    stdout: __dirname
+});
+
+// With args
+new CLITest("Echo 'foo' (1)")
+.actual("echo", [ "foo" ])
+.expected({
+    stdout: "foo",
+    stderr: null
+});
+
+// Condensed
+new CLITest("Echo 'foo' (2)")
+.actual("echo foo")
+.expected("foo");
+
+// stderr
+new CLITest("Print working directory; with undefined argument")
+.actual("pwd -x")
+.expected({
+    stderr: [
+        "/bin/sh: line 0: pwd: -x: invalid option",
+        "pwd: usage: pwd [-LP]"
+    ]
+});

packages/@cli/package.json

@@ -21,9 +21,8 @@
         "debug": "npx tsc --project ./tsconfig.debug.json",
         "debug:watch": "npm run debug -- --watch",
         "build": "rm -rf ./build/ && rm -rf ./types/ && npx tsc --project ./tsconfig.build.json",
-        "metatest:single-file": "../../bin.sh http ./metatest/http-1.test.js",
-        "metatest": "../../bin.sh http ./metatest/",
-        "test": "npm run build && npm run metatest && npm run metatest:single-file",
+        "metatest": "../../bin.sh cli ./metatest/",
+        "test": "npm run build && npm run metatest",
         "release:minor": "npm run test && npx release --minor",
         "release:patch": "npm run test && npx release --patch"
     },
@@ -33,6 +32,6 @@
         "typescript": "^5.3.3"
     },
     "dependencies": {
-        "@rapidjs.org/testing": "^0.1.0"
+        "@rapidjs.org/testing": "0.x"
     }
 }

packages/@cli/src/CLITest.ts

@@ -1,37 +1,98 @@
+import { exec } from "child_process";
+
 import { Test } from "@rapidjs.org/testing";
 
 import { TColor } from "../../common.types";
 
-interface IObject {
-	[key: string]: string | number | boolean | IObject;
+interface IOutput {
+	stdout: string;
+	stderr: string;
+}
+
+interface TConfiguration {
+	commonBinary?: string;
 }
 
-export class CLITest extends Test<IObject> {
+export class CLITest extends Test<IOutput> {
 	public static readonly suiteTitle: string = "CLI";
 	public static readonly suiteColor: TColor = [73, 220, 177]; // 108, 55, 55
 
-	constructor(title: string) {
-		super(title);
+	private static configuration: TConfiguration = {};
+
+	public static configure(configuration: TConfiguration) {
+		CLITest.configuration = {
+			...CLITest.configuration,
+			...configuration
+		};
 	}
 
-	protected evalActualExpression(obj: IObject): Promise<IObject> {
-		return new Promise((resolve) => {
-			resolve(
-				Object.fromEntries(
-					Object.entries(obj).map((entry: [string, unknown]) => [entry[0].toLowerCase(), entry[1]])
-				) as IObject
-			);
+	private normalizeOutput(output: Partial<IOutput>): IOutput {
+		const normalizeStdValue = (value: string) => {
+			return (value ?? "")
+			.replace(/(\n|\r)+/g, "\n")
+			.replace(/(\t| )+/g, " ")
+			.trim()
+			?? null;
+		}
+		return {
+			stdout: normalizeStdValue(output.stdout),
+			stderr: normalizeStdValue(output.stderr)
+		};
+	}
+	
+	protected evalActualExpression(args: string[]): Promise<IOutput>;
+	protected evalActualExpression(binary: string, args?: string[]): Promise<IOutput>;
+	protected evalActualExpression(binaryOrArgs: string|string[], args: string[] = []): Promise<IOutput> {
+		// TODO: Pipe chain abstraction (?)
+		const effectiveBinary: string = (!binaryOrArgs || Array.isArray(binaryOrArgs))
+		? CLITest.configuration.commonBinary
+		: binaryOrArgs;
+		if(!effectiveBinary) throw new SyntaxError("Missing binary to execute");
+
+		const effectiveArgs: string[] = (args ?? [ binaryOrArgs ].flat()) ?? [];
+
+		return new Promise((resolve, reject) => {
+			exec([ effectiveBinary, effectiveArgs ].flat().join(" "), (err: Error, stdout: string, stderr: string) => {
+				if(err && !stderr) {
+					reject(err);
+
+					return;
+				}
+				
+				resolve(this.normalizeOutput({
+					stdout, stderr
+				}));
+			});
 		});
 	}
 
-	protected isEqual(actual: IObject, expected: IObject): boolean {
-		return !Object.keys(this.filterComparedValues(actual, expected).actual).length;
+	protected evalExpectedExpression(expectedOutput: Partial<IOutput>|string): IOutput {
+		return this.normalizeOutput(
+			(typeof(expectedOutput) === "string")
+			? {	
+				stdout: expectedOutput
+			}
+			: {
+				stdout: [ expectedOutput.stdout ].flat().join("\n"),
+				stderr: [ expectedOutput.stderr ].flat().join("\n")
+			}
+		);
 	}
 
-	protected filterComparedValues(actual: IObject, expected: IObject) {
-		return {
-			actual: actual,
-			expected: expected
+	protected getDifference(actual: IOutput, expected: IOutput) {
+		const filterObj = (sourceObj: IOutput, targetObj: IOutput) => {
+			return {
+				...(sourceObj.stdout !== targetObj.stdout)
+				? { stdout: sourceObj.stdout }
+				: {},
+				...(sourceObj.stderr !== targetObj.stderr)
+				? { stderr: sourceObj.stderr }
+				: {},
+			}
 		};
+		return {
+			actual: filterObj(actual, expected),
+			expected: filterObj(expected, actual)
+		}
 	}
 }

packages/@http/package.json

@@ -33,6 +33,6 @@
         "typescript": "^5.3.3"
     },
     "dependencies": {
-        "@rapidjs.org/testing": "^0.1.0"
+        "@rapidjs.org/testing": "0.x"
     }
 }

packages/@http/src/HTTPTest.ts

@@ -35,11 +35,7 @@ export class HTTPTest extends Test<IResponse> {
 			...configuration
 		};
 	}
-
-	constructor(title: string) {
-		super(title);
-	}
-
+	
 	protected evalActualExpression(
 		path: string,
 		options: TConfiguration & {

packages/@unit/package.json

@@ -32,6 +32,6 @@
         "typescript": "^5.3.3"
     },
     "dependencies": {
-        "@rapidjs.org/testing": "^0.1.0"
+        "@rapidjs.org/testing": "0.x"
     }
 }

packages/@unit/src/UnitTest.ts

@@ -5,8 +5,4 @@ import { TColor } from "../../common.types";
 export class UnitTest extends Test {
 	public static readonly suiteTitle: string = "Unit";
 	public static readonly suiteColor: TColor = [38, 155, 227];
-
-	constructor(title: string) {
-		super(title);
-	}
 }