spawn-rx 5.1.2 → 6.0.1

package/test/{asserttest.ts → asserttest.test.ts}

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions */
-import { expect } from "chai";
-import "./support";
+import { describe, expect, it } from "bun:test";
 
 function delay(ms: number) {
   return new Promise((resolve) => {
@@ -8,9 +7,9 @@ function delay(ms: number) {
   });
 }
 
-describe("The test runner", function () {
-  it("should pass this test", async function () {
+describe("The test runner", () => {
+  it("should pass this test", async () => {
     await delay(1000);
-    expect(true).to.be.ok;
+    expect(true).toBeTruthy();
   });
 });

package/test/{spawn.ts → spawn.test.ts}

@@ -1,57 +1,42 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { expect } from "chai";
-import "./support";
-
-import { spawn, spawnPromise, spawnDetachedPromise } from "../src/index";
-
+import { describe, expect, it } from "bun:test";
 import type { Observable } from "rxjs";
 import { of } from "rxjs";
+import { spawn, spawnPromise } from "../src/index";
 
-const uuidRegex =
-  /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 
-describe("The spawnPromise method", function () {
-  it("should return a uuid when we call uuid", async function () {
+describe("The spawnPromise method", () => {
+  it("should return a uuid when we call uuid", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     const result = await spawnPromise("uuid", []);
-    expect(result.match(uuidRegex)).to.be.ok;
+    expect(result.match(uuidRegex)).toBeTruthy();
   });
 
-  it("should split stdout and stderr when we call uuid", async function () {
+  it("should split stdout and stderr when we call uuid", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     const result = await spawnPromise("uuid", [], { split: true });
-    expect(result[0].match(uuidRegex)).to.be.ok;
-    expect(result[1].match(uuidRegex)).to.not.be.ok;
+    expect(result[0].match(uuidRegex)).toBeTruthy();
+    expect(result[1].match(uuidRegex)).toBeFalsy();
   });
 
-  it("should retur nthe exit code", async function () {
+  it("should retur nthe exit code", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     try {
       await spawnPromise("false", [], { split: true });
-      expect(false).to.be.true;
-    } catch (e) {
-      expect(e.code).to.be.equal(1);
+      expect(false).toBe(true);
+    } catch (e: any) {
+      expect(e.code).toBe(1);
     }
   });
 
-  it("should not stdout and stderr when we call uuid with split false", async function () {
+  it("should not stdout and stderr when we call uuid with split false", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     const result = await spawnPromise("uuid", [], { split: false });
-    expect(result.match(uuidRegex)).to.be.ok;
-  });
-});
-
-describe("The spawnDetachedPromise method", function () {
-  it("should return a uuid when we call uuid", async function () {
-    // NB: Since we get run via npm run test, we know that npm bins are in our
-    // PATH.
-    const result = await spawnDetachedPromise("uuid", ["--help"]);
-    expect(result.length > 10).to.be.ok;
+    expect(result.match(uuidRegex)).toBeTruthy();
   });
 });
 
@@ -85,81 +70,68 @@ function wrapSplitObservableInPromise(
   });
 }
 
-describe("The spawn method", function () {
-  it("should return a disposable subscription", async function () {
+describe("The spawn method", () => {
+  it("should return a disposable subscription", async () => {
     // this only check the unsubscribe goes w/o error, not that the spawned process is killed
     // (difficult to do that, maybe iterate through child processes and check ?)
     spawn("sleep", ["2"]).subscribe().unsubscribe();
   });
 
-  it("should return split stderr in a inner tag when called with split", async function () {
+  it("should return split stderr in a inner tag when called with split", async () => {
     // provide an invalid param to uuid so it complains on stderr
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "uuid",
-      ["foo"],
-      { split: true },
-    ) as any;
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", ["foo"], { split: true }) as any;
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stderr.length > 10).to.be.ok;
-    expect(result.stdout).to.be.empty;
-    expect(result.error).to.be.an("error");
+    expect(result.stderr.length > 10).toBeTruthy();
+    expect(result.stdout).toBe("");
+    expect(result.error).toBeInstanceOf(Error);
   });
 
-  it("should return split stdout in a inner tag when called with split", async function () {
+  it("should return split stdout in a inner tag when called with split", async () => {
     const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", [], {
       split: true,
     });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout.match(uuidRegex)).to.be.ok;
-    expect(result.stderr).to.be.empty;
-    expect(result.error).to.be.undefined;
+    expect(result.stdout.match(uuidRegex)).toBeTruthy();
+    expect(result.stderr).toBe("");
+    expect(result.error).toBeUndefined();
   });
 
-  it("should ignore stderr if options.stdio = ignore", async function () {
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "uuid",
-      ["foo"],
-      { split: true, stdio: [null, null, "ignore"] },
-    );
+  it("should ignore stderr if options.stdio = ignore", async () => {
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", ["foo"], {
+      split: true,
+      stdio: [null, null, "ignore"],
+    });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stderr).to.be.empty;
+    expect(result.stderr).toBe("");
   });
 
-  it("should ignore stdout if options.stdio = inherit", async function () {
+  it("should ignore stdout if options.stdio = inherit", async () => {
     const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", [], {
       split: true,
       stdio: [null, "inherit", null],
     });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout).to.be.empty;
+    expect(result.stdout).toBe("");
   });
 
-  it("should croak if stdin is provided but stdio.stdin is disabled", async function () {
+  it("should croak if stdin is provided but stdio.stdin is disabled", async () => {
     const stdin = of("a");
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "marked",
-      [],
-      {
-        split: true,
-        stdin: stdin,
-        stdio: ["ignore", null, null],
-      },
-    );
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("marked", [], {
+      split: true,
+      stdin: stdin,
+      stdio: ["ignore", null, null],
+    });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.error).to.be.an("error");
+    expect(result.error).toBeInstanceOf(Error);
   });
 
-  it("should subscribe to provided stdin", async function () {
+  it("should subscribe to provided stdin", async () => {
     const stdin = of("a");
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "marked",
-      [],
-      {
-        split: true,
-        stdin: stdin,
-      },
-    );
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("marked", [], {
+      split: true,
+      stdin: stdin,
+    });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout.trim()).to.be.equal("<p>a</p>");
+    expect(result.stdout.trim()).toBe("<p>a</p>");
   });
 });

package/tsconfig.json

@@ -21,5 +21,5 @@
     "indentSize": 2,
     "tabSize": 2
   },
-  "exclude": ["node_modules", "lib"]
+  "exclude": ["node_modules", "lib", "test"]
 }

package/eslint.config.mjs

@@ -1,88 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import prettier from "eslint-plugin-prettier";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all,
-});
-
-export default [
-  ...compat.extends(
-    "eslint:recommended",
-    "prettier",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended",
-  ),
-  {
-    files: ["./src/*.{ts,tsx}", "./test/*.{ts,tsx}"],
-    plugins: {
-      "@typescript-eslint": typescriptEslint,
-      prettier,
-    },
-
-    languageOptions: {
-      globals: {},
-      parser: tsParser,
-      ecmaVersion: 5,
-      sourceType: "script",
-
-      parserOptions: {
-        project: "./tsconfig.json",
-      },
-    },
-
-    rules: {
-      "prettier/prettier": "warn",
-
-      "spaced-comment": [
-        "error",
-        "always",
-        {
-          markers: ["/"],
-        },
-      ],
-
-      "no-fallthrough": "error",
-      "@typescript-eslint/ban-ts-comment": "warn",
-
-      "@typescript-eslint/consistent-type-imports": [
-        "error",
-        {
-          prefer: "type-imports",
-        },
-      ],
-
-      "@typescript-eslint/no-inferrable-types": [
-        "error",
-        {
-          ignoreParameters: false,
-          ignoreProperties: false,
-        },
-      ],
-
-      "@typescript-eslint/no-non-null-assertion": "off",
-      "@typescript-eslint/no-floating-promises": "error",
-
-      "@typescript-eslint/no-unused-vars": [
-        "warn",
-        {
-          args: "after-used",
-          argsIgnorePattern: "^_",
-          varsIgnorePattern: "^_",
-          ignoreRestSiblings: true,
-        },
-      ],
-
-      "@typescript-eslint/no-empty-function": ["error"],
-      "@typescript-eslint/restrict-template-expressions": "off",
-    },
-  },
-];