Use jest assertion in place of expect (#3003)

Migrate all test using expect assertions to jest
Delete mocha-runner.html

Fixes: #2995

Author: zimbabao

src/actions/tests/breakpoints.js

@@ -1,5 +1,3 @@
-import expect from "expect.js";
-
 import { createStore, selectors, actions } from "../../utils/test-head";
 import {
   simulateCorrectThreadClient,
@@ -14,8 +12,8 @@ describe("breakpoints", () => {
     await dispatch(actions.addBreakpoint(loc1));
     const bps = selectors.getBreakpoints(getState());
     const bp = selectors.getBreakpoint(getState(), loc1);
-    expect(bps.size).to.be(1);
-    expect(bp.location).to.eql(loc1);
+    expect(bps.size).toBe(1);
+    expect(bp.location).toEqual(loc1);
   });
 
   it("should not re-add a breakpoint", async () => {
@@ -25,12 +23,12 @@ describe("breakpoints", () => {
     await dispatch(actions.addBreakpoint(loc1));
     let bps = selectors.getBreakpoints(getState());
     const bp = selectors.getBreakpoint(getState(), loc1);
-    expect(bps.size).to.be(1);
-    expect(bp.location).to.eql(loc1);
+    expect(bps.size).toBe(1);
+    expect(bp.location).toEqual(loc1);
 
     await dispatch(actions.addBreakpoint(loc1));
     bps = selectors.getBreakpoints(getState());
-    expect(bps.size).to.be(1);
+    expect(bps.size).toBe(1);
   });
 
   describe("adding a breakpoint to an invalid location", async () => {
@@ -46,8 +44,8 @@ describe("breakpoints", () => {
       const state = getState();
       const bps = selectors.getBreakpoints(state);
       const bp = selectors.getBreakpoint(state, correctedLocation);
-      expect(bps.size).to.be(1);
-      expect(bp.location).to.eql(correctedLocation);
+      expect(bps.size).toBe(1);
+      expect(bp.location).toEqual(correctedLocation);
     });
   });
 
@@ -62,7 +60,7 @@ describe("breakpoints", () => {
 
     await dispatch(actions.removeBreakpoint(loc1));
 
-    expect(selectors.getBreakpoints(getState()).size).to.be(1);
+    expect(selectors.getBreakpoints(getState()).size).toBe(1);
   });
 
   it("should disable a breakpoint", async () => {
@@ -76,7 +74,7 @@ describe("breakpoints", () => {
 
     await dispatch(actions.disableBreakpoint(loc1));
 
-    expect(selectors.getBreakpoint(getState(), loc1).disabled).to.be(true);
+    expect(selectors.getBreakpoint(getState(), loc1).disabled).toBe(true);
   });
 
   it("should enable breakpoint", async () => {
@@ -86,11 +84,11 @@ describe("breakpoints", () => {
     await dispatch(actions.addBreakpoint(loc));
     await dispatch(actions.disableBreakpoint(loc));
 
-    expect(selectors.getBreakpoint(getState(), loc).disabled).to.be(true);
+    expect(selectors.getBreakpoint(getState(), loc).disabled).toBe(true);
 
     await dispatch(actions.enableBreakpoint(loc));
 
-    expect(selectors.getBreakpoint(getState(), loc).disabled).to.be(false);
+    expect(selectors.getBreakpoint(getState(), loc).disabled).toBe(false);
   });
 
   it("should toggle all the breakpoints", async () => {
@@ -104,13 +102,13 @@ describe("breakpoints", () => {
 
     await dispatch(actions.toggleAllBreakpoints(true));
 
-    expect(selectors.getBreakpoint(getState(), loc1).disabled).to.be(true);
-    expect(selectors.getBreakpoint(getState(), loc2).disabled).to.be(true);
+    expect(selectors.getBreakpoint(getState(), loc1).disabled).toBe(true);
+    expect(selectors.getBreakpoint(getState(), loc2).disabled).toBe(true);
 
     await dispatch(actions.toggleAllBreakpoints());
 
-    expect(selectors.getBreakpoint(getState(), loc1).disabled).to.be(false);
-    expect(selectors.getBreakpoint(getState(), loc2).disabled).to.be(false);
+    expect(selectors.getBreakpoint(getState(), loc1).disabled).toBe(false);
+    expect(selectors.getBreakpoint(getState(), loc2).disabled).toBe(false);
   });
 
   it("should set the breakpoint condition", async () => {
@@ -120,7 +118,7 @@ describe("breakpoints", () => {
 
     await dispatch(actions.addBreakpoint(loc));
 
-    expect(selectors.getBreakpoint(getState(), loc).condition).to.be(null);
+    expect(selectors.getBreakpoint(getState(), loc).condition).toBe(null);
 
     await dispatch(
       actions.setBreakpointCondition(loc, {
@@ -129,7 +127,7 @@ describe("breakpoints", () => {
       })
     );
 
-    expect(selectors.getBreakpoint(getState(), loc).condition).to.be(
+    expect(selectors.getBreakpoint(getState(), loc).condition).toBe(
       "const foo = 0"
     );
   });

src/actions/tests/expressions.js

@@ -1,4 +1,3 @@
-import expect from "expect.js";
 import { actions, selectors, createStore } from "../../utils/test-head";
 
 const mockThreadClient = {
@@ -20,8 +19,8 @@ describe("expressions", () => {
     dispatch(actions.addExpression("foo"));
     dispatch(actions.addExpression("bar", { visible: false }));
 
-    expect(selectors.getExpressions(getState()).size).to.be(2);
-    expect(selectors.getVisibleExpressions(getState()).size).to.be(1);
+    expect(selectors.getExpressions(getState()).size).toBe(2);
+    expect(selectors.getVisibleExpressions(getState()).size).toBe(1);
   });
 
   it("should update an expression", () => {
@@ -31,7 +30,7 @@ describe("expressions", () => {
     const expression = selectors.getExpression(getState(), "foo");
     dispatch(actions.updateExpression("bar", expression));
 
-    expect(selectors.getExpression(getState(), "bar").input).to.be("bar");
+    expect(selectors.getExpression(getState(), "bar").input).toBe("bar");
   });
 
   it("should delete an expression", () => {
@@ -40,13 +39,13 @@ describe("expressions", () => {
     dispatch(actions.addExpression("foo"));
     dispatch(actions.addExpression("bar", { visible: false }));
 
-    expect(selectors.getExpressions(getState()).size).to.be(2);
+    expect(selectors.getExpressions(getState()).size).toBe(2);
 
     const expression = selectors.getExpression(getState(), "foo");
     dispatch(actions.deleteExpression(expression));
 
-    expect(selectors.getExpressions(getState()).size).to.be(1);
-    expect(selectors.getExpression(getState(), "bar").input).to.be("bar");
+    expect(selectors.getExpressions(getState()).size).toBe(1);
+    expect(selectors.getExpression(getState(), "bar").input).toBe("bar");
   });
 
   it("should evaluate expressions global scope", async () => {
@@ -55,12 +54,12 @@ describe("expressions", () => {
     dispatch(actions.addExpression("foo"));
     dispatch(actions.addExpression("bar", { visible: false }));
 
-    expect(selectors.getExpression(getState(), "foo").value).to.be(null);
-    expect(selectors.getExpression(getState(), "bar").value).to.be(null);
+    expect(selectors.getExpression(getState(), "foo").value).toBe(null);
+    expect(selectors.getExpression(getState(), "bar").value).toBe(null);
     await dispatch(actions.evaluateExpressions());
 
-    expect(selectors.getExpression(getState(), "foo").value).to.be("bla");
-    expect(selectors.getExpression(getState(), "bar").value).to.be("bla");
+    expect(selectors.getExpression(getState(), "foo").value).toBe("bla");
+    expect(selectors.getExpression(getState(), "bar").value).toBe("bla");
   });
 
   it("should evaluate expressions in specific scope", async () => {
@@ -69,11 +68,11 @@ describe("expressions", () => {
     dispatch(actions.addExpression("foo"));
     dispatch(actions.addExpression("bar", { visible: false }));
 
-    expect(selectors.getExpression(getState(), "foo").value).to.be(null);
-    expect(selectors.getExpression(getState(), "bar").value).to.be(null);
+    expect(selectors.getExpression(getState(), "foo").value).toBe(null);
+    expect(selectors.getExpression(getState(), "bar").value).toBe(null);
     await dispatch(actions.evaluateExpressions("boo"));
 
-    expect(selectors.getExpression(getState(), "foo").value).to.be("boo");
-    expect(selectors.getExpression(getState(), "bar").value).to.be("boo");
+    expect(selectors.getExpression(getState(), "foo").value).toBe("boo");
+    expect(selectors.getExpression(getState(), "bar").value).toBe("boo");
   });
 });

src/actions/tests/pending-breakpoints.js

@@ -32,7 +32,6 @@ import {
   makeSource
 } from "../../utils/test-head";
 import { makePendingLocationId } from "../../reducers/breakpoints";
-import expect from "expect.js";
 
 describe("when adding breakpoints", () => {
   it("a corresponding pending breakpoint should be added", async () => {
@@ -42,8 +41,8 @@ describe("when adding breakpoints", () => {
 
     await dispatch(actions.addBreakpoint(bp.location));
     const pendingBps = selectors.getPendingBreakpoints(getState());
-    expect(pendingBps.size).to.be(2);
-    expect(pendingBps.get(id)).to.eql(generatePendingBreakpoint(bp));
+    expect(pendingBps.size).toBe(2);
+    expect(pendingBps.get(id)).toEqual(generatePendingBreakpoint(bp));
   });
 
   describe("adding and deleting breakpoints", () => {
@@ -65,10 +64,10 @@ describe("when adding breakpoints", () => {
       await dispatch(actions.addBreakpoint(breakpoint2.location));
 
       const pendingBps = selectors.getPendingBreakpoints(getState());
-      expect(pendingBps.get(breakpointLocationId1)).to.eql(
+      expect(pendingBps.get(breakpointLocationId1)).toEqual(
         generatePendingBreakpoint(breakpoint1)
       );
-      expect(pendingBps.get(breakpointLocationId2)).to.eql(
+      expect(pendingBps.get(breakpointLocationId2)).toEqual(
         generatePendingBreakpoint(breakpoint2)
       );
     });
@@ -80,8 +79,8 @@ describe("when adding breakpoints", () => {
       await dispatch(actions.removeBreakpoint(breakpoint1.location));
 
       const pendingBps = selectors.getPendingBreakpoints(getState());
-      expect(pendingBps.has(breakpointLocationId1)).not.to.be(true);
-      expect(pendingBps.has(breakpointLocationId2)).to.be(true);
+      expect(pendingBps.has(breakpointLocationId1)).not.toBe(true);
+      expect(pendingBps.has(breakpointLocationId2)).toBe(true);
     });
   });
 });
@@ -98,7 +97,7 @@ describe("when changing an existing breakpoint", () => {
     );
     const bps = selectors.getPendingBreakpoints(getState());
     const breakpoint = bps.get(id);
-    expect(breakpoint.condition).to.be("2");
+    expect(breakpoint.condition).toBe("2");
   });
 
   it("if disabled, updates corresponding pendingBreakpoint", async () => {
@@ -110,7 +109,7 @@ describe("when changing an existing breakpoint", () => {
     await dispatch(actions.disableBreakpoint(bp.location));
     const bps = selectors.getPendingBreakpoints(getState());
     const breakpoint = bps.get(id);
-    expect(breakpoint.disabled).to.be(true);
+    expect(breakpoint.disabled).toBe(true);
   });
 
   it("does not delete the pre-existing pendingBreakpoint", async () => {
@@ -124,7 +123,7 @@ describe("when changing an existing breakpoint", () => {
     );
     const bps = selectors.getPendingBreakpoints(getState());
     const breakpoint = bps.get(id);
-    expect(breakpoint.condition).to.be("2");
+    expect(breakpoint.condition).toBe("2");
   });
 });
 
@@ -134,7 +133,7 @@ describe("initializing when pending breakpoints exist in perfs", () => {
     const id = makePendingLocationId(theMockedPendingBreakpoint.location);
     const bps = selectors.getPendingBreakpoints(getState());
     const bp = bps.get(id);
-    expect(bp).to.eql(generatePendingBreakpoint(theMockedPendingBreakpoint));
+    expect(bp).toEqual(generatePendingBreakpoint(theMockedPendingBreakpoint));
   });
 
   it("readding breakpoints update existing pending breakpoints", async () => {
@@ -144,7 +143,7 @@ describe("initializing when pending breakpoints exist in perfs", () => {
     await dispatch(actions.addBreakpoint(bar.location));
 
     const bps = selectors.getPendingBreakpoints(getState());
-    expect(bps.size).to.be(1);
+    expect(bps.size).toBe(1);
   });
 
   it("adding bps doesn't remove existing pending breakpoints", async () => {
@@ -154,7 +153,7 @@ describe("initializing when pending breakpoints exist in perfs", () => {
     await dispatch(actions.addBreakpoint(bp.location));
 
     const bps = selectors.getPendingBreakpoints(getState());
-    expect(bps.size).to.be(2);
+    expect(bps.size).toBe(2);
   });
 });
 
@@ -163,25 +162,25 @@ describe("adding sources", () => {
     const { dispatch, getState } = createStore(simpleMockThreadClient);
 
     let bps = selectors.getBreakpoints(getState());
-    expect(bps.size).to.be(0);
+    expect(bps.size).toBe(0);
 
     const source = makeSource("bar.js");
     await dispatch(actions.newSource(source));
     bps = selectors.getBreakpoints(getState());
-    expect(bps.size).to.be(1);
+    expect(bps.size).toBe(1);
   });
 
   it("add corresponding breakpoints for multiple sources", async () => {
     const { dispatch, getState } = createStore(simpleMockThreadClient);
 
     let bps = selectors.getBreakpoints(getState());
-    expect(bps.size).to.be(0);
+    expect(bps.size).toBe(0);
 
     const source1 = makeSource("bar.js");
     const source2 = makeSource("foo.js");
     await dispatch(actions.newSources([source1, source2]));
     bps = selectors.getBreakpoints(getState());
-    expect(bps.size).to.be(1);
+    expect(bps.size).toBe(1);
   });
 });
 
@@ -201,6 +200,6 @@ describe("invalid breakpoint location", () => {
     await dispatch(actions.addBreakpoint(bp.location));
     const pendingBps = selectors.getPendingBreakpoints(getState());
     const pendingBp = pendingBps.get(correctedPendingId);
-    expect(pendingBp).to.eql(generatePendingBreakpoint(slidBp));
+    expect(pendingBp).toEqual(generatePendingBreakpoint(slidBp));
   });
 });