Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

ts-migration/valid-expect #387

Merged
merged 1 commit into from Aug 12, 2019
Merged

ts-migration/valid-expect #387

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
174 changes: 101 additions & 73 deletions src/rules/__tests__/valid-expect.test.js → src/rules/__tests__/valid-expect.test.ts
View file
Open in desktop
@@ -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(); });',
G-Rath marked this conversation as resolved.
Show resolved Hide resolved
'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());',
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

?

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I left there here commented out b/c the whole thing was a mess, and I didn't know what the & wasn't valid :)

Case & point, up until now we were testing the the exact opposite of the correct (not.resolve) was correct.

Feel free to remove them if you want, but I'll def be circling back, so they won't be there for ever :)

// '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
View file
Open in desktop
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