Research
Recent Trends in Malicious Packages Targeting Discord
The Socket research team breaks down a sampling of malicious packages that download and execute files, among other suspicious behaviors, targeting the popular Discord platform.
@putout/plugin-tape
Advanced tools
Readme
Tape-inspired TAP-compatible simplest high speed test runner with superpowers.
(c) πΌSupertape
πPutout plugin helps to apply best parctises for tests written with πΌSupertape.
npm i @putout/plugin-tape -D
{
"rules": {
"tape/convert-mock-require-to-mock-import": "off",
"tape/jest": "on",
"tape/apply-stub": "on",
"tape/apply-destructuring": "on",
"tape/apply-with-name": "on",
"tape/add-t-end": "on",
"tape/add-stop-all": "on",
"tape/add-await-to-re-import": "on",
"tape/remove-useless-t-end": "on",
"tape/sync-with-name": "on",
"tape/switch-expected-with-result": "on",
"tape/convert-tape-to-supertape": "on",
"tape/convert-throws-to-try-catch": "on",
"tape/convert-does-not-throw-to-try-catch": "on",
"tape/convert-called-with-args": "on",
"tape/convert-called-with-to-called-with-no-args": "on",
"tape/convert-called-with-no-args-to-called-with": "on",
"tape/convert-equal-to-called-once": "on",
"tape/convert-equal-to-deep-equal": "on",
"tape/convert-equals-to-equal": "on",
"tape/convert-deep-equal-to-equal": "on",
"tape/convert-emitter-to-promise": "on",
"tape/convert-ok-to-match": "on",
"tape/convert-ok-to-called-with": "on",
"tape/convert-match-regexp-to-string": "on",
"tape/add-args": "on",
"tape/declare": "on",
"tape/remove-default-messages": "on",
"tape/remove-useless-not-called-args": "on",
"tape/remove-only": "on",
"tape/remove-skip": "on",
"tape/remove-stop-all": "on"
}
}
πPutout gives ability to switch easily from Jest to πΌSupertape. Checkout in πPutout Editor.
it('should equal', () => {
expect(a).toEqual(b);
});
import {test} from 'supertape';
test('should equal', () => {
t.equal(a, b);
t.end();
});
πΌSupertape uses more natural way of
comparing: first you pass result
and then expected
.
It gives you ability to use value instead of expected
and
understand code faster: no need to search for a second argument.
While result
is always a variable, so it most likely much shorter.
test('plugin-apply-destructuring: transform: array: destructuring', (t) => {
t.equal(expected, result);
t.end();
});
test('plugin-apply-destructuring: transform: array: destructuring', (t) => {
t.equal(result, expected);
t.end();
});
const test = require('tape');
const test = require('supertape');
const test = require('supertape');
test('some message', (t) => {
t.throws(copymitter, /from should be a string!/, 'should throw when no args');
t.end();
});
const tryCatch = require('try-catch');
const test = require('supertape');
test('some message', (t) => {
const [error] = tryCatch(copymitter);
t.equal(error.message, 'from shoulde be a string!', 'should throw when no args');
t.end();
});
const test = require('supertape');
test('some message', (t) => {
t.doesNotThrow(copymitter, 'should throw when no args');
t.end();
});
const test = require('supertape');
const tryCatch = require('try-catch');
test('some test', (t) => {
const [error] = tryCatch(copymitter);
t.notOk(error, 'should not throw when no args');
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledWith(fn, 'hello');
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledWith(fn, ['hello']);
t.end();
});
No need to use equal
, supertape
supports calledOnce
.
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.equal(fn.callCount, 1);
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledOnce(fn);
t.end();
});
Use equal
when comparing with primitives, deepEqual
for Objects
and Arrays
;
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
t.deepEqual(x, 5);
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
t.equal(x, 5);
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledWith(fn);
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledWithNoArgs(fn);
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledWithNoArgs(fn, [1, 2]);
t.end();
});
const test = require('supertape');
const {stub} = test;
test('some message', (t) => {
const fn = stub();
fn();
t.calledWith(fn, [1, 2]);
t.end();
});
test('copymitter', (t) => {
const cp = copymitter(from, to, ['1']);
cp.on('end', (t) => {
t.end();
});
});
const {once} = require('events');
test('copymitter', async (t) => {
const cp = copymitter(from, to, ['1']);
await once(cp, 'end');
t.end();
});
Check out in πPutout Editor.
const test = require('supertape');
const {stub} = test;
const {test, stub} = require('supertape');
Apply stub functions created. Look how it works in πPutout Editor.
const a = async () => true;
const b = async () => {};
const c = async () => throwError('hello');
const d = async () => {
throw Error('hello');
};
const a = stub().resolves(true);
const b = stub().resolves();
const c = stub().rejects(Error('hello'));
const d = stub().rejects(Error('hello'));
test('should call init before show', (t) => {
const init = stub();
const show = stub();
t.calledInOrder([init, show]);
t.end();
});
test('should call init before show', (t) => {
const init = stub().withName('init');
const show = stub().withName('show');
t.calledInOrder([init, show]);
t.end();
});
test('should call init before show', (t) => {
const init = stub().withName('show');
const show = stub().withName('show');
t.calledInOrder([init, show]);
t.end();
});
test('should call init before show', (t) => {
const init = stub().withName('init');
const show = stub().withName('show');
t.calledInOrder([init, show]);
t.end();
});
mockImport
import {stub} from 'supertape';
mockImport('fs/promises', {
readFile: stub().resolves(''),
});
import {stub} from 'supertape';
import {createMockImport} from 'mock-import';
const {
mockImport,
stopAll,
reImport,
} = createMockImport(import.meta.url);
mockImport('fs/promises', {
readFile: stub().resolves(''),
});
test
test('xxx', (t) => {
const a = stub();
t.end();
});
import {test, stub} from 'supertape';
test('xxx', (t) => {
const a = stub();
t.end();
});
test('xxx', () => {
t.end();
});
test('xxx', (t) => {
t.end();
});
test('xxx', () => {});
test('xxx', (t) => {
t.end();
});
test('stop-all: should be called', (t) => {
const read = reImport('./read');
t.end();
});
test('stop-all: should be called', async (t) => {
const read = await reImport('./read');
t.end();
});
When you write test mocking ESM
with mockImport()
never forget to call stopAll()
when you no longer need it. This leads to bugs in tests which are hard to find, each test should be checked with the one which pass when called alone but fail when called with others.
test('stop-all: should be called', (t) => {
mockImport('fs/promises', {
readFile: stub(),
});
t.end();
});
test('stop-all: should be called', (t) => {
mockImport('fs/promises', {
readFile: stub(),
});
stopAll();
t.end();
});
test('test: remove me', () => {
t.end();
t.end();
});
test('test: remove me', () => {
t.end();
});
t.ok(result.includes('hello'));
t.match(result, /hello/);
t.ok(set.calledWith(1, 2));
t.calledWith(set, [1, 2]);
t.equal(error, null);
t.notOk(error);
t.equal(result, true);
t.ok(result);
const expected = {
hello: 'world',
};
t.equal(error, expected);
t.end();
const expected = {
hello: 'world',
};
t.deepEqual(error, expected);
t.end();
Checkout in πPutout Editor.
t.equals(e.message, 'token should be a string!', 'should throw');
t.equal(e.message, 'token should be a string!', 'should throw');
t.match(result, RegExp('hello'));
t.match(result, 'hello');
πΌSupertape will put this information for you, and it is always the same. No need to repeat the same information twice on one line, better to avoid it.
t.equal(result, expected, 'should equal');
t.equal(result, expected);
t.notCalled(fn, []);
t.notCalled(fn);
test.only('some test', (t) => {
t.end();
});
test('some test', (t) => {
t.end();
});
test.skip('some test', (t) => {
t.end();
});
test('some test', (t) => {
t.end();
});
When reImport()
or reRequire
not called, stopAll()
is redundant and should be removed.
test('some test', (t) => {
stopAll();
t.end();
});
test('some test', (t) => {
t.end();
});
Convert mockRequire to mockImport.
const mockRequire = require('mock-require');
const {reRequire, stopAll} = mockRequire;
test('', (t) => {
mockRequire('fs/promises', {
unlink: stub(),
});
const fn = reRequire('..');
fn();
stopAll();
t.end();
});
import {createMockImport} from 'mock-import';
const {
mockImport,
reImport,
stopAll,
} = createMockImport(import.meta.url);
test('', async (t) => {
mockImport('fs/promises', {
unlink: stub(),
});
const fn = await reImport('..');
fn();
stopAll();
t.end();
});
MIT
FAQs
πPutout plugin helps with tests
We found that @putout/plugin-tape demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago.Β It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
The Socket research team breaks down a sampling of malicious packages that download and execute files, among other suspicious behaviors, targeting the popular Discord platform.
Security News
Socket CEO Feross Aboukhadijeh joins a16z partners to discuss how modern, sophisticated supply chain attacks require AI-driven defenses and explore the challenges and solutions in leveraging AI for threat detection early in the development life cycle.
Security News
NIST's new AI Risk Management Framework aims to enhance the security and reliability of generative AI systems and address the unique challenges of malicious AI exploits.