repluggable-core 0.0.0-pr302.475 → 0.0.0-pr303.476

package/test/installedShellsState.spec.ts

@@ -1,39 +0,0 @@
-import {
-    InstalledShellsActions,
-    installedShellsReducer,
-    InstalledShellsSelectors,
-    InstalledShellsState,
-    ShellToggleSet
-} from '../src/installedShellsState'
-
-const initialState: InstalledShellsState = {
-    installedShells: {
-        shellA: true,
-        shellB: true
-    }
-}
-
-const shellsToggleSet: ShellToggleSet = {
-    shellB: false,
-    shellC: true
-}
-
-const expectedState: InstalledShellsState = {
-    installedShells: {
-        shellA: true,
-        shellC: true
-    }
-}
-
-describe('Installed Shells State', () => {
-    it('should toggle shells according to shell toggles', () => {
-        const actualState = installedShellsReducer(initialState, InstalledShellsActions.updateInstalledShells(shellsToggleSet))
-
-        expect(actualState).toEqual(expectedState)
-    })
-
-    it('should select installed shells from state', () => {
-        const rootState = { $installedShells: initialState }
-        expect(InstalledShellsSelectors.getInstalledShellsSet(rootState)).toEqual(initialState.installedShells)
-    })
-})

package/test/interceptAnyObject.spec.ts

@@ -1,217 +0,0 @@
-import _ from 'lodash'
-import { FunctionInterceptor, interceptAnyObject, PropertyInterceptor } from '../src/interceptAnyObject'
-
-type LogSpy = jest.Mock<void, string[]>
-
-function takeLog(spy: LogSpy): string[] {
-    return _.flatten(spy.mock.calls)
-}
-
-interface StringDict {
-    [key: string]: string
-}
-
-function dictToString(dict: StringDict): string {
-    return Object.keys(dict)
-        .map(key => ({
-            key,
-            value: dict[key]
-        }))
-        .filter(kvp => typeof kvp.value === 'string')
-        .map(kvp => `${kvp.key}:${kvp.value}`)
-        .join(';')
-}
-
-function argToString(arg: any): string {
-    switch (typeof arg) {
-        case 'number':
-        case 'string':
-            return `${arg}`
-        case 'object':
-            return dictToString(arg)
-        case 'undefined':
-            return 'undefined'
-        default:
-            return '???'
-    }
-}
-
-interface TestTarget {
-    voidFunc(): void
-    voidFuncWithArgs(str: string, num: number, obj: StringDict): void
-    nonVoidFunc(): StringDict
-    nonVoidFuncWithArgs(str: string, num: number): StringDict
-    scalarProp: string
-    objectProp: TestTargetNested
-}
-
-interface TestTargetNested {
-    nestedFunc(): void
-    nestedProp: string
-    nestedObject: TestTargetNestedLevelTwo
-}
-
-interface TestTargetNestedLevelTwo {
-    nestedFuncLevelTwo(): number
-}
-
-function createTestTarget(spy: LogSpy): TestTarget {
-    return {
-        voidFunc() {
-            spy('voidFunc')
-        },
-        voidFuncWithArgs(str: string, num: number, dict: StringDict): void {
-            spy(`voidFuncWithArgs(str=${str},num=${num},dict=${dictToString(dict)})`)
-        },
-        nonVoidFunc() {
-            spy('nonVoidFunc')
-            return {
-                aaa: '111'
-            }
-        },
-        nonVoidFuncWithArgs(str: string, num: number): StringDict {
-            spy(`nonVoidFuncWithArgs(str=${str},num=${num})`)
-            return {
-                bbb: '222'
-            }
-        },
-        scalarProp: 'original-scalar',
-        objectProp: {
-            nestedProp: 'original-nested',
-            nestedFunc() {
-                spy('objectProp.nestedFunc')
-            },
-            nestedObject: {
-                nestedFuncLevelTwo() {
-                    spy('objectProp.nestedObject.nestedFuncLevelTwo')
-                    return 12345
-                }
-            }
-        }
-    }
-}
-
-describe('interceptAnyObject', () => {
-    function createFuncInterceptor(spy: LogSpy): FunctionInterceptor {
-        return (name, func) => {
-            return (...args: any[]) => {
-                spy(`BEFORE:${name}(${args.map(argToString).join(';')})`)
-                const retVal = func.apply(null, args)
-                spy(`AFTER:${name}(${argToString(retVal)})`)
-                return retVal
-            }
-        }
-    }
-
-    function createPropInterceptor(spy: LogSpy): PropertyInterceptor {
-        return (name, value) => {
-            return typeof value === 'string' ? value.replace('original', `INTERCEPTED[${name}]`) : value
-        }
-    }
-
-    it('should return same members if no interceptors passed', () => {
-        const spy: LogSpy = jest.fn()
-        const real = createTestTarget(spy)
-        const intercepted = interceptAnyObject(real)
-
-        expect(intercepted.voidFunc).toBe(real.voidFunc)
-        expect(intercepted.scalarProp).toBe(real.scalarProp)
-        expect(intercepted.objectProp.nestedFunc).toBe(real.objectProp.nestedFunc)
-    })
-
-    it('should intercept void functions', () => {
-        const spy: LogSpy = jest.fn()
-        const real = createTestTarget(spy)
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy))
-
-        intercepted.voidFunc()
-
-        const log = takeLog(spy)
-        expect(log).toEqual(['BEFORE:voidFunc()', 'voidFunc', 'AFTER:voidFunc(undefined)'])
-    })
-
-    it('should intercept non-void functions with arguments', () => {
-        const spy: LogSpy = jest.fn()
-        const real = createTestTarget(spy)
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy))
-
-        const retVal = intercepted.nonVoidFuncWithArgs('abc', 123)
-
-        const log = takeLog(spy)
-        expect(log).toEqual([
-            'BEFORE:nonVoidFuncWithArgs(abc;123)',
-            'nonVoidFuncWithArgs(str=abc,num=123)',
-            'AFTER:nonVoidFuncWithArgs(bbb:222)'
-        ])
-        expect(dictToString(retVal)).toBe('bbb:222')
-    })
-
-    it('should intercept scalar props', () => {
-        const spy: LogSpy = jest.fn()
-        const real = createTestTarget(spy)
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy))
-
-        const propValue = intercepted.scalarProp
-
-        expect(propValue).toBe('INTERCEPTED[scalarProp]-scalar')
-    })
-
-    it('should intercept nested objects', () => {
-        const spy: LogSpy = jest.fn()
-        const real = createTestTarget(spy)
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy), 10)
-
-        const nestedPropValue = intercepted.objectProp.nestedProp
-        intercepted.objectProp.nestedFunc()
-
-        const log = takeLog(spy)
-        expect(log).toEqual(['BEFORE:objectProp.nestedFunc()', 'objectProp.nestedFunc', 'AFTER:objectProp.nestedFunc(undefined)'])
-        expect(nestedPropValue).toBe('INTERCEPTED[objectProp.nestedProp]-nested')
-    })
-
-    it('should intercept multiple levels of nested objects', () => {
-        const spy: LogSpy = jest.fn()
-        const real = createTestTarget(spy)
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy), 10)
-
-        const nestedFuncLevelTwoRetVal = intercepted.objectProp.nestedObject.nestedFuncLevelTwo()
-
-        const log = takeLog(spy)
-        expect(log).toEqual([
-            'BEFORE:objectProp.nestedObject.nestedFuncLevelTwo()',
-            'objectProp.nestedObject.nestedFuncLevelTwo',
-            'AFTER:objectProp.nestedObject.nestedFuncLevelTwo(12345)'
-        ])
-        expect(nestedFuncLevelTwoRetVal).toBe(12345)
-    })
-
-    it('should not intercept non object-like values - functions', () => {
-        const spy: LogSpy = jest.fn()
-        function real() {
-            return 'real'
-        }
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy))
-        expect(intercepted()).toBe('real')
-    })
-
-    it('should not intercept non object-like values - primitives', () => {
-        const spy: LogSpy = jest.fn()
-        const real = 'real'
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy))
-        expect(intercepted).toBe('real')
-    })
-
-    it('should not intercept non object-like values - arrays', () => {
-        const spy: LogSpy = jest.fn()
-        const real = ['real']
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy))
-        expect(intercepted).toEqual(['real'])
-    })
-
-    it('should not intercept non object-like values - maps', () => {
-        const spy: LogSpy = jest.fn()
-        const real = new Map<string, string>([['key', 'value']])
-        const intercepted = interceptAnyObject(real, createFuncInterceptor(spy), createPropInterceptor(spy))
-        expect(intercepted.get('key')).toEqual('value')
-    })
-})

package/test/loggers.spec.ts

@@ -1,288 +0,0 @@
-import { EntryPoint, HostLogger, EntryPointTags } from '../src/API'
-import { createAppHost } from '../src/appHost'
-import { createShellLogger } from '../src/loggers'
-
-describe('ShellLogger', () => {
-    function setup(tags?: EntryPointTags) {
-        const logSpy = jest.fn()
-        const spanSpy = jest.fn().mockImplementation(() => ({}))
-
-        const entryPoint: EntryPoint = {
-            name: 'ep-1',
-            tags
-        }
-        const hostLogger: HostLogger = {
-            log: logSpy,
-            spanChild: spanSpy,
-            spanRoot: spanSpy
-        }
-        const host = createAppHost([], { logger: hostLogger, monitoring: {} })
-        const shellLogger = createShellLogger(host, entryPoint)
-
-        logSpy.mockClear()
-
-        return {
-            entryPoint,
-            hostLogger,
-            host,
-            shellLogger
-        }
-    }
-
-    function delay(milliseconds: number) {
-        return new Promise(resolve => {
-            setTimeout(resolve, milliseconds)
-        })
-    }
-
-    it('should log simple message', () => {
-        const { shellLogger, hostLogger } = setup()
-
-        shellLogger.debug('M1')
-        shellLogger.info('M2')
-        shellLogger.warning('M3')
-        shellLogger.error('M4')
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(4)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'debug', 'M1', undefined, { $ep: 'ep-1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'info', 'M2', undefined, { $ep: 'ep-1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(3, 'warning', 'M3', undefined, { $ep: 'ep-1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(4, 'error', 'M4', undefined, { $ep: 'ep-1' })
-    })
-
-    it('should log simple message with key-value pairs', () => {
-        const { shellLogger, hostLogger } = setup()
-
-        shellLogger.debug('M1', { k1: 'v1' })
-        shellLogger.info('M2', { k2: 'v2' })
-        shellLogger.warning('M3', { k3: 'v3' })
-        shellLogger.error('M4', undefined, { k4: 'v4' })
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(4)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'debug', 'M1', undefined, { $ep: 'ep-1', k1: 'v1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'info', 'M2', undefined, { $ep: 'ep-1', k2: 'v2' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(3, 'warning', 'M3', undefined, { $ep: 'ep-1', k3: 'v3' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(4, 'error', 'M4', undefined, { $ep: 'ep-1', k4: 'v4' })
-    })
-
-    it('should include entry point tags in key-value pairs', () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1', t2: 'T2' })
-
-        shellLogger.debug('M1', { k1: 'v1' })
-        shellLogger.info('M2', { k2: 'v2' })
-        shellLogger.warning('M3', { k3: 'v3' })
-        shellLogger.error('M4', undefined, { k4: 'v4' })
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(4)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'debug', 'M1', undefined, { $ep: 'ep-1', k1: 'v1', t1: 'T1', t2: 'T2' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'info', 'M2', undefined, { $ep: 'ep-1', k2: 'v2', t1: 'T1', t2: 'T2' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(3, 'warning', 'M3', undefined, { $ep: 'ep-1', k3: 'v3', t1: 'T1', t2: 'T2' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(4, 'error', 'M4', undefined, { $ep: 'ep-1', k4: 'v4', t1: 'T1', t2: 'T2' })
-    })
-
-    it('should begin span', () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        const span = shellLogger.spanChild('M1', { k1: 'v1' })
-
-        expect(span).toBeDefined()
-        expect(hostLogger.spanChild).toHaveBeenCalledTimes(1)
-        expect(hostLogger.spanChild).toHaveBeenNthCalledWith(1, 'M1', { $ep: 'ep-1', k1: 'v1', t1: 'T1' })
-    })
-
-    it.skip('should monitor synchronous void function success', () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        shellLogger.monitor('M1', { k1: 'v1' }, () => {
-            shellLogger.debug('this-is-monitored-code')
-        })
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(3)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', undefined, { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'this-is-monitored-code', undefined, { $ep: 'ep-1', t1: 'T1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            3,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: true,
-                returnValue: undefined,
-                error: undefined
-            },
-            'end'
-        )
-    })
-
-    it.skip('should monitor synchronous non-void function success', () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        const returnValue = shellLogger.monitor('M1', { k1: 'v1' }, () => {
-            shellLogger.debug('this-is-monitored-code')
-            return 123
-        })
-
-        expect(returnValue).toBe(123)
-        expect(hostLogger.log).toHaveBeenCalledTimes(3)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', undefined, { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'this-is-monitored-code', undefined, { $ep: 'ep-1', t1: 'T1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            3,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: true,
-                returnValue: 123,
-                error: undefined
-            },
-            'end'
-        )
-    })
-
-    it.skip('should monitor synchronous function that returns null', () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        const returnValue = shellLogger.monitor('M1', { k1: 'v1' }, () => {
-            shellLogger.debug('this-is-monitored-code')
-            return null
-        })
-
-        expect(returnValue).toBeNull()
-        expect(hostLogger.log).toHaveBeenCalledTimes(3)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'this-is-monitored-code', { $ep: 'ep-1', t1: 'T1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            3,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: true,
-                returnValue: null,
-                error: undefined
-            },
-            'end'
-        )
-    })
-
-    it.skip('should monitor synchronous function failure', () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        expect(() => {
-            shellLogger.monitor('M1', { k1: 'v1' }, () => {
-                throw new Error('ERR1')
-            })
-        }).toThrowError('ERR1')
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(2)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            2,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: false,
-                returnValue: undefined,
-                error: new Error('ERR1')
-            },
-            'end'
-        )
-    })
-
-    it.skip('should monitor async void function success', async () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        await shellLogger.monitor('M1', { k1: 'v1' }, async () => {
-            await delay(10)
-            shellLogger.debug('this-is-monitored-code')
-        })
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(3)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'this-is-monitored-code', { $ep: 'ep-1', t1: 'T1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            3,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: true,
-                returnValue: undefined,
-                error: undefined
-            },
-            'end'
-        )
-    })
-
-    it.skip('should monitor async non-void function success', async () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        const returnValue = await shellLogger.monitor('M1', { k1: 'v1' }, async () => {
-            shellLogger.debug('this-is-monitored-code')
-            await delay(10)
-            return 123
-        })
-
-        expect(returnValue).toBe(123)
-        expect(hostLogger.log).toHaveBeenCalledTimes(3)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'this-is-monitored-code', { $ep: 'ep-1', t1: 'T1' })
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            3,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: true,
-                returnValue: 123,
-                error: undefined
-            },
-            'end'
-        )
-    })
-
-    it.skip('should monitor async function failure', async () => {
-        const { shellLogger, hostLogger } = setup({ t1: 'T1' })
-
-        try {
-            await shellLogger.monitor('M1', { k1: 'v1' }, async () => {
-                await delay(10)
-                throw new Error('ERR1')
-            })
-            fail('expected to throw, but did not')
-        } catch (err) {
-            expect(err.message).toBe('ERR1')
-        }
-
-        expect(hostLogger.log).toHaveBeenCalledTimes(2)
-        expect(hostLogger.log).toHaveBeenNthCalledWith(1, 'span', 'M1', { $ep: 'ep-1', k1: 'v1', t1: 'T1' }, 'begin')
-        expect(hostLogger.log).toHaveBeenNthCalledWith(
-            2,
-            'span',
-            'M1',
-            {
-                $ep: 'ep-1',
-                k1: 'v1',
-                t1: 'T1',
-                success: false,
-                returnValue: undefined,
-                error: new Error('ERR1')
-            },
-            'end'
-        )
-    })
-})

package/test/repluggableAppDebug.spec.ts

@@ -1,118 +0,0 @@
-import { createAppHost } from '../src'
-
-const unreadAPI = { name: 'unreadyAPI' }
-
-const getUnreadyAPIs = async () => {
-    await new Promise(resolve => setTimeout(resolve, 0))
-    return globalThis.repluggableAppDebug.utils.getRootUnreadyAPI()
-}
-
-describe('RepluggableAppDebug', () => {
-    describe('getRootUnreadyAPI', () => {
-        it('should not report any issues in case there are no entry points', async () => {
-            createAppHost([])
-
-            const unreadyAPIs = await getUnreadyAPIs()
-
-            expect(unreadyAPIs).toEqual([])
-        })
-
-        it('should not report any issues in case all entry points are loaded', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint',
-                    declareAPIs: () => []
-                }
-            ])
-
-            const unreadyAPIs = await getUnreadyAPIs()
-
-            expect(unreadyAPIs).toEqual([])
-        })
-
-        it('should return an API if its not ready', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint',
-                    getDependencyAPIs: () => [unreadAPI]
-                }
-            ])
-
-            const unreadyAPIs = await getUnreadyAPIs()
-
-            expect(unreadyAPIs).toEqual([{ name: 'unreadyAPI' }])
-        })
-
-        it('should return the root unready API when there are multiple entry points that depend on the same API', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint A',
-                    getDependencyAPIs: () => [unreadAPI]
-                },
-                {
-                    name: 'entryPoint B',
-                    getDependencyAPIs: () => [unreadAPI]
-                },
-                {
-                    name: 'entryPoint C',
-                    getDependencyAPIs: () => [unreadAPI]
-                }
-            ])
-
-            const unreadyAPIs = await getUnreadyAPIs()
-
-            expect(unreadyAPIs).toEqual([{ name: 'unreadyAPI' }])
-        })
-
-        it('should return the root unready API when there is a graph of dependencies', async () => {
-            createAppHost([
-                {
-                    name: 'entryPoint A',
-                    declareAPIs: () => [{ name: 'API A' }],
-                    getDependencyAPIs: () => [{ name: 'API B' }]
-                },
-                {
-                    name: 'entryPoint B',
-                    declareAPIs: () => [{ name: 'API B' }],
-                    getDependencyAPIs: () => [{ name: 'API C' }]
-                },
-                {
-                    name: 'entryPoint C',
-                    declareAPIs: () => [{ name: 'API C' }],
-                    getDependencyAPIs: () => [unreadAPI]
-                }
-            ])
-
-            const unreadyAPIs = await getUnreadyAPIs()
-
-            expect(unreadyAPIs).toEqual([{ name: 'unreadyAPI' }, { name: 'API C' }, { name: 'API B' }])
-        })
-
-        it('should return the root unready API when there is a graph of dependencies (declation order is reversed)', async () => {
-            createAppHost(
-                [
-                    {
-                        name: 'entryPoint A',
-                        declareAPIs: () => [{ name: 'API A' }],
-                        getDependencyAPIs: () => [{ name: 'API B' }]
-                    },
-                    {
-                        name: 'entryPoint B',
-                        declareAPIs: () => [{ name: 'API B' }],
-                        getDependencyAPIs: () => [{ name: 'API C' }]
-                    },
-                    {
-                        name: 'entryPoint C',
-                        declareAPIs: () => [{ name: 'API C' }],
-                        getDependencyAPIs: () => [unreadAPI]
-                    }
-                ].reverse()
-            )
-
-            const unreadyAPIs = await getUnreadyAPIs()
-            // because we take the first unready entry point, and in this case its the root,
-            // we don't get the rest of the unready APIs
-            expect(unreadyAPIs).toEqual([{ name: 'unreadyAPI' }])
-        })
-    })
-})