test(overmind): fix operator tests to match new API

Author: christianalfoni

packages/node_modules/overmind/src/index.ts

@@ -1004,6 +1004,9 @@ export function action<Input, ThisConfig extends Configuration = Config>(
 
 export function fork<
   Input,
+  // The Output should not really be ANY here, as it will type the last operator
+  // input as ANY, but no way to infer this either... so either force to same as Input
+  // or last will be ANY
   Paths extends { [key: string]: IOperator<ThisConfig, Input, any> },
   ThisConfig extends Configuration = Config
 >(

packages/node_modules/overmind/src/operators.test.ts

@@ -19,8 +19,8 @@ describe('OPERATORS', () => {
   test('map', () => {
     expect.assertions(1)
     const test: Operator<string> = pipe(
-      map(({ value }) => value.toUpperCase()),
-      action(({ value, state }) => (state.foo = value))
+      map((_, value) => value.toUpperCase()),
+      action(({ state }, value) => (state.foo = value))
     )
 
     const state = {
@@ -48,8 +48,8 @@ describe('OPERATORS', () => {
   test('map (async)', () => {
     expect.assertions(1)
     const test: Operator<string> = pipe(
-      map(({ value }) => Promise.resolve(value.toUpperCase())),
-      action(({ value, state }) => (state.foo = value))
+      map((_, value) => Promise.resolve(value.toUpperCase())),
+      action(({ state }, value) => (state.foo = value))
     )
 
     const state = {
@@ -143,9 +143,9 @@ describe('OPERATORS', () => {
   test('filter - truthy', () => {
     expect.assertions(1)
     const test: Operator<string> = pipe(
-      filter(({ value }) => value === 'foo'),
-      map(({ value }) => value.toUpperCase()),
-      action(({ value, state }) => (state.foo = value))
+      filter((_, value) => value === 'foo'),
+      map((_, value) => value.toUpperCase()),
+      action(({ state }, value) => (state.foo = value))
     )
 
     const state = {
@@ -164,18 +164,16 @@ describe('OPERATORS', () => {
     interface Operator<Input = void, Output = Input>
       extends IOperator<Config, Input, Output> {}
 
-    interface Action<Input = void> extends IAction<Config, Input> {}
-
     return overmind.actions.test('foo').then(() => {
       expect(overmind.state.foo).toBe('FOO')
     })
   })
 
   test('filter - falsy', () => {
     const test: Operator<string> = pipe(
-      filter(({ value }) => value === 'bar'),
-      map(({ value }) => value.toUpperCase()),
-      action(({ value, state }) => (state.foo = value))
+      filter((_, value) => value === 'bar'),
+      map((_, value) => value.toUpperCase()),
+      action(({ state }, value) => (state.foo = value))
     )
 
     const state = {
@@ -194,8 +192,6 @@ describe('OPERATORS', () => {
     interface Operator<Input = void, Output = Input>
       extends IOperator<Config, Input, Output> {}
 
-    interface Action<Input = void> extends IAction<Config, Input> {}
-
     return overmind.actions.test('foo').then(() => {
       expect(overmind.state.foo).toBe('bar')
     })
@@ -206,8 +202,8 @@ describe('OPERATORS', () => {
     const test: Operator<string> = pipe(
       fork(() => 'foo', {
         foo: pipe(
-          map(({ value }) => value.toUpperCase()),
-          action(({ value, state }) => (state.foo = value))
+          map((_, value) => value.toUpperCase()),
+          action(({ state }, value) => (state.foo = value))
         ),
       })
     )
@@ -240,12 +236,12 @@ describe('OPERATORS', () => {
     const test: Operator<string, string | number> = pipe(
       when(() => true, {
         true: pipe(
-          map(({ value }) => value.toUpperCase()),
-          action(({ value, state }) => (state.foo = value))
+          map((_, value) => value.toUpperCase()),
+          action(({ state }, value) => (state.foo = value))
         ),
         false: pipe(
-          map(({ value }) => Number(value)),
-          action(({ value, state }) => (state.number = value))
+          map((_, value) => Number(value)),
+          action(({ state }, value) => (state.number = value))
         ),
       })
     )
@@ -320,8 +316,6 @@ describe('OPERATORS', () => {
     interface Operator<Input = void, Output = Input>
       extends IOperator<Config, Input, Output> {}
 
-    interface Action<Input = void> extends IAction<Config, Input> {}
-
     return Promise.all([overmind.actions.test(), overmind.actions.test()]).then(
       () => {
         expect(overmind.state.runCount).toBe(1)