Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
chore(valid-expect): convert to typescript (#387)
  • Loading branch information
G-Rath authored and SimenB committed Aug 12, 2019
1 parent b39aad5 commit ce86d4a
Show file tree
Hide file tree
Showing 4 changed files with 393 additions and 397 deletions.
@@ -1,7 +1,7 @@
import { RuleTester } from 'eslint';
import { TSESLint } from '@typescript-eslint/experimental-utils';
import rule from '../valid-expect';

const ruleTester = new RuleTester({
const ruleTester = new TSESLint.RuleTester({
parserOptions: {
ecmaVersion: 8,
},
Expand All @@ -15,23 +15,65 @@ ruleTester.run('valid-expect', rule, {
'expect(undefined).not.toBeDefined();',
'test("valid-expect", () => { return expect(Promise.resolve(2)).resolves.toBeDefined(); });',
'test("valid-expect", () => { return expect(Promise.reject(2)).rejects.toBeDefined(); });',
'test("valid-expect", () => { return expect(Promise.resolve(2)).not.resolves.toBeDefined(); });',
'test("valid-expect", () => { return expect(Promise.resolve(2)).not.rejects.toBeDefined(); });',
'test("valid-expect", function () { return expect(Promise.resolve(2)).not.resolves.toBeDefined(); });',
'test("valid-expect", function () { return expect(Promise.resolve(2)).not.rejects.toBeDefined(); });',
'test("valid-expect", function () { return Promise.resolve(expect(Promise.resolve(2)).not.resolves.toBeDefined()); });',
'test("valid-expect", function () { return Promise.resolve(expect(Promise.resolve(2)).not.rejects.toBeDefined()); });',
'test("valid-expect", () => { return expect(Promise.resolve(2)).resolves.not.toBeDefined(); });',
'test("valid-expect", () => { return expect(Promise.resolve(2)).rejects.not.toBeDefined(); });',
'test("valid-expect", function () { return expect(Promise.resolve(2)).resolves.not.toBeDefined(); });',
'test("valid-expect", function () { return expect(Promise.resolve(2)).rejects.not.toBeDefined(); });',
'test("valid-expect", function () { return Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined()); });',
'test("valid-expect", function () { return Promise.resolve(expect(Promise.resolve(2)).rejects.not.toBeDefined()); });',
{
code:
'test("valid-expect", () => expect(Promise.resolve(2)).resolves.toBeDefined());',
options: [{ alwaysAwait: true }],
},
'test("valid-expect", () => expect(Promise.resolve(2)).resolves.toBeDefined());',
'test("valid-expect", () => expect(Promise.reject(2)).rejects.toBeDefined());',
'test("valid-expect", () => expect(Promise.reject(2)).not.resolves.toBeDefined());',
'test("valid-expect", () => expect(Promise.reject(2)).not.rejects.toBeDefined());',
'test("valid-expect", () => expect(Promise.reject(2)).resolves.not.toBeDefined());',
'test("valid-expect", () => expect(Promise.reject(2)).rejects.not.toBeDefined());',
// 'test("valid-expect", () => expect(Promise.reject(2)).not.resolves.toBeDefined());',
// 'test("valid-expect", () => expect(Promise.reject(2)).not.rejects.toBeDefined());',
'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined(); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).rejects.not.toBeDefined(); });',
'test("valid-expect", async function () { await expect(Promise.reject(2)).resolves.not.toBeDefined(); });',
'test("valid-expect", async function () { await expect(Promise.reject(2)).rejects.not.toBeDefined(); });',
'test("valid-expect", async () => { await Promise.resolve(expect(Promise.reject(2)).rejects.not.toBeDefined()); });',
'test("valid-expect", async () => { await Promise.reject(expect(Promise.reject(2)).rejects.not.toBeDefined()); });',
'test("valid-expect", async () => { await Promise.all([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });',
'test("valid-expect", async () => { await Promise.race([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });',
'test("valid-expect", async () => { await Promise.allSettled([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });',
'test("valid-expect", async () => { await Promise.any([expect(Promise.reject(2)).rejects.not.toBeDefined(), expect(Promise.reject(2)).rejects.not.toBeDefined()]); });',
'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")); });',
'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).then(() => console.log("another valid case")); });',
'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().catch(() => console.log("valid-case")); });',
'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).catch(() => console.log("another valid case")); });',
'test("valid-expect", async () => { return expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).then(() => console.log("another valid case")); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().catch(() => console.log("valid-case")); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => console.log("valid-case")).catch(() => console.log("another valid case")); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).resolves.not.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });',
{
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => {
return expect(Promise.resolve(2)).resolves.toBe(1);
});
});`,
},
{
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(async () => {
await expect(Promise.resolve(2)).resolves.toBe(1);
});
});`,
},
{
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => expect(Promise.resolve(2)).resolves.toBe(1));
});`,
},
],
invalid: [
/*
'test("valid-expect", async () => { await expect(Promise.reject(2)).not.resolves.toBeDefined(); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).not.rejects.toBeDefined(); });',
'test("valid-expect", async function () { await expect(Promise.reject(2)).not.resolves.toBeDefined(); });',
Expand All @@ -52,28 +94,7 @@ ruleTester.run('valid-expect', rule, {
'test("valid-expect", async () => { await expect(Promise.reject(2)).not.resolves.toBeDefined().catch(() => console.log("valid-case")); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).not.resolves.toBeDefined().then(() => console.log("valid-case")).catch(() => console.log("another valid case")); });',
'test("valid-expect", async () => { await expect(Promise.reject(2)).not.resolves.toBeDefined().then(() => { expect(someMock).toHaveBeenCalledTimes(1); }); });',
{
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => {
return expect(Promise.resolve(2)).resolves.toBe(1);
});
});`,
},
{
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(async () => {
await expect(Promise.resolve(2)).resolves.toBe(1);
});
});`,
},
{
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => expect(Promise.resolve(2)).resolves.toBe(1));
});`,
},
],

invalid: [
*/
{
code: 'expect().toBe(true);',
errors: [{ endColumn: 8, column: 7, messageId: 'noArgs' }],
Expand Down Expand Up @@ -215,10 +236,10 @@ ruleTester.run('valid-expect', rule, {
},
],
},
// expect().not.resolves
// expect().resolves.not
{
code:
'test("valid-expect", () => { expect(Promise.resolve(2)).not.resolves.toBeDefined(); });',
'test("valid-expect", () => { expect(Promise.resolve(2)).resolves.not.toBeDefined(); });',
errors: [
{
column: 30,
Expand All @@ -241,10 +262,10 @@ ruleTester.run('valid-expect', rule, {
},
],
},
// expect().not.rejects
// expect().rejects.not
{
code:
'test("valid-expect", () => { expect(Promise.resolve(2)).not.rejects.toBeDefined(); });',
'test("valid-expect", () => { expect(Promise.resolve(2)).rejects.not.toBeDefined(); });',
errors: [
{
column: 30,
Expand All @@ -269,7 +290,7 @@ ruleTester.run('valid-expect', rule, {
},
{
code:
'test("valid-expect", async () => { expect(Promise.resolve(2)).not.resolves.toBeDefined(); });',
'test("valid-expect", async () => { expect(Promise.resolve(2)).resolves.not.toBeDefined(); });',
errors: [
{
column: 36,
Expand All @@ -281,9 +302,9 @@ ruleTester.run('valid-expect', rule, {
},
// alwaysAwait:false, one not awaited
{
code: `test("valid-expect", async () => {
expect(Promise.resolve(2)).not.resolves.toBeDefined();
expect(Promise.resolve(1)).rejects.toBeDefined();
code: `test("valid-expect", async () => {
expect(Promise.resolve(2)).resolves.not.toBeDefined();
expect(Promise.resolve(1)).rejects.toBeDefined();
});`,
errors: [
{
Expand All @@ -304,9 +325,9 @@ ruleTester.run('valid-expect', rule, {
},
// alwaysAwait: true, one returned
{
code: `test("valid-expect", async () => {
await expect(Promise.resolve(2)).not.resolves.toBeDefined();
expect(Promise.resolve(1)).rejects.toBeDefined();
code: `test("valid-expect", async () => {
await expect(Promise.resolve(2)).resolves.not.toBeDefined();
expect(Promise.resolve(1)).rejects.toBeDefined();
});`,
errors: [
{
Expand All @@ -323,9 +344,9 @@ ruleTester.run('valid-expect', rule, {
*/
// both not awaited
{
code: `test("valid-expect", async () => {
expect(Promise.resolve(2)).not.resolves.toBeDefined();
return expect(Promise.resolve(1)).rejects.toBeDefined();
code: `test("valid-expect", async () => {
expect(Promise.resolve(2)).resolves.not.toBeDefined();
return expect(Promise.resolve(1)).rejects.toBeDefined();
});`,
options: [{ alwaysAwait: true }],
errors: [
Expand All @@ -345,9 +366,9 @@ ruleTester.run('valid-expect', rule, {
},
// alwaysAwait:true, one not awaited, one returned
{
code: `test("valid-expect", async () => {
expect(Promise.resolve(2)).not.resolves.toBeDefined();
return expect(Promise.resolve(1)).rejects.toBeDefined();
code: `test("valid-expect", async () => {
expect(Promise.resolve(2)).resolves.not.toBeDefined();
return expect(Promise.resolve(1)).rejects.toBeDefined();
});`,
errors: [
{
Expand All @@ -361,9 +382,9 @@ ruleTester.run('valid-expect', rule, {
},
// one not awaited
{
code: `test("valid-expect", async () => {
await expect(Promise.resolve(2)).not.resolves.toBeDefined();
return expect(Promise.resolve(1)).rejects.toBeDefined();
code: `test("valid-expect", async () => {
await expect(Promise.resolve(2)).resolves.not.toBeDefined();
return expect(Promise.resolve(1)).rejects.toBeDefined();
});`,
options: [{ alwaysAwait: true }],
errors: [
Expand All @@ -380,8 +401,8 @@ ruleTester.run('valid-expect', rule, {
* Promise.x(expect()) usages
*/
{
code: `test("valid-expect", () => {
Promise.resolve(expect(Promise.resolve(2)).not.resolves.toBeDefined());
code: `test("valid-expect", () => {
Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined());
});`,
errors: [
{
Expand All @@ -394,8 +415,8 @@ ruleTester.run('valid-expect', rule, {
],
},
{
code: `test("valid-expect", () => {
Promise.reject(expect(Promise.resolve(2)).not.resolves.toBeDefined());
code: `test("valid-expect", () => {
Promise.reject(expect(Promise.resolve(2)).resolves.not.toBeDefined());
});`,
errors: [
{
Expand All @@ -408,8 +429,8 @@ ruleTester.run('valid-expect', rule, {
],
},
{
code: `test("valid-expect", () => {
Promise.x(expect(Promise.resolve(2)).not.resolves.toBeDefined());
code: `test("valid-expect", () => {
Promise.x(expect(Promise.resolve(2)).resolves.not.toBeDefined());
});`,
errors: [
{
Expand All @@ -423,8 +444,8 @@ ruleTester.run('valid-expect', rule, {
},
// alwaysAwait option changes error message
{
code: `test("valid-expect", () => {
Promise.resolve(expect(Promise.resolve(2)).not.resolves.toBeDefined());
code: `test("valid-expect", () => {
Promise.resolve(expect(Promise.resolve(2)).resolves.not.toBeDefined());
});`,
options: [{ alwaysAwait: true }],
errors: [
Expand All @@ -438,11 +459,11 @@ ruleTester.run('valid-expect', rule, {
},
// Promise method accepts arrays and returns 1 error
{
code: `test("valid-expect", () => {
code: `test("valid-expect", () => {
Promise.all([
expect(Promise.resolve(2)).not.resolves.toBeDefined(),
expect(Promise.resolve(3)).not.resolves.toBeDefined(),
]);
expect(Promise.resolve(2)).resolves.not.toBeDefined(),
expect(Promise.resolve(3)).resolves.not.toBeDefined(),
]);
});`,
errors: [
{
Expand All @@ -457,11 +478,11 @@ ruleTester.run('valid-expect', rule, {
},
// Promise.any([expect1, expect2]) returns one error
{
code: `test("valid-expect", () => {
code: `test("valid-expect", () => {
Promise.x([
expect(Promise.resolve(2)).not.resolves.toBeDefined(),
expect(Promise.resolve(3)).not.resolves.toBeDefined(),
]);
expect(Promise.resolve(2)).resolves.not.toBeDefined(),
expect(Promise.resolve(3)).resolves.not.toBeDefined(),
]);
});`,
errors: [
{
Expand All @@ -476,10 +497,10 @@ ruleTester.run('valid-expect', rule, {
},
//
{
code: `test("valid-expect", () => {
code: `test("valid-expect", () => {
const assertions = [
expect(Promise.resolve(2)).not.resolves.toBeDefined(),
expect(Promise.resolve(3)).not.resolves.toBeDefined(),
expect(Promise.resolve(2)).resolves.not.toBeDefined(),
expect(Promise.resolve(3)).resolves.not.toBeDefined(),
]
});`,
errors: [
Expand All @@ -505,6 +526,13 @@ ruleTester.run('valid-expect', rule, {
{
code: 'expect(Promise.resolve(2)).resolves.toBe;',
errors: [
{
line: 1,
column: 1,
endLine: 1,
endColumn: 42,
messageId: 'asyncMustBeAwaited',
},
{
column: 37,
endColumn: 41,
Expand All @@ -514,7 +542,7 @@ ruleTester.run('valid-expect', rule, {
],
},
{
code: `test("valid-expect", () => {
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(() => {
expect(Promise.resolve(2)).resolves.toBe(1);
});
Expand All @@ -531,7 +559,7 @@ ruleTester.run('valid-expect', rule, {
],
},
{
code: `test("valid-expect", () => {
code: `test("valid-expect", () => {
return expect(functionReturningAPromise()).resolves.toEqual(1).then(async () => {
await expect(Promise.resolve(2)).resolves.toBe(1);
expect(Promise.resolve(4)).resolves.toBe(4);
Expand Down
10 changes: 0 additions & 10 deletions src/rules/util.js
Expand Up @@ -22,21 +22,11 @@ export const expectResolvesCase = node =>
node.parent.parent.type === 'MemberExpression' &&
methodName(node) === 'resolves';

export const expectNotResolvesCase = node =>
expectNotCase(node) &&
node.parent.parent.type === 'MemberExpression' &&
methodName(node.parent) === 'resolves';

export const expectRejectsCase = node =>
expectCase(node) &&
node.parent.parent.type === 'MemberExpression' &&
methodName(node) === 'rejects';

export const expectNotRejectsCase = node =>
expectNotCase(node) &&
node.parent.parent.type === 'MemberExpression' &&
methodName(node.parent) === 'rejects';

export const expectToBeCase = (node, arg) =>
!(
expectNotCase(node) ||
Expand Down

0 comments on commit ce86d4a

Please sign in to comment.