ScuttleBot

scuttlebot / tests / e2e / node_modules / playwright / lib / isomorphic / testServerConnection.js
Blame History Raw 226 lines
1
"use strict";
2
var __create = Object.create;
3
var __defProp = Object.defineProperty;
4
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
var __getOwnPropNames = Object.getOwnPropertyNames;
6
var __getProtoOf = Object.getPrototypeOf;
7
var __hasOwnProp = Object.prototype.hasOwnProperty;
8
var __export = (target, all) => {
9
for (var name in all)
10
__defProp(target, name, { get: all[name], enumerable: true });
11
};
12
var __copyProps = (to, from, except, desc) => {
13
if (from && typeof from === "object" || typeof from === "function") {
14
for (let key of __getOwnPropNames(from))
15
if (!__hasOwnProp.call(to, key) && key !== except)
16
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
17
}
18
return to;
19
};
20
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
21
// If the importer is in node compatibility mode or this is not an ESM
22
// file that has been converted to a CommonJS file using a Babel-
23
// compatible transform (i.e. "__esModule" has not been set), then set
24
// "default" to the CommonJS "module.exports" for node compatibility.
25
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
26
mod
27
));
28
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
29
var testServerConnection_exports = {};
30
__export(testServerConnection_exports, {
31
TestServerConnection: () => TestServerConnection,
32
TestServerConnectionClosedError: () => TestServerConnectionClosedError,
33
WebSocketTestServerTransport: () => WebSocketTestServerTransport
34
});
35
module.exports = __toCommonJS(testServerConnection_exports);
36
var events = __toESM(require("./events"));
37
class TestServerConnectionClosedError extends Error {
38
constructor() {
39
super("Test server connection closed");
40
}
41
}
42
class WebSocketTestServerTransport {
43
constructor(url) {
44
this._ws = new WebSocket(url);
45
}
46
onmessage(listener) {
47
this._ws.addEventListener("message", (event) => listener(event.data.toString()));
48
}
49
onopen(listener) {
50
this._ws.addEventListener("open", listener);
51
}
52
onerror(listener) {
53
this._ws.addEventListener("error", listener);
54
}
55
onclose(listener) {
56
this._ws.addEventListener("close", listener);
57
}
58
send(data) {
59
this._ws.send(data);
60
}
61
close() {
62
this._ws.close();
63
}
64
}
65
class TestServerConnection {
66
constructor(transport) {
67
this._onCloseEmitter = new events.EventEmitter();
68
this._onReportEmitter = new events.EventEmitter();
69
this._onStdioEmitter = new events.EventEmitter();
70
this._onTestFilesChangedEmitter = new events.EventEmitter();
71
this._onLoadTraceRequestedEmitter = new events.EventEmitter();
72
this._onTestPausedEmitter = new events.EventEmitter();
73
this._lastId = 0;
74
this._callbacks = /* @__PURE__ */ new Map();
75
this._isClosed = false;
76
this.onClose = this._onCloseEmitter.event;
77
this.onReport = this._onReportEmitter.event;
78
this.onStdio = this._onStdioEmitter.event;
79
this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
80
this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
81
this.onTestPaused = this._onTestPausedEmitter.event;
82
this._transport = transport;
83
this._transport.onmessage((data) => {
84
const message = JSON.parse(data);
85
const { id, result, error, method, params } = message;
86
if (id) {
87
const callback = this._callbacks.get(id);
88
if (!callback)
89
return;
90
this._callbacks.delete(id);
91
if (error)
92
callback.reject(new Error(error));
93
else
94
callback.resolve(result);
95
} else {
96
this._dispatchEvent(method, params);
97
}
98
});
99
const pingInterval = setInterval(() => this._sendMessage("ping").catch(() => {
100
}), 3e4);
101
this._connectedPromise = new Promise((f, r) => {
102
this._transport.onopen(f);
103
this._transport.onerror(r);
104
});
105
this._transport.onclose(() => {
106
this._isClosed = true;
107
this._onCloseEmitter.fire();
108
clearInterval(pingInterval);
109
for (const callback of this._callbacks.values())
110
callback.reject(new TestServerConnectionClosedError());
111
this._callbacks.clear();
112
});
113
}
114
isClosed() {
115
return this._isClosed;
116
}
117
async _sendMessage(method, params) {
118
const logForTest = globalThis.__logForTest;
119
logForTest?.({ method, params });
120
await this._connectedPromise;
121
const id = ++this._lastId;
122
const message = { id, method, params };
123
this._transport.send(JSON.stringify(message));
124
return new Promise((resolve, reject) => {
125
this._callbacks.set(id, { resolve, reject });
126
});
127
}
128
_sendMessageNoReply(method, params) {
129
this._sendMessage(method, params).catch(() => {
130
});
131
}
132
_dispatchEvent(method, params) {
133
if (method === "report")
134
this._onReportEmitter.fire(params);
135
else if (method === "stdio")
136
this._onStdioEmitter.fire(params);
137
else if (method === "testFilesChanged")
138
this._onTestFilesChangedEmitter.fire(params);
139
else if (method === "loadTraceRequested")
140
this._onLoadTraceRequestedEmitter.fire(params);
141
else if (method === "testPaused")
142
this._onTestPausedEmitter.fire(params);
143
}
144
async initialize(params) {
145
await this._sendMessage("initialize", params);
146
}
147
async ping(params) {
148
await this._sendMessage("ping", params);
149
}
150
async pingNoReply(params) {
151
this._sendMessageNoReply("ping", params);
152
}
153
async watch(params) {
154
await this._sendMessage("watch", params);
155
}
156
watchNoReply(params) {
157
this._sendMessageNoReply("watch", params);
158
}
159
async open(params) {
160
await this._sendMessage("open", params);
161
}
162
openNoReply(params) {
163
this._sendMessageNoReply("open", params);
164
}
165
async resizeTerminal(params) {
166
await this._sendMessage("resizeTerminal", params);
167
}
168
resizeTerminalNoReply(params) {
169
this._sendMessageNoReply("resizeTerminal", params);
170
}
171
async checkBrowsers(params) {
172
return await this._sendMessage("checkBrowsers", params);
173
}
174
async installBrowsers(params) {
175
await this._sendMessage("installBrowsers", params);
176
}
177
async runGlobalSetup(params) {
178
return await this._sendMessage("runGlobalSetup", params);
179
}
180
async runGlobalTeardown(params) {
181
return await this._sendMessage("runGlobalTeardown", params);
182
}
183
async startDevServer(params) {
184
return await this._sendMessage("startDevServer", params);
185
}
186
async stopDevServer(params) {
187
return await this._sendMessage("stopDevServer", params);
188
}
189
async clearCache(params) {
190
return await this._sendMessage("clearCache", params);
191
}
192
async listFiles(params) {
193
return await this._sendMessage("listFiles", params);
194
}
195
async listTests(params) {
196
return await this._sendMessage("listTests", params);
197
}
198
async runTests(params) {
199
return await this._sendMessage("runTests", params);
200
}
201
async findRelatedTestFiles(params) {
202
return await this._sendMessage("findRelatedTestFiles", params);
203
}
204
async stopTests(params) {
205
await this._sendMessage("stopTests", params);
206
}
207
stopTestsNoReply(params) {
208
this._sendMessageNoReply("stopTests", params);
209
}
210
async closeGracefully(params) {
211
await this._sendMessage("closeGracefully", params);
212
}
213
close() {
214
try {
215
this._transport.close();
216
} catch {
217
}
218
}
219
}
220
// Annotate the CommonJS export names for ESM import in node:
221
0 && (module.exports = {
222
TestServerConnection,
223
TestServerConnectionClosedError,
224
WebSocketTestServerTransport
225
});
226

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button