0

我有一个电子应用程序，它首先启动一个启动器窗口（在渲染器进程中），它启动多个后台服务。在这些后台服务成功启动后，它会将"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在主窗口弹出之前在 shell 上看到，所以肯定会触发事件。

我阅读了nodeIntegration需要启用才能使用 spectron 访问完整电子 api 的文档，我所有的渲染器进程都是{nodeIntegration: true}在它们各自的webPreferences. 但是由于我对主进程感兴趣，我认为这不适用（或者至少我认为它不应该，因为主进程本身就是一个节点进程）。

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

作为奖励，我对 spectron api 有一些理解问题。

  1. 如果我查看isspectron.d.ts的electron属性，它又是 a并且直接具有该属性。所以在我的理解中访问应该是（这是未定义的），远程来自哪里以及为什么它在.ApplicationElectron.AllElectronMainInterfaceipcMainipcMainapp.electron.ipcMainspectron.d.ts

  2. SpectronClient所有返回的方法Promise<void>。所以我必须await或then那些。如果我查看 javascript 示例，它们会链接客户端语句：

return app.client
  .waitUntilWindowLoaded()
  .getTitle().should.equal('Launcher');

这在打字稿中不起作用，因为您不能Promise<void>明显地链接到...在 js 中如何工作？

4

1 回答 1

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));
}
于 2019-10-31T10:39:16.283 回答