319 lines
8.5 KiB
TypeScript
319 lines
8.5 KiB
TypeScript
/*
|
|
* Copyright The OpenTelemetry Authors
|
|
*
|
|
* 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
|
|
*
|
|
* https://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.
|
|
*/
|
|
|
|
import * as child_process from 'child_process';
|
|
import * as assert from 'assert';
|
|
import * as path from 'path';
|
|
import * as fs from 'fs';
|
|
import { IAutoImports, getAutoImports } from './helpers/autoImports';
|
|
|
|
const rValues =
|
|
/^\s*(Size|Loading time|Running time|Total time):[^\d]+([\d.]+\s*[\w]+).*$/gm;
|
|
|
|
const entryPoints = [
|
|
{
|
|
name: 'cjs',
|
|
entry: './build/src/index.js',
|
|
},
|
|
{
|
|
name: 'esm',
|
|
entry: './build/esm/index.js',
|
|
},
|
|
{
|
|
name: 'esnext',
|
|
entry: './build/esnext/index.js',
|
|
},
|
|
];
|
|
|
|
interface ISizeResult {
|
|
raw?: string;
|
|
size?: string;
|
|
loadTime?: string;
|
|
runTime?: string;
|
|
totalTime?: string;
|
|
}
|
|
|
|
describe('size-limits', function () {
|
|
const autoImports: IAutoImports = getAutoImports();
|
|
const results: {
|
|
[key: string]: {
|
|
full?: ISizeResult | null;
|
|
gzip?: ISizeResult | null;
|
|
brotli?: ISizeResult | null;
|
|
};
|
|
} = {};
|
|
const debugPath = path.resolve('./build/size-limit');
|
|
|
|
this.timeout(60000);
|
|
|
|
const _formatResults = (results?: ISizeResult | null): string => {
|
|
let output = '';
|
|
if (!results) {
|
|
return 'N/A';
|
|
}
|
|
|
|
const keys: Array<keyof ISizeResult> = [
|
|
'size',
|
|
'loadTime',
|
|
'runTime',
|
|
'totalTime',
|
|
];
|
|
keys.forEach(key => {
|
|
output +=
|
|
key.padEnd(8, '.') + ': ' + (results[key] || '').padEnd(12, ' ');
|
|
});
|
|
|
|
return output;
|
|
};
|
|
|
|
const checkSize = (
|
|
name: string,
|
|
filename: string,
|
|
imports: string,
|
|
gzip: boolean,
|
|
brotli: boolean
|
|
): ISizeResult | null => {
|
|
const filePath = path.resolve('.', '.size-limit.json');
|
|
try {
|
|
fs.writeFileSync(
|
|
filePath,
|
|
JSON.stringify([
|
|
{
|
|
path: filename,
|
|
import: imports,
|
|
name: name,
|
|
gzip: gzip,
|
|
brotli: brotli,
|
|
},
|
|
])
|
|
);
|
|
|
|
assert.ok(true, 'running');
|
|
const value = child_process.execSync(
|
|
'size-limit --save-bundle build/size-limit/' + name + ' --clean-dir'
|
|
);
|
|
|
|
let output = value.toString();
|
|
// remove screen escaping
|
|
// eslint-disable-next-line no-control-regex
|
|
output = output.replace(/\x1b\[\d+m/g, '');
|
|
const result: ISizeResult = {};
|
|
|
|
let matches: RegExpExecArray | null;
|
|
while ((matches = rValues.exec(output)) && matches.length > 1) {
|
|
switch (matches[1]) {
|
|
case 'Size':
|
|
result['size'] = matches[2];
|
|
!result.raw && (result.raw = output);
|
|
break;
|
|
case 'Loading time':
|
|
result['loadTime'] = matches[2];
|
|
!result.raw && (result.raw = output);
|
|
break;
|
|
case 'Running time':
|
|
result['runTime'] = matches[2];
|
|
!result.raw && (result.raw = output);
|
|
break;
|
|
case 'Total time':
|
|
result['totalTime'] = matches[2];
|
|
!result.raw && (result.raw = output);
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert.ok(
|
|
result && result.size,
|
|
'size not present - ' + JSON.stringify(result.size) + '[' + value + ']'
|
|
);
|
|
assert.ok(
|
|
result && result.loadTime,
|
|
'loading time not present - ' +
|
|
JSON.stringify(result.loadTime) +
|
|
'[' +
|
|
value +
|
|
']'
|
|
);
|
|
assert.ok(
|
|
result && result.runTime,
|
|
'run time not present - ' +
|
|
JSON.stringify(result.runTime) +
|
|
'[' +
|
|
value +
|
|
']'
|
|
);
|
|
assert.ok(
|
|
result && result.totalTime,
|
|
'total time not present - ' +
|
|
JSON.stringify(result.totalTime) +
|
|
'[' +
|
|
value +
|
|
']'
|
|
);
|
|
//assert.ok(result && result.raw, "raw not present - " + JSON.stringify(result.raw) + "[" + value + "]");
|
|
|
|
return Object.keys(result).length > 0 ? result : null;
|
|
} finally {
|
|
fs.unlinkSync(filePath);
|
|
}
|
|
};
|
|
|
|
before(() => {
|
|
if (!fs.existsSync(debugPath)) {
|
|
fs.mkdirSync(debugPath, { recursive: true });
|
|
}
|
|
|
|
fs.writeFileSync(
|
|
path.resolve(debugPath, 'autoImports.debug.txt'),
|
|
autoImports.getDebug()
|
|
);
|
|
});
|
|
|
|
after(() => {
|
|
// Log Results to Console
|
|
Object.keys(results).forEach(key => {
|
|
// eslint-disable-next-line no-console
|
|
console.log(
|
|
key.padEnd(16, '.') +
|
|
': ' +
|
|
JSON.stringify(
|
|
{
|
|
full: _formatResults(results[key].full),
|
|
gzip: _formatResults(results[key].gzip),
|
|
brotli: _formatResults(results[key].brotli),
|
|
},
|
|
null,
|
|
2
|
|
)
|
|
);
|
|
});
|
|
|
|
// Generate CSV Results
|
|
let csvResults =
|
|
'Group,Full Size,Full Load Time,Full Run Time,Full Total Time,GZip Size,GZip Load Time,GZip Run Time,GZip Total Time,Brotli Size,Brotli Load Time,Brotli Run Time,Brotli Total Time\n';
|
|
Object.keys(results).forEach(key => {
|
|
csvResults +=
|
|
key +
|
|
',' +
|
|
results[key].full?.size +
|
|
',' +
|
|
results[key].full?.loadTime +
|
|
',' +
|
|
results[key].full?.runTime +
|
|
',' +
|
|
results[key].full?.totalTime +
|
|
',' +
|
|
results[key].gzip?.size +
|
|
',' +
|
|
results[key].gzip?.loadTime +
|
|
',' +
|
|
results[key].gzip?.runTime +
|
|
',' +
|
|
results[key].gzip?.totalTime +
|
|
',' +
|
|
results[key].brotli?.size +
|
|
',' +
|
|
results[key].brotli?.loadTime +
|
|
',' +
|
|
results[key].brotli?.runTime +
|
|
',' +
|
|
results[key].brotli?.totalTime +
|
|
'\n';
|
|
});
|
|
|
|
// eslint-disable-next-line no-console
|
|
console.log(
|
|
"Writing results to '" + path.resolve(debugPath, 'results.csv') + "'"
|
|
);
|
|
fs.writeFileSync(path.resolve(debugPath, 'results.csv'), csvResults);
|
|
|
|
// Generate JSON Results for debugging
|
|
// eslint-disable-next-line no-console
|
|
console.log(
|
|
"Writing results to '" + path.resolve(debugPath, 'results.json') + "'"
|
|
);
|
|
fs.writeFileSync(
|
|
path.resolve(debugPath, 'results.json'),
|
|
JSON.stringify(results, null, 2)
|
|
);
|
|
});
|
|
|
|
entryPoints.forEach(entryPoint => {
|
|
describe('Checking ' + entryPoint.name, function () {
|
|
// eslint-disable-line no-undef
|
|
autoImports.getGroups().forEach(group => {
|
|
describe('Group ' + group, () => {
|
|
// eslint-disable-line no-undef
|
|
const checkResults: {
|
|
full?: ISizeResult | null;
|
|
gzip?: ISizeResult | null;
|
|
brotli?: ISizeResult | null;
|
|
} = {};
|
|
|
|
before(() => {
|
|
checkResults.full = checkSize(
|
|
entryPoint.name + '-' + group,
|
|
entryPoint.entry,
|
|
autoImports.getImportGroup(group),
|
|
false,
|
|
false
|
|
);
|
|
checkResults.gzip = checkSize(
|
|
entryPoint.name + '-' + group,
|
|
entryPoint.entry,
|
|
autoImports.getImportGroup(group),
|
|
true,
|
|
false
|
|
);
|
|
checkResults.brotli = checkSize(
|
|
entryPoint.name + '-' + group,
|
|
entryPoint.entry,
|
|
autoImports.getImportGroup(group),
|
|
false,
|
|
true
|
|
);
|
|
});
|
|
|
|
it(
|
|
'Calculating ' +
|
|
entryPoint.name +
|
|
'-' +
|
|
group +
|
|
' (' +
|
|
autoImports.getGroupValues(group).length +
|
|
')',
|
|
() => {
|
|
assert.ok(
|
|
checkResults.full,
|
|
'full size found - ' + JSON.stringify(checkResults.full)
|
|
);
|
|
assert.ok(
|
|
checkResults.gzip,
|
|
'gZip size found - ' + JSON.stringify(checkResults.gzip)
|
|
);
|
|
assert.ok(
|
|
checkResults.brotli,
|
|
'brotli size found - ' + JSON.stringify(checkResults.brotli)
|
|
);
|
|
|
|
results[entryPoint.name + '-' + group] = checkResults;
|
|
}
|
|
);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|