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

package/test/testKit.spec.tsx

@@ -1,153 +0,0 @@
-import _ from 'lodash'
-import { EntryPoint, EntryPointOrPackage, SlotKey } from '../src/API'
-import { AnyExtensionSlot } from '../src/extensionSlot'
-import {
-    getPackagesDependencies,
-    createAppHost,
-    addMockShell,
-    MockAPI,
-    mockPackage,
-    createAppHostWithPacts,
-    PactAPI,
-    asyncLoadMockPackage,
-    dependsOnMockPackageEntryPoint,
-    MockPublicAPI,
-    createAppHostAndWaitForLoading
-} from '../testKit'
-
-interface APIKeys {
-    [name: string]: AnyExtensionSlot
-}
-const APIs: APIKeys = {
-    A: { name: 'A' },
-    B: { name: 'B' },
-    C: { name: 'C' },
-    D: { name: 'D' },
-    E: { name: 'E' },
-    F: { name: 'F' }
-}
-interface PackagesMap {
-    [name: string]: EntryPointOrPackage
-}
-const allPackages: PackagesMap = {
-    A: {
-        name: 'A'
-    },
-    B: {
-        name: 'B',
-        declareAPIs() {
-            return [APIs.B]
-        }
-    },
-    C: {
-        name: 'C',
-        getDependencyAPIs() {
-            return [APIs.B]
-        },
-        declareAPIs() {
-            return [APIs.C]
-        }
-    },
-    D: [
-        {
-            name: 'D',
-            getDependencyAPIs() {
-                return [APIs.C]
-            },
-            declareAPIs() {
-                return [APIs.E]
-            }
-        },
-        {
-            name: 'E'
-        }
-    ],
-    F: {
-        name: 'F',
-        getDependencyAPIs() {
-            return [APIs.E]
-        }
-    }
-}
-
-describe('App Host TestKit', () => {
-    it('should get packages dependencies', () => {
-        const toResult = (packages: EntryPointOrPackage[]) => _(packages).flatten().sortBy('name').value()
-        const getDependencies = (packages: EntryPointOrPackage[]) => toResult(getPackagesDependencies(_.values(allPackages), packages))
-        const { A, B, C, D, F } = allPackages
-
-        expect(getDependencies([])).toEqual(toResult([]))
-        expect(getDependencies([A])).toEqual(toResult([A]))
-        expect(getDependencies([C])).toEqual(toResult([B, C]))
-        expect(getDependencies([D])).toEqual(toResult([B, C, D]))
-        expect(getDependencies([D, B])).toEqual(toResult([B, C, D]))
-        expect(getDependencies([D, B, A])).toEqual(toResult([B, C, D, A]))
-
-        // TODO: Should 'E' be included ?
-        expect(getDependencies([F])).toEqual(toResult([B, C, (D as EntryPoint[])[0], F]))
-    })
-
-    it('should add mock shell', async () => {
-        const host = createAppHost([mockPackage])
-        const shell = addMockShell(host, {
-            name: 'MOCK',
-            getDependencyAPIs() {
-                return [MockAPI]
-            }
-        })
-        //await new Promise(resolve => host.onShellsChanged(resolve))
-        expect(host.hasShell('MOCK')).toBe(true)
-        expect(() => shell.getAPI(MockAPI)).not.toThrow()
-    })
-
-    it('should throw if could not add mock shell', async () => {
-        const host = createAppHost([mockPackage])
-        const APIKey = 'API that would never exist'
-        const add = async () => {
-            addMockShell(host, {
-                name: 'MOCK',
-                getDependencyAPIs() {
-                    return [MockAPI, { name: APIKey }]
-                }
-            })
-            //await new Promise(resolve => host.onShellsChanged(resolve))
-        }
-        await expect(add()).rejects.toThrow(new RegExp(APIKey))
-    })
-
-    it('should create app host with provided pacts', () => {
-        interface MockAPI1 {
-            f(): number
-        }
-        const key: SlotKey<MockAPI1> = { name: 'MOCK-API', layer: 'MOCK_LAYER' }
-        const pactAPI: MockAPI1 & PactAPI<MockAPI1> = {
-            getAPIKey: () => key,
-            f: () => 1
-        }
-        const host = createAppHostWithPacts([], [pactAPI])
-        expect(host.getAPI(key).f()).toBe(1)
-    })
-
-    describe('createAppHostAndWaitForLoading', () => {
-        beforeAll(() => {
-            jest.useFakeTimers()
-        })
-
-        afterAll(() => {
-            jest.useRealTimers()
-        })
-
-        it('should wait for loading all packages', async () => {
-            const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint, asyncLoadMockPackage], [])
-            jest.runAllTimers()
-            const host = await hostPromise
-            expect(host.getAPI(MockPublicAPI)).toBeDefined()
-        })
-
-        it('should throw if failed to load all packages', async () => {
-            const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint], [])
-            jest.runAllTimers()
-            await expect(hostPromise).rejects.toThrow(new RegExp(MockPublicAPI.name))
-        })
-    })
-})

package/testKit/emptyLoggerOptions.ts

@@ -1,16 +0,0 @@
-import { AppHostOptions } from '../src/API'
-
-export const emptyLoggerOptions: AppHostOptions = {
-    logger: {
-        log: jest.fn(),
-        spanChild: jest.fn().mockImplementation(() => ({
-            end() {}
-        })),
-        spanRoot: jest.fn().mockImplementation(() => ({
-            end() {}
-        }))
-    },
-    monitoring: {
-        disableMonitoring: true
-    }
-}

package/testKit/index.ts

@@ -1,177 +0,0 @@
-import _ from 'lodash'
-import { EntryPoint, ObservableState } from '../src/API'
-import { AnySlotKey, AppHost, createAppHost as _createAppHost, EntryPointOrPackage, Shell, SlotKey } from '../src/index'
-import { createShellLogger } from '../src/loggers'
-import { emptyLoggerOptions } from './emptyLoggerOptions'
-
-/**
- * When using the testKit you are not directly depends on the global of the repluggableAppDebug,
- * So in order of it to populate global 'only' when import testKit we re-export it here.
- * And not in repluggable-core so it will not pollute the global when using repluggable-core 
- * */ 
-export type * from '../src/repluggableAppDebug/debug'
-
-export {createShellLogger}
-export { emptyLoggerOptions }
-export { AppHost } from '../src/index'
-
-export { withConsoleErrors } from './withConsoleErrors'
-export { withThrowOnError } from './withThrowOnError'
-export * from './mockPackage'
-
-export const createAppHost: typeof _createAppHost = (packages, options = emptyLoggerOptions) => {
-    return _createAppHost(packages, options)
-}
-
-interface PactAPIBase {
-    getAPIKey(): AnySlotKey
-}
-
-export interface PactAPI<T> extends PactAPIBase {
-    getAPIKey(): SlotKey<T>
-}
-
-function forEachDeclaredAPI(allPackages: EntryPointOrPackage[], iteration: (dependency: AnySlotKey, entryPoint: EntryPoint) => void) {
-    _.forEach(_.flatten(allPackages), (entryPoint: EntryPoint) => {
-        _.forEach(entryPoint.declareAPIs ? entryPoint.declareAPIs() : [], dependency => {
-            iteration(dependency, entryPoint)
-        })
-    })
-}
-
-export const getPackagesDependencies = (
-    allPackages: EntryPointOrPackage[],
-    requiredPackages: EntryPointOrPackage[]
-): EntryPointOrPackage[] => {
-    const apiToEntryPoint = new Map<string, EntryPoint | undefined>()
-    const loadedEntryPoints = new Set<string>()
-
-    forEachDeclaredAPI(allPackages, (dependency, entryPoint) => {
-        apiToEntryPoint.set(dependency.name, entryPoint)
-    })
-
-    const packagesList: EntryPointOrPackage[] = []
-    const entryPointsQueue: EntryPoint[] = _.flatten(requiredPackages)
-
-    while (entryPointsQueue.length) {
-        const currEntryPoint = entryPointsQueue.shift()
-        if (!currEntryPoint || loadedEntryPoints.has(currEntryPoint.name)) {
-            continue
-        }
-        loadedEntryPoints.add(currEntryPoint.name)
-        packagesList.push(currEntryPoint)
-        const dependencies = currEntryPoint.getDependencyAPIs ? currEntryPoint.getDependencyAPIs() : []
-        const dependencyEntryPoints = dependencies.map((API: AnySlotKey) => apiToEntryPoint.get(API.name))
-        entryPointsQueue.push(..._.compact(dependencyEntryPoints))
-    }
-
-    return _.uniq(packagesList)
-}
-
-export function createAppHostWithPacts(packages: EntryPointOrPackage[], pacts: PactAPIBase[]) {
-    const pactsEntryPoint: EntryPoint = {
-        name: 'PACTS_ENTRY_POINT',
-        declareAPIs() {
-            return pacts.map(pact => pact.getAPIKey())
-        },
-        attach(shell: Shell): void {
-            _.each(pacts, pact => {
-                shell.contributeAPI(pact.getAPIKey(), () => pact)
-            })
-        }
-    }
-
-    return createAppHost([...packages, pactsEntryPoint], { ...emptyLoggerOptions, disableLayersValidation: true })
-}
-
-export async function createAppHostAndWaitForLoading(packages: EntryPointOrPackage[], pacts: PactAPIBase[]): Promise<AppHost> {
-    const appHost = createAppHostWithPacts(packages, pacts)
-    const declaredAPIs = _(packages)
-        .flatten()
-        .value()
-        .flatMap((entryPoint: EntryPoint) => (entryPoint.declareAPIs ? entryPoint.declareAPIs() : []))
-
-    const timeoutPromise = new Promise((resolve, reject) => {
-        setTimeout(() => {
-            const readyAPIs = Array.from(globalThis.repluggableAppDebug.readyAPIs)
-            const unreadyAPIs = declaredAPIs.filter(api => !readyAPIs.some(readyAPI => readyAPI.name === api.name))
-            reject(
-                new Error(
-                    'createAppHostAndWaitForLoading - waiting for loading timed out - the following declaredAPIs were not contributed ' +
-                        JSON.stringify(unreadyAPIs)
-                )
-            )
-        }, 3000)
-    })
-
-    const loadingPromise = new Promise<void>(async resolve => {
-        await appHost.addShells([
-            {
-                name: 'Depends on all declared APIs',
-                getDependencyAPIs() {
-                    return declaredAPIs
-                },
-                extend() {
-                    resolve()
-                }
-            }
-        ])
-    })
-
-    return Promise.race([timeoutPromise, loadingPromise]).then(() => appHost)
-}
-
-
-type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
-interface EntryPointOverrides extends Omit<EntryPoint, 'name'> {
-    name?: EntryPoint['name']
-}
-
-// this function assumes that addShells completes synchronously
-export const addMockShell = (host: AppHost, entryPointOverrides: EntryPointOverrides = {}): Shell => {
-    let shell = null
-    host.addShells([
-        {
-            name: _.uniqueId('__MOCK_SHELL_'),
-            ...entryPointOverrides,
-            attach(_shell: Shell) {
-                shell = _shell
-                if (entryPointOverrides.attach) {
-                    entryPointOverrides.attach(_shell)
-                }
-            }
-        }
-    ])
-    if (!shell) {
-        const dependencies = entryPointOverrides.getDependencyAPIs ? entryPointOverrides.getDependencyAPIs() : []
-        const canGetAPI = (key: AnySlotKey) => {
-            try {
-                host.getAPI(key)
-                return true
-            } catch (e) {
-                return false
-            }
-        }
-        const missing = dependencies.filter((key: AnySlotKey) => !canGetAPI(key))
-        throw new Error(
-            `addMockShell: overridden entry point is not ready (missing dependency APIs?) host could not find: ${missing.map(
-                (v: AnySlotKey) => `"${v.name}"`
-            )}`
-        )
-    }
-    return shell
-}
-
-
-
-export function mockObservable<T>(value: T): ObservableState<T> {
-    return {
-        subscribe: () => {
-            return () => {}
-        },
-        current() {
-            return value
-        }
-    }
-}
-

package/testKit/mockPackage.ts

@@ -1,110 +0,0 @@
-import _ from 'lodash'
-
-import { AnyAction } from 'redux'
-import { EntryPoint, Shell, SlotKey } from '../src/API'
-
-export interface MockAPI {
-    stubTrue(): boolean
-    getNewObject(): object
-}
-
-export interface MockPublicAPI {
-    stubTrue(): boolean
-}
-
-export const MockAPI: SlotKey<MockAPI> = { name: 'mock API' }
-export const MockSlot: SlotKey<any> = { name: 'mock slot' }
-export const MockPublicAPI: SlotKey<MockPublicAPI> = {
-    name: 'mock API public',
-    public: true
-}
-
-const createMockAPI = (shell: Shell): MockAPI => ({
-    stubTrue: _.stubTrue,
-    getNewObject: () => ({})
-})
-
-export interface MockState {
-    mockValue: boolean
-}
-
-export const mockShellInitialState: MockState = {
-    mockValue: true
-}
-
-export const TOGGLE_MOCK_VALUE = 'mockEntryPoint/mockAction'
-
-const mockReducer = (state: MockState = mockShellInitialState, action: AnyAction): MockState => {
-    switch (action.type) {
-        case TOGGLE_MOCK_VALUE:
-            return { ...state, mockValue: !state.mockValue }
-    }
-    return state
-}
-
-export const mockShellStateKey = 'mockEntryPoint'
-
-export const mockPackage: EntryPoint = {
-    name: 'MOCK_ENTRY_POINT',
-    declareAPIs() {
-        return [MockAPI]
-    },
-    attach(shell: Shell) {
-        shell.contributeAPI(MockAPI, () => createMockAPI(shell))
-        shell.contributeState(() => ({
-            [mockShellStateKey]: mockReducer
-        }))
-    }
-}
-
-export const asyncLoadMockPackage: EntryPoint = {
-    name: 'ASYNC_MOCK_ENTRY_POINT',
-    declareAPIs() {
-        return [MockAPI]
-    },
-    async extend(shell: Shell) {
-        await new Promise<void>(resolve => {
-            setTimeout(() => {
-                shell.contributeAPI(MockAPI, () => createMockAPI(shell))
-                resolve()
-            }, 500)
-        })
-    }
-}
-
-export const dependsOnMockPackageEntryPoint: EntryPoint = {
-    name: 'DEPENDS ON MOCK API',
-    getDependencyAPIs() {
-        return [MockAPI]
-    },
-    declareAPIs() {
-        return [MockPublicAPI]
-    },
-    attach(shell: Shell) {
-        shell.contributeAPI(MockPublicAPI, () => ({
-            stubTrue: () => true
-        }))
-    }
-}
-
-export const mockPackageWithPublicAPI: EntryPoint = {
-    name: 'MOCK_ENTRY_POINT_PUBLIC',
-    declareAPIs() {
-        return [MockPublicAPI]
-    },
-    attach(shell: Shell) {
-        shell.contributeAPI(MockPublicAPI, () => ({
-            stubTrue: () => true
-        }))
-    }
-}
-
-export const mockPackageWithSlot: EntryPoint = {
-    name: 'MOCK_PACKAGE_WITH_SLOT',
-    declareAPIs() {
-        return []
-    },
-    attach(shell: Shell) {
-        shell.declareSlot(MockSlot)
-    }
-}

package/testKit/withConsoleErrors.ts

@@ -1,12 +0,0 @@
-const noopConsoleError: Console['error'] = () => {}
-
-export function withConsoleErrors<T>(action: () => T, mock?: Console['error']): T {
-    const savedConsoleError = console.error
-    console.error = mock || noopConsoleError
-
-    try {
-        return action()
-    } finally {
-        console.error = savedConsoleError
-    }
-}

package/testKit/withThrowOnError.ts

@@ -1,34 +0,0 @@
-import { AppHostOptions, HostLogger, LogSeverity, ShellLoggerSpan } from '../src/API'
-
-export function withThrowOnError(options: AppHostOptions = { monitoring: {} }): AppHostOptions {
-    const throwError = (error: Error, keyValuePairs?: Object) => {
-        throw new Error(`${error} ${keyValuePairs ? JSON.stringify(keyValuePairs) : ''}`)
-    }
-
-    const span: ShellLoggerSpan = {
-        end(success, error, keyValuePairs) {
-            if (error) {
-                throwError(error, keyValuePairs)
-            }
-        }
-    }
-
-    const logger: HostLogger = {
-        spanRoot(messageId: string, error?: Error, keyValuePairs?: Object): ShellLoggerSpan {
-            return span
-        },
-        spanChild(messageId: string, error?: Error, keyValuePairs?: Object): ShellLoggerSpan {
-            return span
-        },
-        log(severity: LogSeverity, id: string, error?: Error, keyValuePairs?: Object): void {
-            if (severity === 'error' || severity === 'critical') {
-                throwError(error || new Error('Unknown error'), keyValuePairs)
-            }
-        }
-    }
-
-    return {
-        ...options,
-        logger
-    }
-}