Merge pull request #63 from contentstack/develop

v1.4.0--beta.1

Author: Deepak-Kharah

.eslintrc

@@ -12,6 +12,11 @@
         "plugin:@typescript-eslint/eslint-recommended",
         "plugin:@typescript-eslint/recommended"
     ],
+    "env": {
+        "browser": true,
+        "node": true
+    },
+
     "rules": {
         "@typescript-eslint/no-explicit-any": 0,
         "@typescript-eslint/prefer-const": 0,

README.md

@@ -13,7 +13,7 @@ npm install @contentstack/app-sdk
 Alternatively, you can use the following command within the script tag to install the App SDK:
 
 ```html
-<script src="https://unpkg.com/@contentstack/app-sdk@^1.3.0/dist/index.js"></script>
+<script src="https://unpkg.com/@contentstack/app-sdk@^1.4.0/dist/index.js"></script>
 ```
 
 ### Initializing the App SDK

__test__/appConfig.test.ts

@@ -0,0 +1,88 @@
+import EventEmitter from "wolfy87-eventemitter";
+import { AppConfig } from "../src/appConfig";
+import { ERROR_MESSAGES } from "../src/utils/errorMessages";
+
+describe("app config", () => {
+    const mockConnection = {
+        sendToParent: jest.fn().mockReturnValue(Promise.resolve({})),
+    };
+    const mockEmitter: EventEmitter = new EventEmitter();
+    const mockData = {
+        stack: {},
+    };
+    const appConfig: AppConfig = new AppConfig(
+        mockData,
+        mockConnection,
+        mockEmitter,
+        { currentBranch: "master" }
+    );
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("stack method should return stack object", () => {
+        expect(appConfig.stack()).toBeDefined();
+    });
+
+    it("setInstallationData method should send data to parent", () => {
+        const data = {
+            configuration: {},
+            serverConfiguration: {},
+        };
+        appConfig.setInstallationData(data);
+
+        expect(mockConnection.sendToParent).toHaveBeenLastCalledWith(
+            "setInstallationData",
+            data
+        );
+    });
+    it("getInstallationData method should send request to parent for data", () => {
+        appConfig.getInstallationData();
+
+        expect(mockConnection.sendToParent).toHaveBeenLastCalledWith(
+            "getInstallationData"
+        );
+    });
+
+    describe("setValidity", () => {
+        it("should throw error if isValid is not a boolean", async () => {
+            await expect(appConfig.setValidity("true" as any)).rejects.toThrow(
+                ERROR_MESSAGES.configPage.setValidity.isValidTypeBoolean
+            );
+        });
+
+        it("should throw error if message is not a string", async () => {
+            await expect(
+                appConfig.setValidity(true, { message: 123 as any })
+            ).rejects.toThrow(
+                ERROR_MESSAGES.configPage.setValidity.messageTypeString
+            );
+        });
+
+        it("should work when options parameter is not provided", async () => {
+            await appConfig.setValidity(true);
+
+            expect(mockConnection.sendToParent).toHaveBeenLastCalledWith(
+                "setValidity",
+                { isValid: true }
+            );
+        });
+
+        it("should send data to parent", async () => {
+            await appConfig.setValidity(true);
+
+            expect(mockConnection.sendToParent).toHaveBeenLastCalledWith(
+                "setValidity",
+                { isValid: true }
+            );
+
+            await appConfig.setValidity(false, { message: "message" });
+
+            expect(mockConnection.sendToParent).toHaveBeenLastCalledWith(
+                "setValidity",
+                { isValid: false, options: { message: "message" } }
+            );
+        });
+    });
+});

__test__/extension.test.ts

@@ -0,0 +1,57 @@
+import Extension from "../src/extension";
+import { IAppConfigInitData } from "../src/types";
+
+jest.mock("post-robot", () => ({
+    sendToParent: jest.fn(),
+    on: jest.fn(),
+}));
+
+const initData: IAppConfigInitData = {
+    data: {
+        type: "APP_CONFIG_WIDGET",
+        app_id: "app_id",
+        installation_uid: "installation_uid",
+        extension_uid: "extension_uid",
+        stack: {
+            created_at: "created_at",
+            updated_at: "updated_at",
+            uid: "uid",
+            org_uid: "org_uid",
+            api_key: "api_key",
+            master_locale: "master_locale",
+            is_asset_download_public: true,
+            owner_uid: "owner_uid",
+            user_uids: ["user_uids"],
+            settings: {},
+            name: "name",
+        },
+        user: {},
+        currentBranch: "currentBranch",
+    },
+};
+
+describe("Main extension", () => {
+
+    afterEach(() => {
+        window["postRobot"] = undefined;
+        window["iframeRef"] = undefined;
+    })
+
+    it("should have modal property", () => {
+        const extension = new Extension(initData);
+        expect(extension.modal).toBeDefined();
+    })
+
+    describe("Properties in the window object", () => {
+        it("should have postRobot property", () => {
+            expect(window["postRobot"]).toBeUndefined();
+            new Extension(initData);
+            expect(window["postRobot"]).toBeDefined();
+
+            Object.prototype.hasOwnProperty.call(
+                window["postRobot"],
+                "sendToParent"
+            );
+        });
+    });
+});

__test__/extenstion.test.ts

@@ -0,0 +1,29 @@
+import postRobot from "post-robot";
+import Extension from "../src/extension";
+
+jest.mock("post-robot", () => ({
+  __esModule: true,
+  default: {
+    on: jest.fn(),
+    sendToParent: jest.fn(),
+  },
+}));
+
+describe("Extension", () => {
+  let extensionObj: Extension;
+  const initializationData = { data: { type: "DASHBOARD" } };
+
+  beforeEach(function () {
+    extensionObj = new Extension(initializationData as any);
+  });
+
+  it("pulse should invoke post robot method with type analytics", () => {
+    const eventName = "Sample Event";
+    const metadata = { foo: "bar" };
+    extensionObj.pulse(eventName, metadata);
+    expect((postRobot as any).sendToParent).toHaveBeenCalledWith("analytics", {
+      eventName,
+      metadata,
+    });
+  });
+});

__test__/entryFieldLocation/entry.test.ts …st__/fieldModifierLocation/entry.test.ts__test__/entryFieldLocation/entry.test.ts renamed to __test__/fieldModifierLocation/entry.test.ts __test__/entryFieldLocation/entry.test.ts renamed to __test__/fieldModifierLocation/entry.test.ts

@@ -1,18 +1,18 @@
-import EntryFieldLocationEntry from "../../src/entryFieldLocation/entry";
+import FieldModifierLocationEntry from "../../src/fieldModifierLocation/entry";
 import testData from "../data/testData.json";
-import { IEntryFieldLocationInitData } from "../../src/types";
-import { errorMessage } from "../../src/utils/errorMessages";
+import { IFieldModifierLocationInitData } from "../../src/types";
+import generateErrorMessages, { ERROR_MESSAGES } from "../../src/utils/errorMessages";
 
-describe("EntryFieldLocationEntry", () => {
-    let entryInstance: EntryFieldLocationEntry;
+describe("FieldModifierLocationEntry", () => {
+    let entryInstance: FieldModifierLocationEntry;
     let sendToParent: any;
     let connection: { sendToParent: (...props: any[]) => any };
 
     let emitter: any;
-    function getEntryInitialData(): IEntryFieldLocationInitData {
+    function getEntryInitialData(): IFieldModifierLocationInitData {
         return {
             data: {
-                type: "ENTRY_FIELD_LOCATION",
+                type: "FIELD_MODIFIER_LOCATION",
                 config: {},
                 content_type: {},
                 entry: {
@@ -54,7 +54,8 @@ describe("EntryFieldLocationEntry", () => {
             },
         };
     }
-    const entryIntialData: IEntryFieldLocationInitData = getEntryInitialData();
+    const entryIntialData: IFieldModifierLocationInitData =
+        getEntryInitialData();
 
     beforeEach(() => {
         sendToParent = () => {};
@@ -73,7 +74,7 @@ describe("EntryFieldLocationEntry", () => {
         };
 
         jest.spyOn(emitter, "on");
-        entryInstance = new EntryFieldLocationEntry(
+        entryInstance = new FieldModifierLocationEntry(
             entryIntialData,
             connection,
             emitter
@@ -131,19 +132,19 @@ describe("EntryFieldLocationEntry", () => {
         it("should throw an error when tags are not defined", async () => {
             // @ts-ignore
             await expect(entryInstance.setTags()).rejects.toThrow(
-                errorMessage.entryField.entry.tagsShouldNotBeBlank
+                generateErrorMessages(ERROR_MESSAGES.entryField.entry.tagsShouldNotBeBlank)
             );
         });
 
         it("should throw an error if tags is not an array of strings", async () => {
             // @ts-ignore
             await expect(entryInstance.setTags(["tag3", 4])).rejects.toThrow(
-                errorMessage.entryField.entry.tagsShouldBeArrayOfStrings
+                generateErrorMessages(ERROR_MESSAGES.entryField.entry.tagsShouldBeArrayOfStrings)
             );
 
             // @ts-ignore
             await expect(entryInstance.setTags("tag3")).rejects.toThrow(
-                errorMessage.entryField.entry.tagsShouldBeArrayOfStrings
+                generateErrorMessages(ERROR_MESSAGES.entryField.entry.tagsShouldBeArrayOfStrings)
             );
         });
 

__test__/entryFieldLocation/field.test.ts …st__/fieldModifierLocation/field.test.ts__test__/entryFieldLocation/field.test.ts renamed to __test__/fieldModifierLocation/field.test.ts __test__/entryFieldLocation/field.test.ts renamed to __test__/fieldModifierLocation/field.test.ts

@@ -1,4 +1,4 @@
-import Field from "../../src/entryFieldLocation/field";
+import Field from "../../src/fieldModifierLocation/field";
 import testData from "../data/testData.json";
 import fileFieldData from "../data/fileField.json";
 import helpers from "../helpers";

__test__/entryFieldLocation/frame.test.ts …st__/fieldModifierLocation/frame.test.ts__test__/entryFieldLocation/frame.test.ts renamed to __test__/fieldModifierLocation/frame.test.ts __test__/entryFieldLocation/frame.test.ts renamed to __test__/fieldModifierLocation/frame.test.ts

@@ -1,9 +1,9 @@
-import EntryFieldLocationFrame from "../../src/entryFieldLocation/frame";
-import { errorMessage } from "../../src/utils/errorMessages";
+import FieldModifierLocationFrame from "../../src/fieldModifierLocation/frame";
+import { ERROR_MESSAGES } from "../../src/utils/errorMessages";
 import testData from "../data/testData.json";
 
-describe("EntryFieldLocationFrame", () => {
-    let frameInstance: EntryFieldLocationFrame;
+describe("FieldModifierLocationFrame", () => {
+    let frameInstance: FieldModifierLocationFrame;
     let sendToParent: any;
     let connection: { sendToParent: (...props: any[]) => any };
 
@@ -26,7 +26,7 @@ describe("EntryFieldLocationFrame", () => {
         };
 
         jest.spyOn(emitter, "on");
-        frameInstance = new EntryFieldLocationFrame(connection, emitter);
+        frameInstance = new FieldModifierLocationFrame(connection, emitter);
     });
 
     afterEach(() => {
@@ -76,7 +76,7 @@ describe("EntryFieldLocationFrame", () => {
                 // @ts-ignore
                 frameInstance.updateDimension({ height: "100" })
             ).rejects.toThrowError(
-                errorMessage.entryField.frame.dimensionHeightShouldBeNumber
+                ERROR_MESSAGES.entryField.frame.dimensionHeightShouldBeNumber
             );
         });
 
@@ -85,7 +85,7 @@ describe("EntryFieldLocationFrame", () => {
                 // @ts-ignore
                 frameInstance.updateDimension({ width: "100" })
             ).rejects.toThrowError(
-                errorMessage.entryField.frame.dimensionWidthShouldBeNumber
+                ERROR_MESSAGES.entryField.frame.dimensionWidthShouldBeNumber
             );
         });
     });
@@ -108,7 +108,7 @@ describe("EntryFieldLocationFrame", () => {
             //@ts-ignore
             global.MutationObserver = mutationObserverMock;
 
-            frameInstance = new EntryFieldLocationFrame(connection, emitter);
+            frameInstance = new FieldModifierLocationFrame(connection, emitter);
 
             const [observerInstance] = <void[] | [{ trigger: () => {} }]>(
                 mutationObserverMock.mock.instances
@@ -150,7 +150,7 @@ describe("EntryFieldLocationFrame", () => {
             //@ts-ignore
             global.MutationObserver = mutationObserverMock;
 
-            frameInstance = new EntryFieldLocationFrame(connection, emitter);
+            frameInstance = new FieldModifierLocationFrame(connection, emitter);
 
             frameInstance.disableAutoResizing();
 

__test__/modal.test.ts

@@ -0,0 +1,48 @@
+import Modal from "../src/modal";
+
+describe("Modal module", () => {
+    const bodyChildInnerText = "body-child";
+    const divElementInnerText = "separate-div";
+
+    const bodyChild = document.createElement("div");
+    bodyChild.innerText = bodyChildInnerText;
+    document.body.appendChild(bodyChild);
+
+    const divElement = document.createElement("div");
+    divElement.innerText = divElementInnerText;
+    document.body.appendChild(divElement);
+
+    afterEach(() => {
+        window["iframeRef"] = undefined;
+    });
+
+    it("should add first child of the body to iframeRef if the user has not provided one", () => {
+        expect(window["iframeRef"]).toBeUndefined();
+
+        new Modal();
+        expect(window["iframeRef"]).toBeDefined();
+        expect(window["iframeRef"].tagName).toBe(bodyChild.tagName);
+        expect(window["iframeRef"].innerText).toBe(bodyChildInnerText);
+    });
+
+    it("should not add anything to iframeRef if it already exists", () => {
+        window["iframeRef"] = divElement;
+
+        new Modal();
+        const iframeRef = window["iframeRef"];
+
+        expect(iframeRef).toBeDefined();
+        expect(iframeRef.tagName).toBe(divElement.tagName);
+        expect(iframeRef.innerText).toBe(divElementInnerText);
+    });
+
+    it("should set iframeRef to the element provided by the user", () => {
+        const modal = new Modal();
+        modal.setBackgroundElement(divElement);
+        const iframeRef = window["iframeRef"];
+
+        expect(iframeRef).toBeDefined();
+        expect(iframeRef.tagName).toBe(divElement.tagName);
+        expect(iframeRef.innerText).toBe(divElementInnerText);
+    });
+});