@wocker/testing 1.0.5 → 1.0.6-beta.0

package/lib/makes/MockReadStream.d.ts

@@ -0,0 +1,32 @@
+import { AddressInfo, SocketReadyState } from "net";
+import { Duplex } from "stream";
+export declare class MockReadStream extends Duplex implements NodeJS.ReadStream {
+    isTTY: boolean;
+    isRaw: boolean;
+    autoSelectFamilyAttemptedAddresses: string[];
+    bufferSize: number;
+    bytesRead: number;
+    bytesWritten: number;
+    connecting: boolean;
+    pending: boolean;
+    localAddress?: string;
+    localPort?: number;
+    localFamily?: string;
+    readyState: SocketReadyState;
+    remoteAddress: string;
+    remoteFamily: string;
+    remotePort: number;
+    timeout?: number;
+    setRawMode(mode: boolean): this;
+    pause(): this;
+    resume(): this;
+    destroySoon(): void;
+    connect(port: unknown, host?: unknown, connectionListener?: unknown): this;
+    resetAndDestroy(): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+    setNoDelay(noDelay?: boolean): this;
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    address(): AddressInfo | {};
+    unref(): this;
+    ref(): this;
+}

package/lib/makes/MockReadStream.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockReadStream = void 0;
+const stream_1 = require("stream");
+class MockReadStream extends stream_1.Duplex {
+    constructor() {
+        super(...arguments);
+        this.isTTY = false;
+        this.isRaw = false;
+        this.connecting = false;
+    }
+    setRawMode(mode) {
+        this.isRaw = mode;
+        return this;
+    }
+    pause() {
+        return this;
+    }
+    resume() {
+        return this;
+    }
+    destroySoon() {
+    }
+    connect(port, host, connectionListener) {
+        throw new Error("Method not implemented.");
+    }
+    resetAndDestroy() {
+        throw new Error("Method not implemented.");
+    }
+    setTimeout(timeout, callback) {
+        throw new Error("Method not implemented.");
+    }
+    setNoDelay(noDelay) {
+        throw new Error("Method not implemented.");
+    }
+    setKeepAlive(enable, initialDelay) {
+        throw new Error("Method not implemented.");
+    }
+    address() {
+        throw new Error("Method not implemented.");
+    }
+    unref() {
+        throw new Error("Method not implemented.");
+    }
+    ref() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockReadStream = MockReadStream;

package/lib/makes/MockWriteStream.d.ts

@@ -0,0 +1,36 @@
+import { AddressInfo, SocketReadyState } from "net";
+import { PassThrough } from "stream";
+import { Direction } from "tty";
+export declare class MockWriteStream extends PassThrough implements NodeJS.WriteStream {
+    isTTY: boolean;
+    columns: number;
+    rows: number;
+    autoSelectFamilyAttemptedAddresses: string[];
+    bufferSize: number;
+    bytesRead: number;
+    bytesWritten: number;
+    connecting: boolean;
+    pending: boolean;
+    readyState: SocketReadyState;
+    remoteAddress: string | undefined;
+    remoteFamily: string | undefined;
+    remotePort: number | undefined;
+    constructor();
+    connect(): this;
+    destroySoon(): void;
+    resetAndDestroy(): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+    setNoDelay(noDelay?: boolean): this;
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    address(): AddressInfo | {};
+    ref(): this;
+    unref(): this;
+    clearLine(dir: Direction, callback?: () => void): boolean;
+    clearScreenDown(callback?: () => void): boolean;
+    cursorTo(x: number, y?: number, callback?: () => void): boolean;
+    cursorTo(x: number, callback: () => void): boolean;
+    moveCursor(dx: number, dy: number, callback?: () => void): boolean;
+    getColorDepth(env?: object): number;
+    hasColors(count?: unknown, env?: unknown): boolean;
+    getWindowSize(): [number, number];
+}

package/lib/makes/MockWriteStream.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWriteStream = void 0;
+const stream_1 = require("stream");
+const readline_1 = __importDefault(require("readline"));
+class MockWriteStream extends stream_1.PassThrough {
+    constructor() {
+        super({});
+        this.isTTY = true;
+        this.columns = 0;
+        this.rows = 0;
+        this.autoSelectFamilyAttemptedAddresses = [];
+        this.bufferSize = 0;
+        this.bytesRead = 0;
+        this.bytesWritten = 0;
+        this.connecting = false;
+        this.pending = false;
+        this.readyState = "writeOnly";
+    }
+    connect() {
+        throw new Error("Method not implemented.");
+    }
+    destroySoon() {
+        throw new Error("Method not implemented.");
+    }
+    resetAndDestroy() {
+        throw new Error("Method not implemented.");
+    }
+    setTimeout(timeout, callback) {
+        throw new Error("Method not implemented.");
+    }
+    setNoDelay(noDelay) {
+        throw new Error("Method not implemented.");
+    }
+    setKeepAlive(enable, initialDelay) {
+        throw new Error("Method not implemented.");
+    }
+    address() {
+        throw new Error("Method not implemented.");
+    }
+    ref() {
+        throw new Error("Method not implemented.");
+    }
+    unref() {
+        throw new Error("Method not implemented.");
+    }
+    clearLine(dir, callback) {
+        return readline_1.default.clearLine(this, dir, callback);
+    }
+    clearScreenDown(callback) {
+        return readline_1.default.clearScreenDown(this, callback);
+    }
+    cursorTo(x, yOrCallback, callback) {
+        const y = typeof yOrCallback === "number" ? yOrCallback : undefined;
+        if (typeof yOrCallback === "function") {
+            callback = yOrCallback;
+        }
+        return readline_1.default.cursorTo(this, x, y, callback);
+    }
+    moveCursor(dx, dy, callback) {
+        return readline_1.default.moveCursor(this, dx, dy, callback);
+    }
+    getColorDepth(env) {
+        throw new Error("Method not implemented.");
+    }
+    hasColors(count, env) {
+        throw new Error("Method not implemented.");
+    }
+    getWindowSize() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockWriteStream = MockWriteStream;

package/lib/makes/TestingModuleBuilder.js

@@ -15,7 +15,7 @@ class TestingModuleBuilder {
         this.overrideProviders = new Map();
         this.overrideModules = new Map();
         this.overrideProvider(core_1.ProcessService)
-            .useProvider(services_1.MockProcessService);
+            .useProvider(services_1.ProcessMockService);
     }
     createModule(metadata) {
         let TestingModule = class TestingModule {

package/lib/services/ProcessMockService.d.ts

@@ -0,0 +1,17 @@
+import { ProcessService, FileSystemDriver } from "@wocker/core";
+import { MockReadStream } from "../makes/MockReadStream";
+import { MockWriteStream } from "../makes/MockWriteStream";
+export declare class ProcessMockService extends ProcessService {
+    protected readonly driver: FileSystemDriver;
+    protected _pwd: string;
+    protected _stdin: MockReadStream;
+    protected _stdout: MockWriteStream;
+    protected _stderr: MockWriteStream;
+    constructor(dataDir: string, driver: FileSystemDriver);
+    get stdin(): MockReadStream;
+    get stdout(): MockWriteStream;
+    get stderr(): MockWriteStream;
+    pwd(path?: string): string;
+    chdir(path: string): void;
+    write(chunk: string | Buffer): boolean;
+}

package/lib/services/{MockProcessService.js → ProcessMockService.js}

@@ -15,16 +15,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockProcessService = void 0;
+exports.ProcessMockService = void 0;
 const core_1 = require("@wocker/core");
-const stream_1 = require("stream");
 const path_1 = __importDefault(require("path"));
-let MockProcessService = class MockProcessService extends core_1.ProcessService {
+const MockReadStream_1 = require("../makes/MockReadStream");
+const MockWriteStream_1 = require("../makes/MockWriteStream");
+let ProcessMockService = class ProcessMockService extends core_1.ProcessService {
     constructor(dataDir, driver) {
         super();
         this.driver = driver;
         this._pwd = dataDir;
-        this.stdout = new stream_1.Duplex();
+        this._stdin = new MockReadStream_1.MockReadStream();
+        this._stdout = new MockWriteStream_1.MockWriteStream();
+        this._stderr = new MockWriteStream_1.MockWriteStream();
+    }
+    get stdin() {
+        return this._stdin;
+    }
+    get stdout() {
+        return this._stdout;
+    }
+    get stderr() {
+        return this._stderr;
     }
     pwd(path = "") {
         return path_1.default.join(this._pwd, path);
@@ -39,10 +51,10 @@ let MockProcessService = class MockProcessService extends core_1.ProcessService
         return this.stdout.write(chunk);
     }
 };
-exports.MockProcessService = MockProcessService;
-exports.MockProcessService = MockProcessService = __decorate([
+exports.ProcessMockService = ProcessMockService;
+exports.ProcessMockService = ProcessMockService = __decorate([
     (0, core_1.Injectable)("CORE_PROCESS_SERVICE"),
     __param(0, (0, core_1.Inject)(core_1.WOCKER_DATA_DIR_KEY)),
     __param(1, (0, core_1.Inject)(core_1.FILE_SYSTEM_DRIVER_KEY)),
     __metadata("design:paramtypes", [String, Object])
-], MockProcessService);
+], ProcessMockService);

package/lib/services/index.d.ts

@@ -1 +1 @@
-export * from "./MockProcessService";
+export * from "./ProcessMockService";

package/lib/services/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./MockProcessService"), exports);
+__exportStar(require("./ProcessMockService"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wocker/testing",
     "type": "commonjs",
-    "version": "1.0.5",
+    "version": "1.0.6-beta.0",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Docker workspace for web projects (testing)",
     "license": "MIT",
@@ -30,7 +30,7 @@
         "make-coverage-badge": "make-coverage-badge"
     },
     "peerDependencies": {
-        "@wocker/core": "^1.0.26",
+        "@wocker/core": "^1.0.30-beta.1",
         "docker-modem": "^5.0.6",
         "dockerode": "^4.0.7"
     },

package/lib/services/MockProcessService.d.ts

@@ -1,11 +0,0 @@
-import { ProcessService, FileSystemDriver } from "@wocker/core";
-import { Duplex } from "stream";
-export declare class MockProcessService extends ProcessService {
-    protected readonly driver: FileSystemDriver;
-    protected _pwd: string;
-    protected stdout: Duplex;
-    constructor(dataDir: string, driver: FileSystemDriver);
-    pwd(path?: string): string;
-    chdir(path: string): void;
-    write(chunk: string | Buffer): boolean;
-}