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

package/test/customExtensionSlot.spec.ts

@@ -0,0 +1,153 @@
+import _ from "lodash";
+import {
+  EntryPoint,
+  SlotKey,
+  Shell,
+  CustomExtensionSlot,
+  CustomExtensionSlotHandler,
+  ExtensionItem,
+} from "../src";
+import { createAppHost, addMockShell } from "../testKit";
+
+interface TestItem {
+  value: string;
+}
+
+const slotKey: SlotKey<TestItem> = { name: "TEST_SLOT" };
+
+describe("Custom Extension Slot", () => {
+  let slotUnderTest: CustomExtensionSlot<TestItem>;
+  let slotHandler: CustomExtensionSlotHandler<TestItem>;
+  let ownerShell: Shell | undefined;
+
+  const testEntryPoint: EntryPoint = {
+    name: "TEST",
+    attach(shell) {
+      ownerShell = shell;
+      slotUnderTest = shell.declareCustomSlot<TestItem>(slotKey, slotHandler);
+    },
+    detach(shell) {
+      ownerShell = undefined;
+    },
+  };
+
+  beforeEach(() => {
+    slotHandler = {
+      contribute: jest.fn(),
+      discardBy: jest.fn(),
+    };
+    ownerShell = undefined;
+  });
+
+  it("can be declared", () => {
+    createAppHost([testEntryPoint]);
+
+    expect(slotUnderTest).toBeDefined();
+  });
+
+  it("can be retrieved by key", async () => {
+    createAppHost([testEntryPoint]);
+
+    expect(ownerShell).toBeDefined();
+    expect(ownerShell && ownerShell.getSlot(slotKey)).toBeDefined();
+  });
+
+  it("invokes callback on contribute", () => {
+    const host = createAppHost([testEntryPoint]);
+    const contributorShell = addMockShell(host);
+    const item = { value: "abc" };
+
+    slotUnderTest.contribute(contributorShell, item);
+
+    expect(slotHandler.contribute).toBeCalledTimes(1);
+    expect(slotHandler.contribute).toBeCalledWith(contributorShell, item);
+    expect(slotHandler.discardBy).not.toHaveBeenCalled();
+  });
+
+  it("invokes callback on discard", () => {
+    createAppHost([testEntryPoint]);
+    const predicate = (item: ExtensionItem<TestItem>) => true;
+
+    slotUnderTest.discardBy(predicate);
+
+    expect(slotHandler.contribute).not.toHaveBeenCalled();
+    expect(slotHandler.discardBy).toBeCalledTimes(1);
+    expect(slotHandler.discardBy).toBeCalledWith(predicate);
+  });
+
+  it("cannot create two slots with same key: custom and standard", () => {
+    const beforeTestEntryPoint: EntryPoint = {
+      name: "BEFORE_TEST",
+      attach(shell) {
+        shell.declareSlot(slotKey);
+      },
+    };
+
+    expect(() =>
+      createAppHost([beforeTestEntryPoint, testEntryPoint])
+    ).toThrowError();
+  });
+
+  it("cannot create two slots with same key: custom and custom", () => {
+    const beforeTestEntryPoint: EntryPoint = {
+      name: "BEFORE_TEST",
+      attach(shell) {
+        shell.declareCustomSlot(slotKey, {
+          contribute: () => {},
+          discardBy: () => {},
+        });
+      },
+    };
+
+    expect(() =>
+      createAppHost([beforeTestEntryPoint, testEntryPoint])
+    ).toThrowError();
+  });
+
+  it("cannot create two slots with same name: custom and standard", () => {
+    const beforeTestEntryPoint: EntryPoint = {
+      name: "BEFORE_TEST",
+      attach(shell) {
+        shell.declareSlot({ name: slotKey.name });
+      },
+    };
+
+    expect(() =>
+      createAppHost([beforeTestEntryPoint, testEntryPoint])
+    ).toThrowError();
+  });
+
+  it("cannot create two slots with same name: custom and custom", () => {
+    const beforeTestEntryPoint: EntryPoint = {
+      name: "BEFORE_TEST",
+      attach(shell) {
+        shell.declareCustomSlot(
+          { name: slotKey.name },
+          {
+            contribute: () => {},
+            discardBy: () => {},
+          }
+        );
+      },
+    };
+
+    expect(() =>
+      createAppHost([beforeTestEntryPoint, testEntryPoint])
+    ).toThrowError();
+  });
+
+  it("can reload entry point that declares custom slots", async () => {
+    const host = createAppHost([testEntryPoint]);
+
+    expect(ownerShell).toBeDefined();
+
+    await host.removeShells([testEntryPoint.name]);
+
+    expect(ownerShell).toBeUndefined();
+
+    await host.addShells([_.cloneDeep(testEntryPoint)]);
+
+    expect(ownerShell).toBeDefined();
+    expect(ownerShell && ownerShell.getSlot(slotKey)).toBeDefined();
+  });
+});

package/test/extensionSlot.spec.ts

@@ -0,0 +1,94 @@
+import { SlotKey } from '../src'
+import { addMockShell, createAppHost } from '../testKit'
+import { PrivateExtensionSlot, Shell, EntryPoint } from '../src/API'
+
+describe('ExtensionSlot', () => {
+    describe('Subscribe', () => {
+        it('should be invoked on contribution', () => {
+            const slotKey: SlotKey<{}> = {
+                name: 'mock_key'
+            }
+            const host = createAppHost([])
+            const shell = addMockShell(host)
+            const spy = jest.fn()
+            const slot = shell.declareSlot(slotKey) as PrivateExtensionSlot<{}>
+
+            slot.subscribe(spy)
+
+            slot.contribute(shell, () => ({}))
+
+            expect(spy).toBeCalledTimes(1)
+
+            slot.contribute(shell, () => ({}))
+
+            expect(spy).toBeCalledTimes(2)
+        })
+        it('should be invoked once when contribution is during installation phase', () => {
+            interface SlotItem {
+                name: string
+            }
+            const slotKey: SlotKey<SlotItem> = {
+                name: 'MOCK_SLOT'
+            }
+            interface MockContributionAPI {
+                contributeItem(fromShell: Shell, item: SlotItem): void
+            }
+
+            const ContributionAPI: SlotKey<MockContributionAPI> = {
+                name: 'CONTRIBUTION_API'
+            }
+
+            const spy = jest.fn()
+
+            const contributionEntryPoint: EntryPoint = {
+                name: 'PRIVATE CONTRIBUTION ENTRY POINT',
+                declareAPIs() {
+                    return [ContributionAPI]
+                },
+                attach(shell) {
+                    const slot = shell.declareSlot(slotKey) as PrivateExtensionSlot<SlotItem>
+                    slot.subscribe(spy)
+                    shell.contributeAPI(ContributionAPI, () => ({
+                        contributeItem(fromShell, item) {
+                            shell.getSlot(slotKey).contribute(fromShell, item)
+                        }
+                    }))
+                }
+            }
+
+            const API_A: SlotKey<{}> = { name: 'API_A' }
+
+            const itemContributionEntryPointA: EntryPoint = {
+                name: 'ITEM CONTRIBUTION ENTRY POINT A',
+                getDependencyAPIs() {
+                    return [ContributionAPI]
+                },
+                declareAPIs(): SlotKey<{}>[] {
+                    return [API_A]
+                },
+                attach(shell: Shell) {
+                    shell.contributeAPI(API_A, () => ({}))
+                },
+                extend(shell: Shell) {
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'A.1' })
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'A.2' })
+                }
+            }
+
+            const itemContributionEntryPointB: EntryPoint = {
+                name: 'ITEM CONTRIBUTION ENTRY POINT B',
+                getDependencyAPIs() {
+                    return [ContributionAPI, API_A]
+                },
+                extend(shell: Shell) {
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'B.1' })
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'B.2' })
+                }
+            }
+
+            createAppHost([contributionEntryPoint, itemContributionEntryPointA, itemContributionEntryPointB])
+
+            expect(spy).toBeCalledTimes(1)
+        })
+    })
+})

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