Fix a bunch of type errors in the tests

Former-commit-id: 66482dd

Author: timdorr

package.json

@@ -40,10 +40,10 @@
     "format:check": "prettier --list-different \"{src,test}/**/*.{js,ts}\" \"**/*.md\"",
     "lint": "eslint --ext js,ts src test",
     "check-types": "tsc --noEmit",
-    "test": "jest",
+    "test": "jest && tsc -p test/typescript",
     "test:types": "tsc -p test/typescript",
-    "test:watch": "npm test -- --watch",
-    "test:cov": "npm test -- --coverage",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
     "build": "rollup -c",
     "pretest": "npm run build",
     "prepublishOnly": "npm run clean && npm run check-types && npm run format:check && npm run lint && npm test",

test/applyMiddleware.spec.ts

@@ -1,25 +1,36 @@
-import { createStore, applyMiddleware, Middleware, AnyAction, Action } from '..'
+import {
+  createStore,
+  applyMiddleware,
+  Middleware,
+  MiddlewareAPI,
+  AnyAction,
+  Action,
+  Store,
+  Dispatch
+} from '..'
 import * as reducers from './helpers/reducers'
 import { addTodo, addTodoAsync, addTodoIfEmpty } from './helpers/actionCreators'
 import { thunk } from './helpers/middleware'
 
 describe('applyMiddleware', () => {
   it('warns when dispatching during middleware setup', () => {
-    function dispatchingMiddleware(store) {
-      store.dispatch(addTodo('Dont dispatch in middleware setup'))
-      return next => action => next(action)
+    function dispatchingMiddleware(store: Store) {
+      store.dispatch(addTodo("Don't dispatch in middleware setup"))
+      return (next: Dispatch) => (action: Action) => next(action)
     }
 
     expect(() =>
-      applyMiddleware(dispatchingMiddleware)(createStore)(reducers.todos)
+      applyMiddleware(dispatchingMiddleware as Middleware)(createStore)(
+        reducers.todos
+      )
     ).toThrow()
   })
 
   it('wraps dispatch method with middleware once', () => {
-    function test(spyOnMethods) {
-      return methods => {
+    function test(spyOnMethods: any) {
+      return (methods: any) => {
         spyOnMethods(methods)
-        return next => action => next(action)
+        return (next: Dispatch) => (action: Action) => next(action)
       }
     }
 
@@ -41,8 +52,8 @@ describe('applyMiddleware', () => {
   })
 
   it('passes recursive dispatches through the middleware chain', () => {
-    function test(spyOnMethods) {
-      return () => next => action => {
+    function test(spyOnMethods: any) {
+      return () => (next: Dispatch) => (action: Action) => {
         spyOnMethods(action)
         return next(action)
       }
@@ -53,7 +64,7 @@ describe('applyMiddleware', () => {
 
     // the typing for redux-thunk is super complex, so we will use an as unknown hack
     const dispatchedValue = store.dispatch(
-      addTodoAsync('Use Redux')
+      addTodoAsync('Use Redux') as any
     ) as unknown as Promise<void>
     return dispatchedValue.then(() => {
       expect(spy.mock.calls.length).toEqual(2)
@@ -63,15 +74,15 @@ describe('applyMiddleware', () => {
   it('works with thunk middleware', done => {
     const store = applyMiddleware(thunk)(createStore)(reducers.todos)
 
-    store.dispatch(addTodoIfEmpty('Hello'))
+    store.dispatch(addTodoIfEmpty('Hello') as any)
     expect(store.getState()).toEqual([
       {
         id: 1,
         text: 'Hello'
       }
     ])
 
-    store.dispatch(addTodoIfEmpty('Hello'))
+    store.dispatch(addTodoIfEmpty('Hello') as any)
     expect(store.getState()).toEqual([
       {
         id: 1,
@@ -93,7 +104,7 @@ describe('applyMiddleware', () => {
 
     // the typing for redux-thunk is super complex, so we will use an "as unknown" hack
     const dispatchedValue = store.dispatch(
-      addTodoAsync('Maybe')
+      addTodoAsync('Maybe') as any
     ) as unknown as Promise<void>
     dispatchedValue.then(() => {
       expect(store.getState()).toEqual([
@@ -124,24 +135,25 @@ describe('applyMiddleware', () => {
 
     const multiArgMiddleware: Middleware<MultiDispatch, any, MultiDispatch> =
       _store => {
-        return next => (action, callArgs?: any) => {
+        return next => (action: any, callArgs?: any) => {
           if (Array.isArray(callArgs)) {
             return action(...callArgs)
           }
           return next(action)
         }
       }
 
-    function dummyMiddleware({ dispatch }) {
-      return _next => action => dispatch(action, testCallArgs)
+    function dummyMiddleware({ dispatch }: MiddlewareAPI) {
+      return (_next: Dispatch) => (action: Action) =>
+        dispatch(action, testCallArgs)
     }
 
     const store = createStore(
       reducers.todos,
       applyMiddleware(multiArgMiddleware, dummyMiddleware)
     )
 
-    store.dispatch(spy)
+    store.dispatch(spy as any)
     expect(spy.mock.calls[0]).toEqual(testCallArgs)
   })
 })

test/bindActionCreators.spec.ts

@@ -1,10 +1,10 @@
-import { bindActionCreators, createStore, ActionCreator } from '..'
+import { bindActionCreators, createStore, ActionCreator, Store } from '..'
 import { todos } from './helpers/reducers'
 import * as actionCreators from './helpers/actionCreators'
 
 describe('bindActionCreators', () => {
-  let store
-  let actionCreatorFunctions
+  let store: Store
+  let actionCreatorFunctions: any
 
   beforeEach(() => {
     store = createStore(todos)
@@ -33,13 +33,13 @@ describe('bindActionCreators', () => {
   it('wraps action creators transparently', () => {
     const uniqueThis = {}
     const argArray = [1, 2, 3]
-    function actionCreator() {
+    function actionCreator(this: any) {
       return { type: 'UNKNOWN_ACTION', this: this, args: [...arguments] }
     }
     const boundActionCreator = bindActionCreators(actionCreator, store.dispatch)
 
-    const boundAction = boundActionCreator.apply(uniqueThis, argArray)
-    const action = actionCreator.apply(uniqueThis, argArray)
+    const boundAction = boundActionCreator.apply(uniqueThis, argArray as [])
+    const action = actionCreator.apply(uniqueThis, argArray as [])
     expect(boundAction).toEqual(action)
     expect(boundAction.this).toBe(uniqueThis)
     expect(action.this).toBe(uniqueThis)
@@ -75,6 +75,7 @@ describe('bindActionCreators', () => {
 
   it('throws for an undefined actionCreator', () => {
     expect(() => {
+      // @ts-expect-error
       bindActionCreators(undefined, store.dispatch)
     }).toThrow(
       `bindActionCreators expected an object or a function, but instead received: 'undefined'. ` +
@@ -84,6 +85,7 @@ describe('bindActionCreators', () => {
 
   it('throws for a null actionCreator', () => {
     expect(() => {
+      // @ts-expect-error
       bindActionCreators(null, store.dispatch)
     }).toThrow(
       `bindActionCreators expected an object or a function, but instead received: 'null'. ` +

test/combineReducers.spec.ts.REMOVED.git-id

@@ -1 +1 @@
-74a67c7ab000cd7cee3655199bd2ca5834085126
+b012ff5cffff432eca8c941c7dd6b9e6e2ef5d3d

test/compose.spec.ts

@@ -29,6 +29,7 @@ describe('Utils', () => {
       expect(() =>
         compose(square, add, false as unknown as sFunc)(1, 2)
       ).toThrow()
+      // @ts-expect-error
       expect(() => compose(square, add, undefined)(1, 2)).toThrow()
       expect(() =>
         compose(square, add, true as unknown as sFunc)(1, 2)

test/createStore.spec.ts.REMOVED.git-id

@@ -1 +1 @@
-d104d41480eb4865939c7831851c3ada6cdadc22
+f8065aeb618d36e1b5344bd7e730e2450f1dee93

test/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "emitDeclarationOnly": false,
+    "strict": true,
+    "noEmit": true,
+    "target": "esnext",
+    "jsx": "react",
+    "baseUrl": ".",
+    "skipLibCheck": true,
+    "noImplicitReturns": false,
+    "noUnusedLocals": false
+  },
+  "include": ["**/*.spec.ts"]
+}

test/utils/isPlainObject.spec.ts

@@ -4,15 +4,10 @@ import vm from 'vm'
 
 describe('isPlainObject', () => {
   it('returns true only if plain object', () => {
-    function Test() {
-      this.prop = 1
-    }
-
     const sandbox = { fromAnotherRealm: false }
     vm.runInNewContext('fromAnotherRealm = {}', sandbox)
 
     expect(isPlainObject(sandbox.fromAnotherRealm)).toBe(true)
-    expect(isPlainObject(new Test())).toBe(false)
     expect(isPlainObject(new Date())).toBe(false)
     expect(isPlainObject([1, 2, 3])).toBe(false)
     expect(isPlainObject(null)).toBe(false)