TypeScript testing-utils.cloneableGenerator函数代码示例

function testCloneableGenerator3() {
  function* testSaga(n1: number, n2: number, n3: number): SagaIterator {
    yield put({type: 'my-action'});
  }

  // typings:expect-error
  cloneableGenerator(testSaga)(1, 2);

  cloneableGenerator(testSaga)(1, 2, 3);
}

function testCloneableGenerator1() {
  function* testSaga(n1: number): SagaIterator {
    yield put({type: 'my-action'});
  }

  // typings:expect-error
  cloneableGenerator(testSaga)();

  // typings:expect-error
  cloneableGenerator(testSaga)('foo');

  cloneableGenerator(testSaga)(1);
}

function testCloneableGenerator4() {
  function* testSaga(
    n1: number,
    n2: number,
    n3: number,
    n4: number,
  ): SagaIterator {
    yield put({type: 'my-action'});
  }
  cloneableGenerator(testSaga)(1, 2, 3, 4);
}

function testCloneableGenerator() {
  function* testSaga(): SagaIterator {
    yield put({type: 'my-action'});
  }

  const cloneableGen = cloneableGenerator(testSaga)();
  const value = cloneableGen.next().value;

  const clone = cloneableGen.clone();
  const cloneVal = clone.next().value;
}

describe('getBookmarkTrees', () => {
  // limit to 4 trees, and set parentId to previous tree id
  const correlatedBookmarkTrees = R.take(4, bookmarkTrees).reduce(
    (acc: Array<BookmarkTree>, bookmarkTree) => {
      if (!acc.length) return [bookmarkTree]

      const prevBookmarkTree = R.last(acc)
      if (!prevBookmarkTree) throw new Error('prevBookmarkTree must exist')
      const updatedBookmarkTree = R.set(
        R.lensPath(['parent', 'parentId']),
        prevBookmarkTree.parent.id,
        bookmarkTree
      )
      return [...acc, updatedBookmarkTree]
    },
    []
  )
  const getRestTreeIds = (trees: Array<BookmarkTree>) => R.tail(trees).map((tree) => tree.parent.id)

  const options = optionsFixture
  const restTreeIds = getRestTreeIds(correlatedBookmarkTrees)

  const generator = cloneableGenerator(getters.getBookmarkTrees)(restTreeIds, options)

  expect(generator.next().value).toEqual(
    all([
      call(getters.getFirstBookmarkTree, options),
      ...R.map((id) => call(getters.tryGetBookmarkTree, id), restTreeIds)
    ])
  )

  test('should get all trees', () => {
    const clonedGenerator = generator.clone()

    expect(clonedGenerator.next(correlatedBookmarkTrees).value).toEqual(correlatedBookmarkTrees)

    expect(clonedGenerator.next().done).toBe(true)
  })
  test('should remove tree and its child trees if cannot get that tree', () => {
    for (let i = 1; i < correlatedBookmarkTrees.length; i += 1) {
      const clonedGenerator = generator.clone()

      const partiallyUnrelatedBookmarkTrees = R.set(R.lensIndex(i), null, correlatedBookmarkTrees)
      expect(clonedGenerator.next(partiallyUnrelatedBookmarkTrees).value).toEqual(
        R.take(i, partiallyUnrelatedBookmarkTrees)
      )

      expect(clonedGenerator.next().done).toBe(true)
    }
  })
})

function testCloneableGenerator6Rest() {
  function* testSaga(
    n1: number,
    n2: number,
    n3: number,
    n4: number,
    n5: number,
    n6: number,
    n7: number,
  ): SagaIterator {
    yield put({type: 'my-action'});
  }
  cloneableGenerator(testSaga)(1, 2, 3, 4, 5, 6, 7);
}

const createGenerator = (id: string) => {
  return cloneableGenerator(deleteBookmark)({
    type: getType(bookmarkCreators.deleteBookmark),
    payload: {id}
  })
}