mirror of
https://github.com/microsoft/playwright.git
synced 2024-12-14 21:53:35 +03:00
d76166beca
This patch moves fixtures.js to base.fixtures.ts that sits next to tests. All tests get an extra import to get the base fixtures (both types and implementations).
489 lines
14 KiB
JavaScript
489 lines
14 KiB
JavaScript
/**
|
|
* Copyright 2017 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
const http = require('http');
|
|
const https = require('https');
|
|
const url = require('url');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const WebSocketServer = require('ws').Server;
|
|
|
|
const fulfillSymbol = Symbol('fullfil callback');
|
|
const rejectSymbol = Symbol('reject callback');
|
|
|
|
class TestServer {
|
|
/**
|
|
* @param {string} dirPath
|
|
* @param {number} port
|
|
* @return {!Promise<TestServer>}
|
|
*/
|
|
static async create(dirPath, port) {
|
|
const server = new TestServer(dirPath, port);
|
|
await new Promise(x => server._server.once('listening', x));
|
|
return server;
|
|
}
|
|
|
|
/**
|
|
* @param {string} dirPath
|
|
* @param {number} port
|
|
* @return {!Promise<TestServer>}
|
|
*/
|
|
static async createHTTPS(dirPath, port) {
|
|
const server = new TestServer(dirPath, port, {
|
|
key: fs.readFileSync(path.join(__dirname, 'key.pem')),
|
|
cert: fs.readFileSync(path.join(__dirname, 'cert.pem')),
|
|
passphrase: 'aaaa',
|
|
});
|
|
await new Promise(x => server._server.once('listening', x));
|
|
return server;
|
|
}
|
|
|
|
/**
|
|
* @param {string} dirPath
|
|
* @param {number} port
|
|
* @param {!Object=} sslOptions
|
|
*/
|
|
constructor(dirPath, port, sslOptions) {
|
|
if (sslOptions)
|
|
this._server = https.createServer(sslOptions, this._onRequest.bind(this));
|
|
else
|
|
this._server = http.createServer(this._onRequest.bind(this));
|
|
this._server.on('connection', socket => this._onSocket(socket));
|
|
this._wsServer = new WebSocketServer({server: this._server, path: '/ws'});
|
|
this._wsServer.on('connection', this._onWebSocketConnection.bind(this));
|
|
this._server.listen(port);
|
|
this._dirPath = dirPath;
|
|
this.debugServer = require('debug')('pw:server');
|
|
|
|
this._startTime = new Date();
|
|
this._cachedPathPrefix = null;
|
|
|
|
/** @type {!Set<!NodeJS.Socket>} */
|
|
this._sockets = new Set();
|
|
/** @type {!Map<string, function(!http.IncomingMessage,http.ServerResponse)>} */
|
|
this._routes = new Map();
|
|
/** @type {!Map<string, !{username:string, password:string}>} */
|
|
this._auths = new Map();
|
|
/** @type {!Map<string, string>} */
|
|
this._csp = new Map();
|
|
/** @type {!Set<string>} */
|
|
this._gzipRoutes = new Set();
|
|
/** @type {!Map<string, !Promise>} */
|
|
this._requestSubscribers = new Map();
|
|
|
|
const protocol = sslOptions ? 'https' : 'http';
|
|
this.PORT = port;
|
|
this.PREFIX = `${protocol}://localhost:${port}`;
|
|
this.CROSS_PROCESS_PREFIX = `${protocol}://127.0.0.1:${port}`;
|
|
this.EMPTY_PAGE = `${protocol}://localhost:${port}/empty.html`;
|
|
|
|
}
|
|
|
|
_onSocket(socket) {
|
|
this._sockets.add(socket);
|
|
// ECONNRESET is a legit error given
|
|
// that tab closing simply kills process.
|
|
socket.on('error', error => {
|
|
if (error.code !== 'ECONNRESET')
|
|
throw error;
|
|
});
|
|
socket.once('close', () => this._sockets.delete(socket));
|
|
}
|
|
|
|
/**
|
|
* @param {string} pathPrefix
|
|
*/
|
|
enableHTTPCache(pathPrefix) {
|
|
this._cachedPathPrefix = pathPrefix;
|
|
}
|
|
|
|
/**
|
|
* @param {string} path
|
|
* @param {string} username
|
|
* @param {string} password
|
|
*/
|
|
setAuth(path, username, password) {
|
|
this.debugServer(`set auth for ${path} to ${username}:${password}`);
|
|
this._auths.set(path, {username, password});
|
|
}
|
|
|
|
enableGzip(path) {
|
|
this._gzipRoutes.add(path);
|
|
}
|
|
|
|
/**
|
|
* @param {string} path
|
|
* @param {string} csp
|
|
*/
|
|
setCSP(path, csp) {
|
|
this._csp.set(path, csp);
|
|
}
|
|
|
|
async stop() {
|
|
this.reset();
|
|
for (const socket of this._sockets)
|
|
socket.destroy();
|
|
this._sockets.clear();
|
|
await new Promise(x => this._server.close(x));
|
|
}
|
|
|
|
/**
|
|
* @param {string} path
|
|
* @param {function(!http.IncomingMessage,http.ServerResponse)} handler
|
|
*/
|
|
setRoute(path, handler) {
|
|
this._routes.set(path, handler);
|
|
}
|
|
|
|
/**
|
|
* @param {string} from
|
|
* @param {string} to
|
|
*/
|
|
setRedirect(from, to) {
|
|
this.setRoute(from, (req, res) => {
|
|
res.writeHead(302, { location: to });
|
|
res.end();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {string} path
|
|
* @return {!Promise<!http.IncomingMessage>}
|
|
*/
|
|
waitForRequest(path) {
|
|
let promise = this._requestSubscribers.get(path);
|
|
if (promise)
|
|
return promise;
|
|
let fulfill, reject;
|
|
promise = new Promise((f, r) => {
|
|
fulfill = f;
|
|
reject = r;
|
|
});
|
|
promise[fulfillSymbol] = fulfill;
|
|
promise[rejectSymbol] = reject;
|
|
this._requestSubscribers.set(path, promise);
|
|
return promise;
|
|
}
|
|
|
|
reset() {
|
|
this._routes.clear();
|
|
this._auths.clear();
|
|
this._csp.clear();
|
|
this._gzipRoutes.clear();
|
|
const error = new Error('Static Server has been reset');
|
|
for (const subscriber of this._requestSubscribers.values())
|
|
subscriber[rejectSymbol].call(null, error);
|
|
this._requestSubscribers.clear();
|
|
}
|
|
|
|
/**
|
|
* @param {http.IncomingMessage} request
|
|
* @param {http.ServerResponse} response
|
|
*/
|
|
_onRequest(request, response) {
|
|
request.on('error', error => {
|
|
if (error.code === 'ECONNRESET')
|
|
response.end();
|
|
else
|
|
throw error;
|
|
});
|
|
request.postBody = new Promise(resolve => {
|
|
let body = Buffer.from([]);
|
|
request.on('data', chunk => body = Buffer.concat([body, chunk]));
|
|
request.on('end', () => resolve(body));
|
|
});
|
|
const pathName = url.parse(request.url).path;
|
|
this.debugServer(`request ${request.method} ${pathName}`);
|
|
if (this._auths.has(pathName)) {
|
|
const auth = this._auths.get(pathName);
|
|
const credentials = Buffer.from((request.headers.authorization || '').split(' ')[1] || '', 'base64').toString();
|
|
this.debugServer(`request credentials ${credentials}`);
|
|
this.debugServer(`actual credentials ${auth.username}:${auth.password}`);
|
|
if (credentials !== `${auth.username}:${auth.password}`) {
|
|
this.debugServer(`request write www-auth`);
|
|
response.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Secure Area"' });
|
|
response.end('HTTP Error 401 Unauthorized: Access is denied');
|
|
return;
|
|
}
|
|
}
|
|
// Notify request subscriber.
|
|
if (this._requestSubscribers.has(pathName)) {
|
|
this._requestSubscribers.get(pathName)[fulfillSymbol].call(null, request);
|
|
this._requestSubscribers.delete(pathName);
|
|
}
|
|
const handler = this._routes.get(pathName);
|
|
if (handler) {
|
|
handler.call(null, request, response);
|
|
} else {
|
|
const pathName = url.parse(request.url).path;
|
|
this.serveFile(request, response, pathName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {!http.IncomingMessage} request
|
|
* @param {!http.ServerResponse} response
|
|
* @param {string} pathName
|
|
*/
|
|
serveFile(request, response, pathName) {
|
|
if (pathName === '/')
|
|
pathName = '/index.html';
|
|
const filePath = path.join(this._dirPath, pathName.substring(1));
|
|
|
|
if (this._cachedPathPrefix !== null && filePath.startsWith(this._cachedPathPrefix)) {
|
|
if (request.headers['if-modified-since']) {
|
|
response.statusCode = 304; // not modified
|
|
response.end();
|
|
return;
|
|
}
|
|
response.setHeader('Cache-Control', 'public, max-age=31536000, no-cache');
|
|
response.setHeader('Last-Modified', this._startTime.toISOString());
|
|
} else {
|
|
response.setHeader('Cache-Control', 'no-cache, no-store');
|
|
}
|
|
if (this._csp.has(pathName))
|
|
response.setHeader('Content-Security-Policy', this._csp.get(pathName));
|
|
|
|
fs.readFile(filePath, (err, data) => {
|
|
if (err) {
|
|
response.statusCode = 404;
|
|
response.end(`File not found: ${filePath}`);
|
|
return;
|
|
}
|
|
const extension = filePath.substring(filePath.lastIndexOf('.') + 1);
|
|
const mimeType = extensionToMime[extension] || 'application/octet-stream';
|
|
const isTextEncoding = /^text\/|^application\/(javascript|json)/.test(mimeType);
|
|
const contentType = isTextEncoding ? `${mimeType}; charset=utf-8` : mimeType;
|
|
response.setHeader('Content-Type', contentType);
|
|
if (this._gzipRoutes.has(pathName)) {
|
|
response.setHeader('Content-Encoding', 'gzip');
|
|
const zlib = require('zlib');
|
|
zlib.gzip(data, (_, result) => {
|
|
response.end(result);
|
|
});
|
|
} else {
|
|
response.end(data);
|
|
}
|
|
});
|
|
}
|
|
|
|
_onWebSocketConnection(ws) {
|
|
ws.send('incoming');
|
|
}
|
|
}
|
|
|
|
const extensionToMime = {
|
|
'ai': 'application/postscript',
|
|
'apng': 'image/apng',
|
|
'appcache': 'text/cache-manifest',
|
|
'au': 'audio/basic',
|
|
'bmp': 'image/bmp',
|
|
'cer': 'application/pkix-cert',
|
|
'cgm': 'image/cgm',
|
|
'coffee': 'text/coffeescript',
|
|
'conf': 'text/plain',
|
|
'crl': 'application/pkix-crl',
|
|
'css': 'text/css',
|
|
'csv': 'text/csv',
|
|
'def': 'text/plain',
|
|
'doc': 'application/msword',
|
|
'dot': 'application/msword',
|
|
'drle': 'image/dicom-rle',
|
|
'dtd': 'application/xml-dtd',
|
|
'ear': 'application/java-archive',
|
|
'emf': 'image/emf',
|
|
'eps': 'application/postscript',
|
|
'exr': 'image/aces',
|
|
'fits': 'image/fits',
|
|
'g3': 'image/g3fax',
|
|
'gbr': 'application/rpki-ghostbusters',
|
|
'gif': 'image/gif',
|
|
'glb': 'model/gltf-binary',
|
|
'gltf': 'model/gltf+json',
|
|
'gz': 'application/gzip',
|
|
'h261': 'video/h261',
|
|
'h263': 'video/h263',
|
|
'h264': 'video/h264',
|
|
'heic': 'image/heic',
|
|
'heics': 'image/heic-sequence',
|
|
'heif': 'image/heif',
|
|
'heifs': 'image/heif-sequence',
|
|
'htm': 'text/html',
|
|
'html': 'text/html',
|
|
'ics': 'text/calendar',
|
|
'ief': 'image/ief',
|
|
'ifb': 'text/calendar',
|
|
'iges': 'model/iges',
|
|
'igs': 'model/iges',
|
|
'in': 'text/plain',
|
|
'ini': 'text/plain',
|
|
'jade': 'text/jade',
|
|
'jar': 'application/java-archive',
|
|
'jls': 'image/jls',
|
|
'jp2': 'image/jp2',
|
|
'jpe': 'image/jpeg',
|
|
'jpeg': 'image/jpeg',
|
|
'jpf': 'image/jpx',
|
|
'jpg': 'image/jpeg',
|
|
'jpg2': 'image/jp2',
|
|
'jpgm': 'video/jpm',
|
|
'jpgv': 'video/jpeg',
|
|
'jpm': 'image/jpm',
|
|
'jpx': 'image/jpx',
|
|
'js': 'application/javascript',
|
|
'json': 'application/json',
|
|
'json5': 'application/json5',
|
|
'jsx': 'text/jsx',
|
|
'jxr': 'image/jxr',
|
|
'kar': 'audio/midi',
|
|
'ktx': 'image/ktx',
|
|
'less': 'text/less',
|
|
'list': 'text/plain',
|
|
'litcoffee': 'text/coffeescript',
|
|
'log': 'text/plain',
|
|
'm1v': 'video/mpeg',
|
|
'm21': 'application/mp21',
|
|
'm2a': 'audio/mpeg',
|
|
'm2v': 'video/mpeg',
|
|
'm3a': 'audio/mpeg',
|
|
'm4a': 'audio/mp4',
|
|
'm4p': 'application/mp4',
|
|
'man': 'text/troff',
|
|
'manifest': 'text/cache-manifest',
|
|
'markdown': 'text/markdown',
|
|
'mathml': 'application/mathml+xml',
|
|
'md': 'text/markdown',
|
|
'mdx': 'text/mdx',
|
|
'me': 'text/troff',
|
|
'mesh': 'model/mesh',
|
|
'mft': 'application/rpki-manifest',
|
|
'mid': 'audio/midi',
|
|
'midi': 'audio/midi',
|
|
'mj2': 'video/mj2',
|
|
'mjp2': 'video/mj2',
|
|
'mjs': 'application/javascript',
|
|
'mml': 'text/mathml',
|
|
'mov': 'video/quicktime',
|
|
'mp2': 'audio/mpeg',
|
|
'mp21': 'application/mp21',
|
|
'mp2a': 'audio/mpeg',
|
|
'mp3': 'audio/mpeg',
|
|
'mp4': 'video/mp4',
|
|
'mp4a': 'audio/mp4',
|
|
'mp4s': 'application/mp4',
|
|
'mp4v': 'video/mp4',
|
|
'mpe': 'video/mpeg',
|
|
'mpeg': 'video/mpeg',
|
|
'mpg': 'video/mpeg',
|
|
'mpg4': 'video/mp4',
|
|
'mpga': 'audio/mpeg',
|
|
'mrc': 'application/marc',
|
|
'ms': 'text/troff',
|
|
'msh': 'model/mesh',
|
|
'n3': 'text/n3',
|
|
'oga': 'audio/ogg',
|
|
'ogg': 'audio/ogg',
|
|
'ogv': 'video/ogg',
|
|
'ogx': 'application/ogg',
|
|
'otf': 'font/otf',
|
|
'p10': 'application/pkcs10',
|
|
'p7c': 'application/pkcs7-mime',
|
|
'p7m': 'application/pkcs7-mime',
|
|
'p7s': 'application/pkcs7-signature',
|
|
'p8': 'application/pkcs8',
|
|
'pdf': 'application/pdf',
|
|
'pki': 'application/pkixcmp',
|
|
'pkipath': 'application/pkix-pkipath',
|
|
'png': 'image/png',
|
|
'ps': 'application/postscript',
|
|
'pskcxml': 'application/pskc+xml',
|
|
'qt': 'video/quicktime',
|
|
'rmi': 'audio/midi',
|
|
'rng': 'application/xml',
|
|
'roa': 'application/rpki-roa',
|
|
'roff': 'text/troff',
|
|
'rsd': 'application/rsd+xml',
|
|
'rss': 'application/rss+xml',
|
|
'rtf': 'application/rtf',
|
|
'rtx': 'text/richtext',
|
|
's3m': 'audio/s3m',
|
|
'sgi': 'image/sgi',
|
|
'sgm': 'text/sgml',
|
|
'sgml': 'text/sgml',
|
|
'shex': 'text/shex',
|
|
'shtml': 'text/html',
|
|
'sil': 'audio/silk',
|
|
'silo': 'model/mesh',
|
|
'slim': 'text/slim',
|
|
'slm': 'text/slim',
|
|
'snd': 'audio/basic',
|
|
'spx': 'audio/ogg',
|
|
'stl': 'model/stl',
|
|
'styl': 'text/stylus',
|
|
'stylus': 'text/stylus',
|
|
'svg': 'image/svg+xml',
|
|
'svgz': 'image/svg+xml',
|
|
't': 'text/troff',
|
|
't38': 'image/t38',
|
|
'text': 'text/plain',
|
|
'tfx': 'image/tiff-fx',
|
|
'tif': 'image/tiff',
|
|
'tiff': 'image/tiff',
|
|
'tr': 'text/troff',
|
|
'ts': 'video/mp2t',
|
|
'tsv': 'text/tab-separated-values',
|
|
'ttc': 'font/collection',
|
|
'ttf': 'font/ttf',
|
|
'ttl': 'text/turtle',
|
|
'txt': 'text/plain',
|
|
'uri': 'text/uri-list',
|
|
'uris': 'text/uri-list',
|
|
'urls': 'text/uri-list',
|
|
'vcard': 'text/vcard',
|
|
'vrml': 'model/vrml',
|
|
'vtt': 'text/vtt',
|
|
'war': 'application/java-archive',
|
|
'wasm': 'application/wasm',
|
|
'wav': 'audio/wav',
|
|
'weba': 'audio/webm',
|
|
'webm': 'video/webm',
|
|
'webmanifest': 'application/manifest+json',
|
|
'webp': 'image/webp',
|
|
'wmf': 'image/wmf',
|
|
'woff': 'font/woff',
|
|
'woff2': 'font/woff2',
|
|
'wrl': 'model/vrml',
|
|
'x3d': 'model/x3d+xml',
|
|
'x3db': 'model/x3d+fastinfoset',
|
|
'x3dbz': 'model/x3d+binary',
|
|
'x3dv': 'model/x3d-vrml',
|
|
'x3dvz': 'model/x3d+vrml',
|
|
'x3dz': 'model/x3d+xml',
|
|
'xaml': 'application/xaml+xml',
|
|
'xht': 'application/xhtml+xml',
|
|
'xhtml': 'application/xhtml+xml',
|
|
'xm': 'audio/xm',
|
|
'xml': 'text/xml',
|
|
'xsd': 'application/xml',
|
|
'xsl': 'application/xml',
|
|
'xslt': 'application/xslt+xml',
|
|
'yaml': 'text/yaml',
|
|
'yml': 'text/yaml',
|
|
'zip': 'application/zip'
|
|
};
|
|
|
|
module.exports = {TestServer};
|