IPC Main <-> Renderer Example Test

Following the Electron recommendations, I’m removing remote access completely in renderer and convert everything to be IPC via .invoke()

Is it possible to test IPC communication between Main/Renderer via e-mocha ?

If so, could you provide a simple e-mocha test on how to trigger an IPC event from renderer that is then received in main process (or vice versa) ?

I’ve looked through the provided test examples as well as projects that use e-mocha, but did not find a suitable example.

Thanks.

Electron 12.0.2 E-Mocha 9.3.3 Win x64

[inukshuk]

If you stub a method, the original method is replaced on the context instance.

In the updated example 1 you allegedly stub a method, yet the original is invoked (there’s console output) so this means my_class (the one you stubbed) is not the same instance as the one that was registered to receive the IPC messages. This is further confirmed by the fact that your stub was not called at all.

In the updated example 2:

1. You call ipcMain.handle first
2. Then you create a spy on ipcMain.handle
3. You don’t call ipcMain.handle again (it is not called on receiving IPC messages either)
4. So obviously the call count is zero

There is nothing surprising about this. You seem to expect that ipcMain.handle will be invoked when an IPC message is received, but it is not. You set up the handler first (the function you pass as the second argument to ipcMain.handle) and only the handler will be invoked. If you want to stub/spy on the handler you need to create the stub/spy first to make sure that at the moment ipcMain.handle is called it is already the stub/spy that is registered not the original method.

So example 2 looks just fine, but the test makes no sense. Example 1 is a better way to test the fact that the IPC communication took place, but there must be an error in your setup. It looks like you create another My_Class instance somewhere and call its init() method – while the init() method of the My_Class instance which you then use to stub the callback is not called at all.

This test works fine for me (test.html is an empty HTML page):

const { join } = require('path')
const sinon = require('sinon')
const { ipcMain, BrowserWindow } = require('electron')

describe.only('IPC Handlers', () => {
  let spy

  beforeEach(() => {
    spy = sinon.spy()
    ipcMain.handle('test', async () => spy())
  })

  afterEach(() => {
    ipcMain.removeHandler('test')
  })

  it('can be invoked', async () => {
    let win = new BrowserWindow({
      webPreferences: {
        contextIsolation: false,
        nodeIntegration: true
      }
    })

    await win.loadFile(join(__dirname, 'test.html'))

    win.webContents.executeJavaScript(
      `require('electron').ipcRenderer.invoke('test')`
    )

    // Allow some time for the IPC messages to be sent.
    await new Promise((resolve) => setTimeout(resolve, 500))

    win.destroy()

    expect(spy.callCount).to.equal(1)
  })
})

[inukshuk]

In a given process, ipcMain is always the same thing no matter how many times you import/require it. If I’m not mistaken, there can only be a single handler per channel, so it’s no problem to remove your test handler, after a test with using ipcMain.removeHandler(channel).