repluggable-core 1.302.65 → 1.302.67

package/test/installedShellsState.spec.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,217 @@
+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

@@ -0,0 +1,288 @@
+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

@@ -0,0 +1,118 @@
+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' }])
+        })
+    })
+})