repluggable-core 0.0.0-pr280.413 → 0.0.0-pr282.418

package/test/interceptEntryPoints.spec.ts

@@ -0,0 +1,291 @@
+import _ from 'lodash'
+import { EntryPoint, EntryPointInterceptor } from '../src/API'
+import { interceptEntryPoints, interceptEntryPointsMap } from '../src/interceptEntryPoints'
+import { createAppHost } from '../testKit'
+
+type LogSpy = jest.Mock<void, string[]>
+
+function takeLog(spy: LogSpy): string[] {
+    return _.flatten(spy.mock.calls)
+}
+
+function takeAndClearLog(spy: LogSpy): string[] {
+    const result = takeLog(spy)
+    spy.mockClear()
+    return result
+}
+
+describe('interceptEntryPoints', () => {
+    it('should intercept name', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(2, spy)
+        const interceptor = createTestInterceptor(spy, 'INTR1', { interceptName: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        expect(intercepted[0].name).toBe('INTR1!EP-0')
+        expect(intercepted[1].name).toBe('INTR1!EP-1')
+    })
+    it('should intercept tags', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(2, spy)
+        const interceptor = createTestInterceptor(spy, 'INTR1', { interceptTags: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        expect(intercepted[0].tags).toMatchObject({ test_ep_index: '0', intercepted_by: 'INTR1' })
+        expect(intercepted[1].tags).toMatchObject({ test_ep_index: '1', intercepted_by: 'INTR1' })
+    })
+    it('should intercept attach', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'INTR1', { interceptAttach: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        intercepted[0].attach && intercepted[0].attach({} as any)
+
+        expect(takeLog(spy)).toEqual(['INTR1:attach', 'EP-0:attach'])
+    })
+    it('should intercept extend', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'INTR1', { interceptExtend: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        intercepted[0].extend && intercepted[0].extend({} as any)
+
+        expect(takeLog(spy)).toEqual(['INTR1:extend', 'EP-0:extend'])
+    })
+    it('should intercept detach', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'INTR1', { interceptDetach: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        intercepted[0].detach && intercepted[0].detach({} as any)
+
+        expect(takeLog(spy)).toEqual(['INTR1:detach', 'EP-0:detach'])
+    })
+    it('should intercept declareAPIs', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'I1', { interceptDeclareAPIs: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        intercepted[0].declareAPIs && intercepted[0].declareAPIs()
+
+        expect(takeLog(spy)).toEqual(['I1:declareAPIs', 'EP-0:declareAPIs'])
+    })
+    it('should intercept getDependencyAPIs', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'I1', { interceptGetDependencyAPIs: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        intercepted[0].getDependencyAPIs && intercepted[0].getDependencyAPIs()
+
+        expect(takeLog(spy)).toEqual(['I1:getDependencyAPIs', 'EP-0:getDependencyAPIs'])
+    })
+    it('should invoke original if not intercepted', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'INTR1', {}) // flags are all false
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        const interceptedName = intercepted[0].name
+        intercepted[0].attach && intercepted[0].attach({} as any)
+        intercepted[0].extend && intercepted[0].extend({} as any)
+        intercepted[0].detach && intercepted[0].detach({} as any)
+        intercepted[0].getDependencyAPIs && intercepted[0].getDependencyAPIs()
+        intercepted[0].declareAPIs && intercepted[0].declareAPIs()
+
+        expect(interceptedName).toBe('EP-0')
+        expect(takeLog(spy)).toEqual(['EP-0:attach', 'EP-0:extend', 'EP-0:detach', 'EP-0:getDependencyAPIs', 'EP-0:declareAPIs'])
+    })
+    it('should allow multiple interceptors', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(3, spy)
+        const interceptor1 = createTestInterceptor(spy, 'I1', { interceptAttach: true })
+        const interceptor2 = createTestInterceptor(spy, 'I2', { interceptAttach: true })
+        const intercepted1 = interceptEntryPoints(entryPoints[0], interceptor1)
+        const intercepted2 = interceptEntryPoints(intercepted1, interceptor2)
+
+        intercepted2[0].attach && intercepted2[0].attach({} as any)
+
+        expect(takeLog(spy)).toEqual(['I2:attach', 'I1:attach', 'EP-0:attach'])
+    })
+    it('should apply single interceptor to map of entry points', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(3, spy)
+        const packagesMap = {
+            one: entryPoints[0],
+            two: [entryPoints[1], entryPoints[2]]
+        }
+        const interceptor = createTestInterceptor(spy, 'I1', { interceptAttach: true })
+        const interceptedMap = interceptEntryPointsMap(packagesMap, interceptor)
+        const intercepted = [
+            (interceptedMap.one as EntryPoint[])[0],
+            (interceptedMap.two as EntryPoint[])[0],
+            (interceptedMap.two as EntryPoint[])[1]
+        ]
+
+        intercepted[0].attach && intercepted[0].attach({} as any)
+        const logOne0 = takeAndClearLog(spy)
+
+        intercepted[1].attach && intercepted[1].attach({} as any)
+        const logTwo0 = takeAndClearLog(spy)
+
+        intercepted[2].attach && intercepted[2].attach({} as any)
+        const logTwo1 = takeAndClearLog(spy)
+
+        expect(typeof interceptedMap).toBe('object')
+        expect(logOne0).toEqual(['I1:attach', 'EP-0:attach'])
+        expect(logTwo0).toEqual(['I1:attach', 'EP-1:attach'])
+        expect(logTwo1).toEqual(['I1:attach', 'EP-2:attach'])
+    })
+    it('should apply multiple interceptors to map of entry points', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(3, spy)
+        const packagesMap = {
+            one: entryPoints[0],
+            two: [entryPoints[1], entryPoints[2]]
+        }
+        const interceptor1 = createTestInterceptor(spy, 'I1', { interceptAttach: true })
+        const interceptor2 = createTestInterceptor(spy, 'I2', { interceptAttach: true })
+        const interceptedMap1 = interceptEntryPointsMap(packagesMap, interceptor1)
+        const interceptedMap2 = interceptEntryPointsMap(interceptedMap1, interceptor2)
+        const intercepted = [
+            (interceptedMap2.one as EntryPoint[])[0],
+            (interceptedMap2.two as EntryPoint[])[0],
+            (interceptedMap2.two as EntryPoint[])[1]
+        ]
+
+        intercepted[0].attach && intercepted[0].attach({} as any)
+        const logOne0 = takeAndClearLog(spy)
+
+        intercepted[1].attach && intercepted[1].attach({} as any)
+        const logTwo0 = takeAndClearLog(spy)
+
+        intercepted[2].attach && intercepted[2].attach({} as any)
+        const logTwo1 = takeAndClearLog(spy)
+
+        expect(typeof interceptedMap1).toBe('object')
+        expect(logOne0).toEqual(['I2:attach', 'I1:attach', 'EP-0:attach'])
+        expect(logTwo0).toEqual(['I2:attach', 'I1:attach', 'EP-1:attach'])
+        expect(logTwo1).toEqual(['I2:attach', 'I1:attach', 'EP-2:attach'])
+    })
+    it('should be able to add intercepted entry point to AppHost', () => {
+        const spy: LogSpy = jest.fn()
+
+        const entryPoints = createTestEntryPoints(1, spy)
+        const interceptor = createTestInterceptor(spy, 'I1', { interceptAttach: true, interceptExtend: true })
+        const intercepted = interceptEntryPoints(entryPoints, interceptor)
+
+        createAppHost(intercepted, {
+            monitoring: {}
+        })
+
+        // getDependencyAPIs appears to be called multiple times
+        expect(_.uniq(takeLog(spy))).toEqual([
+            'EP-0:declareAPIs', // called because of circular validation
+            'EP-0:getDependencyAPIs',
+            'I1:attach',
+            'EP-0:attach',
+            'I1:extend',
+            'EP-0:extend'
+        ])
+    })
+})
+
+type TestInterceptorFlags = { [P in keyof EntryPointInterceptor]?: boolean }
+
+function createTestEntryPoints(count: number, spy: LogSpy): EntryPoint[] {
+    return _.times(count).map<EntryPoint>(index => ({
+        name: `EP-${index}`,
+        tags: { test_ep_index: `${index}` },
+        getDependencyAPIs() {
+            spy(`EP-${index}:getDependencyAPIs`)
+            return []
+        },
+        declareAPIs() {
+            spy(`EP-${index}:declareAPIs`)
+            return []
+        },
+        attach() {
+            spy(`EP-${index}:attach`)
+            return []
+        },
+        extend() {
+            spy(`EP-${index}:extend`)
+            return []
+        },
+        detach() {
+            spy(`EP-${index}:detach`)
+            return []
+        }
+    }))
+}
+
+function createTestInterceptor(spy: LogSpy, interceptorName: string, flags: TestInterceptorFlags): EntryPointInterceptor {
+    return {
+        interceptName: flags.interceptName
+            ? name => {
+                  return `${interceptorName}!${name}`
+              }
+            : undefined,
+        interceptTags: flags.interceptTags
+            ? tags => {
+                  return { intercepted_by: interceptorName, ...tags }
+              }
+            : undefined,
+        interceptDeclareAPIs: flags.interceptDeclareAPIs
+            ? innerDeclareAPIs => {
+                  return () => {
+                      spy(`${interceptorName}:declareAPIs`)
+                      return (innerDeclareAPIs && innerDeclareAPIs()) || []
+                  }
+              }
+            : undefined,
+        interceptGetDependencyAPIs: flags.interceptGetDependencyAPIs
+            ? innerGetDependencyAPIs => {
+                  return () => {
+                      spy(`${interceptorName}:getDependencyAPIs`)
+                      return (innerGetDependencyAPIs && innerGetDependencyAPIs()) || []
+                  }
+              }
+            : undefined,
+        interceptAttach: flags.interceptAttach
+            ? innerAttach => {
+                  return shell => {
+                      spy(`${interceptorName}:attach`)
+                      innerAttach && innerAttach(shell)
+                  }
+              }
+            : undefined,
+        interceptExtend: flags.interceptExtend
+            ? innerExtend => {
+                  return shell => {
+                      spy(`${interceptorName}:extend`)
+                      innerExtend && innerExtend(shell)
+                  }
+              }
+            : undefined,
+        interceptDetach: flags.interceptDetach
+            ? innerDetach => {
+                  return shell => {
+                      spy(`${interceptorName}:detach`)
+                      innerDetach && innerDetach(shell)
+                  }
+              }
+            : undefined
+    }
+}

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' }])
+        })
+    })
+})