test: move module tests to main process (#20419)

spec-main/modules-spec.ts

@@ -0,0 +1,153 @@
+import { expect } from 'chai'
+import * as path from 'path'
+import * as fs from 'fs'
+import { BrowserWindow } from 'electron'
+import { ifdescribe, ifit } from './spec-helpers'
+import { closeAllWindows } from './window-helpers'
+import * as childProcess from 'child_process'
+
+const Module = require('module')
+
+const features = process.electronBinding('features')
+const nativeModulesEnabled = !process.env.ELECTRON_SKIP_NATIVE_MODULE_TESTS
+
+describe('modules support', () => {
+  const fixtures = path.join(__dirname, 'fixtures')
+
+  describe('third-party module', () => {
+    ifdescribe(nativeModulesEnabled)('echo', () => {
+      afterEach(closeAllWindows)
+      it('can be required in renderer', async () => {
+        const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+        w.loadURL('about:blank')
+        await expect(w.webContents.executeJavaScript(`{ require('echo') }`)).to.be.fulfilled()
+      })
+
+      ifit(features.isRunAsNodeEnabled())('can be required in node binary', function (done) {
+        const child = childProcess.fork(path.join(fixtures, 'module', 'echo.js'))
+        child.on('message', (msg) => {
+          expect(msg).to.equal('ok')
+          done()
+        })
+      })
+
+      ifit(process.platform === 'win32')('can be required if electron.exe is renamed', () => {
+        const testExecPath = path.join(path.dirname(process.execPath), 'test.exe')
+        fs.copyFileSync(process.execPath, testExecPath)
+        try {
+          const fixture = path.join(fixtures, 'module', 'echo-renamed.js')
+          expect(fs.existsSync(fixture)).to.be.true()
+          const child = childProcess.spawnSync(testExecPath, [fixture])
+          expect(child.status).to.equal(0)
+        } finally {
+          fs.unlinkSync(testExecPath)
+        }
+      })
+    })
+
+    describe('q', () => {
+      const Q = require('q')
+      describe('Q.when', () => {
+        it('emits the fullfil callback', (done) => {
+          Q(true).then((val: boolean) => {
+            expect(val).to.be.true()
+            done()
+          })
+        })
+      })
+    })
+
+    describe('coffeescript', () => {
+      it('can be registered and used to require .coffee files', () => {
+        expect(() => {
+          require('coffeescript').register()
+        }).to.not.throw()
+        expect(require('./fixtures/module/test.coffee')).to.be.true()
+      })
+    })
+  })
+
+  describe('global variables', () => {
+    describe('process', () => {
+      it('can be declared in a module', () => {
+        expect(require('./fixtures/module/declare-process')).to.equal('declared process')
+      })
+    })
+
+    describe('global', () => {
+      it('can be declared in a module', () => {
+        expect(require('./fixtures/module/declare-global')).to.equal('declared global')
+      })
+    })
+
+    describe('Buffer', () => {
+      it('can be declared in a module', () => {
+        expect(require('./fixtures/module/declare-buffer')).to.equal('declared Buffer')
+      })
+    })
+  })
+
+  describe('Module._nodeModulePaths', () => {
+    describe('when the path is inside the resources path', () => {
+      it('does not include paths outside of the resources path', () => {
+        let modulePath = process.resourcesPath
+        expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
+          path.join(process.resourcesPath, 'node_modules')
+        ])
+
+        modulePath = process.resourcesPath + '-foo'
+        const nodeModulePaths = Module._nodeModulePaths(modulePath)
+        expect(nodeModulePaths).to.include(path.join(modulePath, 'node_modules'))
+        expect(nodeModulePaths).to.include(path.join(modulePath, '..', 'node_modules'))
+
+        modulePath = path.join(process.resourcesPath, 'foo')
+        expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
+          path.join(process.resourcesPath, 'foo', 'node_modules'),
+          path.join(process.resourcesPath, 'node_modules')
+        ])
+
+        modulePath = path.join(process.resourcesPath, 'node_modules', 'foo')
+        expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
+          path.join(process.resourcesPath, 'node_modules', 'foo', 'node_modules'),
+          path.join(process.resourcesPath, 'node_modules')
+        ])
+
+        modulePath = path.join(process.resourcesPath, 'node_modules', 'foo', 'bar')
+        expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
+          path.join(process.resourcesPath, 'node_modules', 'foo', 'bar', 'node_modules'),
+          path.join(process.resourcesPath, 'node_modules', 'foo', 'node_modules'),
+          path.join(process.resourcesPath, 'node_modules')
+        ])
+
+        modulePath = path.join(process.resourcesPath, 'node_modules', 'foo', 'node_modules', 'bar')
+        expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
+          path.join(process.resourcesPath, 'node_modules', 'foo', 'node_modules', 'bar', 'node_modules'),
+          path.join(process.resourcesPath, 'node_modules', 'foo', 'node_modules'),
+          path.join(process.resourcesPath, 'node_modules')
+        ])
+      })
+    })
+
+    describe('when the path is outside the resources path', () => {
+      it('includes paths outside of the resources path', () => {
+        const modulePath = path.resolve('/foo')
+        expect(Module._nodeModulePaths(modulePath)).to.deep.equal([
+          path.join(modulePath, 'node_modules'),
+          path.resolve('/node_modules')
+        ])
+      })
+    })
+  })
+
+  describe('require', () => {
+    describe('when loaded URL is not file: protocol', () => {
+      afterEach(closeAllWindows)
+      it('searches for module under app directory', async () => {
+        const w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
+        w.loadURL('about:blank')
+        const result = await w.webContents.executeJavaScript('typeof require("q").when')
+        expect(result).to.equal('function')
+      })
+    })
+  })
+})