Question

我有一个电子应用程序，该应用程序首先启动一个启动器窗口（在渲染器过程中），该窗口启动了多个后台服务。在这些后台服务成功启动之后，它将其"services-running"上的ipcRenderer发送回主进程，然后通过关闭启动器窗口并启动主应用程序窗口来对该事件做出反应。 ipcMain.on('services-running',...)

当然会收到该事件

我对所有处理程序分别进行了单元测试，所以它们很好，现在我想对通过ipcMain传递的事件进行集成测试。

这是我目前的集成测试的样子：

import { Application } from 'spectron';
import * as electron from "electron";
import { expect } from 'chai';
import * as chai from 'chai';
import * as chaiAsPromised from 'chai-as-promised';

let app: Application;

global.before(() => {
    app = new Application({
        path: "" + electron,
        args: ["app/main.js"],
        env: {
            ELECTRON_ENABLE_LOGGING: true,
            ELECTRON_ENABLE_STACK_DUMPING: true,
            NODE_ENV: "integrationtest"
        },
        startTimeout: 20000,
        chromeDriverLogPath: '../chromedriverlog.txt'
    });

    chai.use(chaiAsPromised);
    chai.should();
});

describe('Application', () => {

    before('Start Application', () => {
        return app.start();
    });

    after(() => {
        if(app && app.isRunning()){
            return app.stop();
        }
    });

    it('should start the launcher', async  () => {
        await app.client.waitUntilWindowLoaded();
        return app.client.getTitle().should.eventually.equal('Launcher');
    });

    it('should start all services before timing out', async (done) => {
        console.log('subscribed');
        app.electron.remote.ipcMain.on('services-running', () => {
            done();
        });
    });

});

第一个测试工作正常。尽管我可以在弹出主窗口之前在外壳上看到subscribed，但第二次测试最终还是会在超时后失败，因此肯定会触发该事件。

我在文档中读到，需要启用nodeIntegration才能使用Spectron访问完整的电子api，我所有的渲染器过程都以{nodeIntegration: true}在其各自的webPreferences中开始。但是，由于我对主流程感兴趣，因此我认为这并不适用（或者至少我认为不应这样做，因为主流程本身就是节点流程）。

所以我的主要问题是，我将如何绑定到ipcMain事件并将其包含在我的断言中。另外，我怎么知道关闭启动器窗口并打开“主”窗口的时间？

作为奖励，我对Spectron API有一些理解问题。

如果我查看spectron.d.ts，则electron的{{1}}属性的类型为Application，而属性依次为Electron.AllElectron具有MainInterface属性。因此，根据我的理解，访问ipcMain应该是ipcMain（未定义），该远程来自哪里，为什么它在app.electron.ipcMain中不可见。
spectron.d.ts上的方法均返回SpectronClient。所以我必须Promise<void>或await那些。如果我看一下javascript示例，它们会链接客户端语句：

then

这在打字稿中不起作用，因为您显然无法链接到return app.client .waitUntilWindowLoaded() .getTitle().should.equal('Launcher');，...在js中如何工作？

Answer 1

所以我分别解决了这些问题。我将所有内容迁移到类，并使用字段/构造函数注入将所有依赖项放入类中，以便可以模拟它们，包括来自电子的事物。

export class LauncherRenderer implements Renderer {

    protected mongo: MongoProcess;
    protected logger: Logger;
    protected ipc: IpcRenderer;

    protected STATUS_LABEL: string = 'status-text';

    constructor() {
        this.ipc = ipcRenderer;

        this.mongo = new MongoProcess(this.ipc);

        this.logger = new Logger('launcher', this.ipc);
    }

在类中，订阅事件时，我将始终使用this.ipc。对于单元测试，我有一个FakeIpc类：

import { EventEmitter } from 'events';

export class FakeIpc {

    public emitter: EventEmitter = new EventEmitter();

    public send(channel: string, message?: any): void { }

    public on(event: string, listener: () => void): void {
        this.emitter.on(event, listener);
    }

    public emit(event: string): void {
        this.emitter.emit(event);
    }
}

设置LauncherRenderer的单元测试时，我将FakeIpc注入渲染器：

 beforeEach(() => {
        fakeIpc = new FakeIpc();
        spyOn(fakeIpc, 'on').and.callThrough();
        spyOn(fakeIpc, 'send').and.callThrough();

        mongoMock = createSpyObj('mongoMock', ['start', 'stop', 'forceStop']);

        underTest = new LauncherRenderer();

        underTest.mongo = mongoMock;
        underTest.ipc = fakeIpc;
    });

这样，如果订阅已完成，我可以监视ipc，或者使用公共trigger方法来拍摄ipc事件并测试我的班级是否对此做出正确反应。

对于集成测试，我认识到我不应该关心事件之类的内部事件（在单元测试中完成），而只关心那些结果（窗口关闭和打开）。像这样：

    it('should start the launcher', async () => {
        await app.client.waitUntilWindowLoaded();
        const title: string = await app.client.getTitle();
        expect(title).toEqual('Launcher');
    });

在下一个测试中，我等到启动器消失并打开一个新窗口，这样事件必须已经生效或将不会发生。

    it('should open main window after all services started within 120s', async () => {
        let handles: any = await app.client.windowHandles();

        try {
            await Utils.waitForPredicate(async () => {
                handles = await app.client.windowHandles();
                return Promise.resolve(handles.value.length === 2);
            }, 120000);
            await app.client.windowByIndex(1);
        } catch (err) {
            return Promise.reject(err);
        }

        const title: string = await app.client.getTitle();
        expect(title).toEqual('Main Window');
    });

waitForPredicate只是一个助手方法，它在达到超时后等待承诺解决或终止测试。

public static waitForPredicate(
    predicate: () => Promise<boolean>,
    timeout: number = 10000,
    interval: number = 1000,
    expectation: boolean = true): Promise<void> {
        return new Promise<any>(async (res, rej) => {
            let currentTime: number = 0;
            while (currentTime < timeout) {
                // performance.now() would be nicer, but that doesn't work in jasmin tests
                const t0: number = Date.now();
                const readyState: boolean | void = await predicate().catch(() => rej());
                if (readyState === expectation) {
                    res();
                    return;
                }
                await Utils.sleep(interval);
                const t1: number = Date.now();
                currentTime += t1 - t0;
            }
            // timeout
            rej();
        });
}

public static sleep(ms: number): Promise<void> {
    if (this.skipSleep) {
        return Promise.resolve();
    }
    return new Promise<void>((res) => setTimeout(res, ms));
}

对Spectron中的ipcMain事件做出反应

1 个答案: