node/test/es-module/test-esm-loader-globalpreload-hook.mjs at bbcd685067528f4af17d393dfe4d84edaa2f88c7 · GeoffreyBooth/node · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import { spawnPromisified } from '../common/index.mjs';
import * as fixtures from '../common/fixtures.mjs';
import assert from 'node:assert';
import os from 'node:os';
import { execPath } from 'node:process';
import { describe, it } from 'node:test';

describe('globalPreload hook', () => {
  it('should not emit deprecation warning when initialize is supplied', async () => {
    const { stderr } = await spawnPromisified(execPath, [
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){}export function initialize(){}',
      fixtures.path('empty.js'),
    ]);

    assert.doesNotMatch(stderr, /`globalPreload` is an experimental feature/);
  });

  it('should handle globalPreload returning undefined', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){}',
      fixtures.path('empty.js'),
    ]);

    assert.strictEqual(stderr, '');
    assert.strictEqual(stdout, '');
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });

  it('should handle loading node:test', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return `getBuiltin("node:test")()`}',
      fixtures.path('empty.js'),
    ]);

    assert.strictEqual(stderr, '');
    assert.match(stdout, /\n# pass 1\r?\n/);
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });

  it('should handle loading node:os with node: prefix', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return `console.log(getBuiltin("node:os").arch())`}',
      fixtures.path('empty.js'),
    ]);

    assert.strictEqual(stderr, '');
    assert.strictEqual(stdout.trim(), os.arch());
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });

  // `os` is used here because it's simple and not mocked (the builtin module otherwise doesn't matter).
  it('should handle loading builtin module without node: prefix', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return `console.log(getBuiltin("os").arch())`}',
      fixtures.path('empty.js'),
    ]);

    assert.strictEqual(stderr, '');
    assert.strictEqual(stdout.trim(), os.arch());
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });

  it('should throw when loading node:test without node: prefix', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return `getBuiltin("test")()`}',
      fixtures.path('empty.js'),
    ]);

    assert.match(stderr, /ERR_UNKNOWN_BUILTIN_MODULE/);
    assert.strictEqual(stdout, '');
    assert.strictEqual(code, 1);
    assert.strictEqual(signal, null);
  });

  it('should register globals set from globalPreload', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return "this.myGlobal=4"}',
      '--print', 'myGlobal',
    ]);

    assert.strictEqual(stderr, '');
    assert.strictEqual(stdout.trim(), '4');
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });

  it('should log console.log calls returned from globalPreload', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return `console.log("Hello from globalPreload")`}',
      fixtures.path('empty.js'),
    ]);

    assert.strictEqual(stderr, '');
    assert.strictEqual(stdout.trim(), 'Hello from globalPreload');
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });

  it('should crash if globalPreload returns code that throws', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      'data:text/javascript,export function globalPreload(){return `throw new Error("error from globalPreload")`}',
      fixtures.path('empty.js'),
    ]);

    assert.match(stderr, /error from globalPreload/);
    assert.strictEqual(stdout, '');
    assert.strictEqual(code, 1);
    assert.strictEqual(signal, null);
  });

  it('should have a `this` value that is not bound to the loader instance', async () => {
    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
      '--no-warnings',
      '--experimental-loader',
      `data:text/javascript,export ${function globalPreload() {
        if (this != null) {
          throw new Error('hook function must not be bound to ESMLoader instance');
        }
      }}`,
      fixtures.path('empty.js'),
    ]);

    assert.strictEqual(stderr, '');
    assert.strictEqual(stdout, '');
    assert.strictEqual(code, 0);
    assert.strictEqual(signal, null);
  });
});