@finsemble/finsemble-ui 1.0.0-beta-1

package/react/components/sdd/tests/AppEditPage.spec.js

@@ -0,0 +1,1236 @@
+import * as React from "react";
+import { mount } from "enzyme";
+import { afterEach, describe, it } from "mocha";
+import { expect } from "chai";
+import sinon from "sinon";
+import { Page, EmptyPage, NativePage, PageWithIconURL, AssimilationPage, CitrixPage, } from "../stories/AppEditPage.stories";
+import { accessibilityAssessor } from "./a11y_helper";
+const defaults = {
+    name: "Test",
+    abstractPosition: 0,
+    addToWorkspace: true,
+    alias: "",
+    allowAutoArrange: true,
+    allowGrouping: true,
+    allowMaximize: true,
+    allowMinimize: true,
+    allowSnapping: true,
+    allowTabbing: true,
+    allowTiling: true,
+    alwaysOnTop: false,
+    appArguments: "",
+    appType: "web",
+    autoConnect: false,
+    bootPhase: "preuser",
+    description: "",
+    devConsole: false,
+    enableAOT: false,
+    enableTitleBar: true,
+    height: 600,
+    hideClose: false,
+    hideMaximize: false,
+    hideMinimize: false,
+    iconURL: "",
+    intents: [],
+    isEvergreen: false,
+    launchableByUser: true,
+    native_windowSpawnTimeout: 30,
+    opacity: 1,
+    path: "",
+    persistPath: true,
+    persistURL: true,
+    preloads: [],
+    resizable: true,
+    rules: [],
+    security: "trusted",
+    serviceVisible: false,
+    singleton: false,
+    spawnOnStartup: false,
+    titlebarType: "injected",
+    url: "http://www.google.com",
+    waitForInitialization: true,
+    width: 1280,
+};
+const testPresetInputValue = (appDataKey, selector, starter = Page, presetValue = "Test") => {
+    var _a;
+    const args = Object.assign(Object.assign({}, starter.args), { appData: Object.assign(Object.assign({}, (_a = starter.args) === null || _a === void 0 ? void 0 : _a.appData), { [appDataKey]: presetValue }) });
+    const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+    expect(wrapper.find(selector).prop("value")).to.equal(presetValue);
+};
+const testSaveInputValue = (appDataKey, selector, native = false, newValue = "New value") => {
+    const starter = native ? NativePage : Page;
+    const buttonSpy = sinon.spy(starter.args, "submitFn");
+    const wrapper = mount(React.createElement(Page, Object.assign({}, starter.args)));
+    wrapper
+        .find(selector)
+        .at(0)
+        .simulate("change", {
+        target: {
+            value: newValue,
+        },
+    });
+    const collection = wrapper.find("button");
+    collection.at(collection.length - 1).simulate("click");
+    expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign(Object.assign({}, defaults), (native
+        ? {
+            appType: "native",
+            path: "test.exe",
+        }
+        : {})), { [appDataKey]: newValue }));
+};
+const testSubmitOnEnter = (selector, starter = Page) => {
+    const buttonSpy = sinon.spy(starter.args, "submitFn");
+    const wrapper = mount(React.createElement(Page, Object.assign({}, starter.args)));
+    wrapper
+        .find(selector)
+        .at(0)
+        .simulate("keydown", {
+        key: "Enter",
+        preventDefault: () => { },
+    });
+    expect(buttonSpy.calledOnce).to.be.true;
+};
+const flipCheckbox = (appDataKey, label, presetValue) => {
+    var _a;
+    const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { [appDataKey]: presetValue }) });
+    const buttonSpy = sinon.spy(args, "submitFn");
+    const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+    wrapper.find(`[role='checkbox'][aria-label='${label}']`).simulate("click");
+    const collection = wrapper.find("button");
+    const saveButton = collection.at(collection.length - 1);
+    saveButton.simulate("click");
+    expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign({}, defaults), { [appDataKey]: !presetValue }));
+};
+const presetCheckbox = (appDataKey, label, presetValue = true, expectedValue = true) => {
+    var _a;
+    const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { [appDataKey]: presetValue }) });
+    const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+    expect(wrapper.find(`[role='checkbox'][aria-label='${label}']`).prop("aria-checked")).to.equal(expectedValue);
+};
+const checkUniqueRadioButtons = (name, numberOfButtons, starter = Page) => {
+    const wrapper = mount(React.createElement(Page, Object.assign({}, starter.args)));
+    const locator = `input[type='radio'][name='${name}']`;
+    for (let i = 0; i < numberOfButtons; i++) {
+        wrapper.find(locator).at(i).simulate("change");
+        for (let j = 0; j < numberOfButtons; j++) {
+            expect(wrapper.find(locator).at(j).prop("checked"), `When radio #${i + 1} is clicked, is radio #${j + 1} checked?`).to.equal(i === j);
+        }
+    }
+};
+const presetRadioButtons = (name, presetData, radioChecked) => {
+    var _a;
+    const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), presetData) });
+    const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+    radioChecked.forEach((radioButton, key) => {
+        expect(wrapper.find(`input[type='radio'][name='${name}']`).at(key).prop("checked")).to.equal(radioButton);
+    });
+};
+const saveRadioButton = (name, buttonNumberChecked, savedValues, starter = Page) => {
+    const buttonSpy = sinon.spy(starter.args, "submitFn");
+    const wrapper = mount(React.createElement(Page, Object.assign({}, starter.args)));
+    wrapper.find(`input[type='radio'][name='${name}']`).at(buttonNumberChecked).simulate("change");
+    const collection = wrapper.find("button");
+    const saveButton = collection.at(collection.length - 1);
+    saveButton.simulate("click");
+    const savedValue = buttonSpy.args[0][0];
+    for (let key in savedValues) {
+        // @ts-ignore
+        expect(savedValue[key]).to.equal(savedValues[key]);
+    }
+};
+describe("<AppEditPage/>", () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    // Not using accessibility scans on this page, since the parent component <Applications /> is running them
+    it("should call the passed-in cancel function when the cancel button is clicked", () => {
+        const buttonSpy = sinon.spy(Page.args, "cancelFn");
+        const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+        const collection = wrapper.find("button");
+        collection.at(collection.length - 2).simulate("click");
+        expect(buttonSpy.calledOnce).to.be.true;
+    });
+    it("should call the passed-in Remove Application function when the Remove Application button is clicked", () => {
+        const buttonSpy = sinon.spy(Page.args, "removeApplicationFn");
+        const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+        const collection = wrapper.find("button");
+        collection.at(collection.length - 3).simulate("click");
+        expect(buttonSpy.calledOnce).to.be.true;
+        sinon.restore();
+    });
+    it("should call the passed-in submit function with relevant data when the submit button is clicked", () => {
+        const buttonSpy = sinon.spy(Page.args, "submitFn");
+        const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+        wrapper.find("button").last().simulate("click");
+        expect(buttonSpy.calledOnce).to.be.true;
+        expect(buttonSpy.firstCall.args[0]).to.deep.equal(defaults);
+    });
+    it("should pass accessibility scans", async () => {
+        const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+        expect(await accessibilityAssessor(wrapper)).to.be.true;
+    }).timeout(10e3);
+    describe("Show/hide sections for types of apps", () => {
+        it("Web app type", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            expect(wrapper.contains("App URL")).to.be.true;
+            expect(wrapper.contains("File path")).to.be.false;
+            expect(wrapper.contains("Arguments")).to.be.false;
+            expect(wrapper.contains("API access")).to.be.false;
+            expect(wrapper.contains("Virtual app name")).to.be.false;
+            expect(wrapper.contains("Launch timeout")).to.be.false;
+            expect(wrapper.contains("Persist across workspaces")).to.be.true;
+            expect(wrapper.find("#accordion-control-select-connect").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-preloads").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-window").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-window-behavior").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-interop").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-component").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-workspace").exists()).to.be.true;
+            expect(wrapper.find("#persist-url").exists()).to.be.true;
+            expect(wrapper.find("#persist-path").exists()).to.be.false;
+        });
+        it("Native app type", () => {
+            const wrapper = mount(React.createElement(NativePage, Object.assign({}, NativePage.args)));
+            expect(wrapper.contains("App URL")).to.be.false;
+            expect(wrapper.contains("File path")).to.be.true;
+            expect(wrapper.contains("Arguments")).to.be.true;
+            expect(wrapper.contains("API access")).to.be.true;
+            expect(wrapper.contains("Virtual app name")).to.be.false;
+            expect(wrapper.contains("Launch timeout")).to.be.true;
+            expect(wrapper.contains("Persist across workspaces")).to.be.true;
+            expect(wrapper.find("#accordion-control-select-connect").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-preloads").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-window").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-window-behavior").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-interop").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-component").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-workspace").exists()).to.be.true;
+            expect(wrapper.find("#persist-url").exists()).to.be.false;
+            expect(wrapper.find("#persist-path").exists()).to.be.true;
+        });
+        it("Assimilation app type", () => {
+            const wrapper = mount(React.createElement(AssimilationPage, Object.assign({}, AssimilationPage.args)));
+            expect(wrapper.contains("App URL")).to.be.false;
+            expect(wrapper.contains("File path")).to.be.true;
+            expect(wrapper.contains("Arguments")).to.be.true;
+            expect(wrapper.contains("API access")).to.be.true;
+            expect(wrapper.contains("Virtual app name")).to.be.false;
+            expect(wrapper.contains("Launch timeout")).to.be.false;
+            expect(wrapper.contains("Persist across workspaces")).to.be.true;
+            expect(wrapper.find("#accordion-control-select-connect").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-preloads").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-window").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-window-behavior").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-interop").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-component").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-workspace").exists()).to.be.true;
+            expect(wrapper.find("#persist-url").exists()).to.be.false;
+            expect(wrapper.find("#persist-path").exists()).to.be.true;
+        });
+        it("Citrix app type", () => {
+            const wrapper = mount(React.createElement(CitrixPage, Object.assign({}, CitrixPage.args)));
+            expect(wrapper.contains("App URL")).to.be.false;
+            expect(wrapper.contains("File path")).to.be.false;
+            expect(wrapper.contains("Arguments")).to.be.true;
+            expect(wrapper.contains("API access")).to.be.false;
+            expect(wrapper.contains("Virtual app name")).to.be.true;
+            expect(wrapper.contains("Launch timeout")).to.be.false;
+            expect(wrapper.contains("Persist across workspaces")).to.be.false;
+            expect(wrapper.find("#accordion-control-select-connect").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-preloads").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-window").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-window-behavior").exists()).to.be.false;
+            expect(wrapper.find("#accordion-control-interop").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-component").exists()).to.be.true;
+            expect(wrapper.find("#accordion-control-workspace").exists()).to.be.false;
+            expect(wrapper.find("#persist-url").exists()).to.be.false;
+            expect(wrapper.find("#persist-path").exists()).to.be.false;
+        });
+    });
+    describe("Name", () => {
+        afterEach(() => {
+            sinon.restore();
+        });
+        it("should save correctly when edited", () => {
+            testSaveInputValue("name", "#app-name");
+        });
+        it("should display starting name in Name field, if name field is set", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            expect(wrapper.find("#app-name").first().prop("value")).to.equal("Test");
+        });
+        it("should not display starting name in Name field, if no name field is set", () => {
+            const wrapper = mount(React.createElement(EmptyPage, Object.assign({}, EmptyPage.args)));
+            expect(wrapper.find("#app-name").first().prop("value")).to.equal("");
+        });
+        it("should display Name as a valid field, even if the given name is duplicate", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            const appName = wrapper.find("#app-name").at(0);
+            appName.simulate("change", {
+                target: {
+                    value: "Used",
+                },
+            });
+            expect(wrapper.find("#app-name").at(0).prop("value")).to.equal("Used");
+            expect(!!wrapper.find("#app-name").at(0).prop("aria-invalid")).to.be.false;
+        });
+        it("should have a disabled Save button if the name field is emptied", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find("#app-name")
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find("button").last().prop("disabled")).to.be.true;
+        });
+        it("should click submit button when pressing enter on Name field", () => {
+            testSubmitOnEnter("#app-name");
+        });
+        it("should not click submit button when pressing a key other than enter on Name field", () => {
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find("#app-name")
+                .at(0)
+                .simulate("keydown", {
+                key: "a",
+                preventDefault: () => { },
+            });
+            expect(buttonSpy.calledOnce).to.be.false;
+        });
+        it("should not submit when pressing enter on Name field IF the submit button is disabled", () => {
+            const buttonSpy = sinon.spy(EmptyPage.args, "submitFn");
+            const wrapper = mount(React.createElement(EmptyPage, Object.assign({}, EmptyPage.args)));
+            wrapper
+                .find("#app-name")
+                .at(0)
+                .simulate("keydown", {
+                key: "Enter",
+                preventDefault: () => { },
+            });
+            expect(buttonSpy.calledOnce).to.be.false;
+        });
+    });
+    describe("Icon URL", () => {
+        const appDataKey = "iconURL";
+        const selector = "#app-icon-url";
+        const imageSelector = ".app-icon";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector);
+        });
+        it("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector);
+        });
+        it("should submit on enter", () => {
+            testSubmitOnEnter(selector);
+        });
+        it("should display icon when icon url is provided", () => {
+            const wrapper = mount(React.createElement(PageWithIconURL, Object.assign({}, PageWithIconURL.args)));
+            expect(wrapper.find(imageSelector).exists()).to.be.true;
+        });
+        it("should not display icon when no icon url is provided", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            expect(wrapper.find(imageSelector).exists()).to.be.false;
+        });
+        it("when icon url field is emptied, the icon should disappear", () => {
+            const wrapper = mount(React.createElement(PageWithIconURL, Object.assign({}, PageWithIconURL.args)));
+            wrapper.find(selector).simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find(imageSelector).exists()).to.be.false;
+        });
+        it("when icon url field gets a value, the icon should start displaying", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper.find(selector).simulate("change", {
+                target: {
+                    value: "https://assets.finsemble.com/components/fdc3-workbench/fdc3-icon-256.png",
+                },
+            });
+            expect(wrapper.find(imageSelector).exists()).to.be.true;
+        });
+    });
+    describe("API Access", () => {
+        afterEach(() => {
+            sinon.restore();
+        });
+        const name = "api-access";
+        const nativeParams = {
+            appType: "native",
+        };
+        const assimilationParams = {
+            appType: "assimilation",
+        };
+        it("should save correctly when edited: With API Access", () => {
+            const buttonSpy = sinon.spy(AssimilationPage.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, AssimilationPage.args)));
+            wrapper.find(`input[type='checkbox'][name='${name}']`).simulate("change");
+            const collection = wrapper.find("button");
+            const saveButton = collection.at(collection.length - 1);
+            saveButton.simulate("click");
+            const savedValue = buttonSpy.args[0][0];
+            for (let key in assimilationParams) {
+                // @ts-ignore
+                expect(savedValue[key]).to.equal(nativeParams[key]);
+            }
+        });
+        it("should save correctly when edited: Without API Access", () => {
+            const buttonSpy = sinon.spy(NativePage.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, NativePage.args)));
+            wrapper.find(`input[type='checkbox'][name='${name}']`).simulate("change");
+            const collection = wrapper.find("button");
+            const saveButton = collection.at(collection.length - 1);
+            saveButton.simulate("click");
+            const savedValue = buttonSpy.args[0][0];
+            for (let key in assimilationParams) {
+                // @ts-ignore
+                expect(savedValue[key]).to.equal(assimilationParams[key]);
+            }
+        });
+        it("should submit on enter", () => {
+            testSubmitOnEnter("[name='api-access']", NativePage);
+        });
+    });
+    describe("App URL", () => {
+        const appDataKey = "url";
+        const selector = "#app-url";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector);
+        });
+        it.skip("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector);
+        });
+        it("should submit on enter", () => {
+            testSubmitOnEnter(selector);
+        });
+        it("should have a disabled Save button if the App URL field is emptied", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find("#app-url")
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find("button").last().prop("disabled")).to.be.true;
+        });
+        it("should display invalid state for App URL if provided URL is invalid", () => {
+            const wrapper = mount(React.createElement(EmptyPage, Object.assign({}, EmptyPage.args)));
+            wrapper
+                .find("#app-url")
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "invalid",
+                },
+            });
+            expect(wrapper.find("#app-url").at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should click submit button when pressing enter on App URL field", () => {
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find("#app-url")
+                .at(0)
+                .simulate("keydown", {
+                key: "Enter",
+                preventDefault: () => { },
+            });
+            expect(buttonSpy.calledOnce).to.be.true;
+        });
+    });
+    describe.skip("File path", () => {
+        // Couldn't get tests for manipulating input[type=file] to work right
+        // should save correctly when edited
+        // should display pre-set values
+        // is required (enables/disables Save button when invalid)
+        // shows invalid state
+    });
+    describe("Arguments", () => {
+        const appDataKey = "appArguments";
+        const selector = "#app-arguments";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector, true);
+        });
+        it("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector, NativePage);
+        });
+        it("should submit on enter", () => {
+            testSubmitOnEnter(selector, NativePage);
+        });
+        it("is not required (Save button is enabled if empty)", () => {
+            const wrapper = mount(React.createElement(NativePage, Object.assign({}, NativePage.args)));
+            expect(wrapper.find(selector).prop("value")).to.be.empty;
+            const collection = wrapper.find("button");
+            const saveButton = collection.at(collection.length - 1);
+            expect(saveButton.prop("disabled")).to.be.false;
+        });
+    });
+    describe("Description", () => {
+        const appDataKey = "description";
+        const selector = "#app-description";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector);
+        });
+        it("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector);
+        });
+        it("is not required (Save button is enabled if empty)", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            expect(wrapper.find(selector).prop("value")).to.be.empty;
+            const collection = wrapper.find("button");
+            const saveButton = collection.at(collection.length - 1);
+            expect(saveButton.prop("disabled")).to.be.false;
+        });
+    });
+    describe("Select Connect", () => {
+        // @todo write test: should save correctly when edited (radio buttons and box) - issue with how <AppEditAccess /> is set up, so it always appears empty in tests
+        it("should display preset value (undefined rules)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { rules: undefined }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find("input[name='interop-trust'][value='true']").prop("checked"), "Radio button 'trust all apps' is checked").to.be.true;
+            expect(wrapper.find(".app-edit-access").exists(), "Display SelectConnect listbox").to.be.false;
+        });
+        it("should display preset value (empty rules)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { rules: [] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find("input[name='interop-trust'][value='true']").prop("checked"), "Radio button 'trust all apps' is checked").to.be.true;
+            expect(wrapper.find(".app-edit-access").exists(), "Display SelectConnect listbox").to.be.false;
+        });
+        it("should display preset value (rules without authorize)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { rules: [
+                        { contextType: "fdc3.instrument", cc: "#Workspace" },
+                        { contextType: "layout", fwd: "#Workspace" },
+                    ] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find("input[name='interop-trust'][value='true']").prop("checked"), "Radio button 'trust all apps' is checked").to.be.true;
+            expect(wrapper.find(".app-edit-access").exists(), "Display SelectConnect listbox").to.be.false;
+        });
+        it("should display preset value (rules with authorize)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { rules: [{ authorize: [{ name: "ChartIQ Example App" }] }] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find("input[name='interop-trust'][value='false']").prop("checked"), "Radio button 'trust selected apps' is checked").to.be.true;
+            expect(wrapper.find(".app-edit-access").exists(), "Display SelectConnect listbox").to.be.true;
+            // AppEditAccess is tested independently (and can't be tested on this level because it comes up as empty because it doesn't have a list of apps)
+        });
+        it("should display preset value (rules with empty authorize)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { rules: [{ authorize: [] }] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find("input[name='interop-trust'][value='false']").prop("checked"), "Radio button 'trust selected apps' is checked").to.be.true;
+            expect(wrapper.find(".app-edit-access").exists(), "Display SelectConnect listbox").to.be.true;
+            // AppEditAccess is tested independently
+        });
+        it.skip("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons("interop-trust", 2);
+        });
+    });
+    describe("Width", () => {
+        const appDataKey = "width";
+        const selector = "#app-width";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector, false, 200);
+        });
+        it("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector, Page, "200");
+        });
+        it("should display invalid state for width if provided a negative number", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "-999",
+                },
+            });
+            expect(wrapper.find(selector).at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should display invalid state for width if provided an empty value", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find(selector).at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should display invalid state for non-numeric value", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "abc",
+                },
+            });
+            expect(wrapper.find(selector).at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should have a disabled Save button if the width field is emptied", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find("button").last().prop("disabled")).to.be.true;
+        });
+        it("should have a disabled Save button if the width field is negative", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "-999",
+                },
+            });
+            expect(wrapper.find("button").last().prop("disabled")).to.be.true;
+        });
+    });
+    describe("Height", () => {
+        const appDataKey = "height";
+        const selector = "#app-height";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector, false, 200);
+        });
+        it("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector, Page, "200");
+        });
+        it("should display invalid state for width if provided a negative number", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "-999",
+                },
+            });
+            expect(wrapper.find(selector).at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should display invalid state for width if provided an empty value", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find(selector).at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should display invalid state for non-numeric value", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "abc",
+                },
+            });
+            expect(wrapper.find("#app-height").at(0).prop("aria-invalid")).to.be.true;
+        });
+        it("should have a disabled Save button if the height field is emptied", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "",
+                },
+            });
+            expect(wrapper.find("button").last().prop("disabled")).to.be.true;
+        });
+        it("should have a disabled Save button if the height field is negative", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(selector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "-999",
+                },
+            });
+            expect(wrapper.find("button").last().prop("disabled")).to.be.true;
+        });
+    });
+    describe("Lock dimensions", () => {
+        const label = "Lock dimensions";
+        const appDataKey = "resizable";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, false);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Position", () => {
+        it("should save correctly when edited", () => {
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper.find(".position-entry [role='combobox']").simulate("click");
+            wrapper.find(".position-entry .finsemble-dropdown__btn-option").at(4).simulate("click");
+            const collection = wrapper.find("button");
+            collection.at(collection.length - 1).simulate("click");
+            expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign({}, defaults), { abstractPosition: 4 }));
+        });
+        it("should display pre-set values", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { abstractPosition: 5 }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find(".position-entry .finsemble-dropdown__btn-label").text()).to.equal("Center");
+        });
+    });
+    describe("Opacity", () => {
+        const appDataKey = "opacity";
+        const rangeSelector = ".app-edit-range";
+        const inputSelector = "#app-opacity";
+        it("should display correctly when preset (input range)", () => {
+            testPresetInputValue(appDataKey, rangeSelector, Page, "30");
+        });
+        it("should display correctly when preset (input field)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { [appDataKey]: 0.3 }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find(inputSelector).prop("value")).to.equal(30);
+        });
+        it("should save correctly when edited (input range)", () => {
+            testSaveInputValue(appDataKey, rangeSelector, false, 30);
+        });
+        it("should save correctly when edited (input field) - value saved is 1/100 of what is entered", () => {
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(inputSelector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: 30,
+                },
+            });
+            const collection = wrapper.find("button");
+            collection.at(collection.length - 1).simulate("click");
+            expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign({}, defaults), { [appDataKey]: 0.3 }));
+        });
+        it("When editing the range field, the text box updates", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(inputSelector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: 70,
+                },
+            });
+            expect(wrapper.find(rangeSelector).prop("value")).to.equal(0.7);
+        });
+        it("When editing the text box, the range field updates", () => {
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(rangeSelector)
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: 0.7,
+                },
+            });
+            expect(wrapper.find(inputSelector).prop("value")).to.equal(70);
+        });
+    });
+    describe("Auto arrange", () => {
+        const label = "Auto arrange";
+        const appDataKey = "allowAutoArrange";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Grouping", () => {
+        const label = "Grouping";
+        const appDataKey = "allowGrouping";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Snapping", () => {
+        const label = "Snapping";
+        const appDataKey = "allowSnapping";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Tabs", () => {
+        const label = "Tabs";
+        const appDataKey = "allowTabbing";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Tiling", () => {
+        const label = "Tiling";
+        const appDataKey = "allowTiling";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Enable title bar", () => {
+        const label = "Enable title bar";
+        const appDataKey = "enableTitleBar";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Always on top", () => {
+        const name = "alwaysOnTop";
+        const enableParams = {
+            alwaysOnTop: true,
+            enableAOT: false,
+        };
+        const showParams = {
+            alwaysOnTop: false,
+            enableAOT: true,
+        };
+        const disableParams = {
+            alwaysOnTop: false,
+            enableAOT: false,
+        };
+        it("should display correctly when preset: Enable", () => {
+            presetRadioButtons(name, enableParams, [true, false, false]);
+        });
+        it("should display correctly when preset: Show in titlebar", () => {
+            presetRadioButtons(name, showParams, [false, true, false]);
+        });
+        it("should display correctly when preset: Disable", () => {
+            presetRadioButtons(name, disableParams, [false, false, true]);
+        });
+        it("should save correctly when edited: Enable", () => {
+            saveRadioButton(name, 0, enableParams);
+        });
+        it("should save correctly when edited: Show in titlebar", () => {
+            saveRadioButton(name, 1, showParams);
+        });
+        it("should save correctly when edited: Disable", () => {
+            saveRadioButton(name, 2, disableParams);
+        });
+        it("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons(name, 3);
+        });
+    });
+    describe("Minimize", () => {
+        const name = "minimize";
+        const enableParams = {
+            allowMinimize: true,
+            hideMinimize: false,
+        };
+        const hideParams = {
+            allowMinimize: true,
+            hideMinimize: true,
+        };
+        const disableParams = {
+            allowMinimize: false,
+            hideMinimize: true,
+        };
+        it("should display correctly when preset: Enable", () => {
+            presetRadioButtons(name, enableParams, [true, false, false]);
+        });
+        it("should display correctly when preset: Hide from titlebar", () => {
+            presetRadioButtons(name, hideParams, [false, true, false]);
+        });
+        it("should display correctly when preset: Disable", () => {
+            presetRadioButtons(name, disableParams, [false, false, true]);
+        });
+        it("should save correctly when edited: Enable", () => {
+            saveRadioButton(name, 0, enableParams);
+        });
+        it("should save correctly when edited: Hide from titlebar", () => {
+            saveRadioButton(name, 1, hideParams);
+        });
+        it("should save correctly when edited: Disable", () => {
+            saveRadioButton(name, 2, disableParams);
+        });
+        it("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons(name, 3);
+        });
+    });
+    describe("Maximize", () => {
+        const name = "maximize";
+        const enableParams = {
+            allowMaximize: true,
+            hideMaximize: false,
+        };
+        const hideParams = {
+            allowMaximize: true,
+            hideMaximize: true,
+        };
+        const disableParams = {
+            allowMaximize: false,
+            hideMaximize: true,
+        };
+        it("should display correctly when preset: Enable", () => {
+            presetRadioButtons(name, enableParams, [true, false, false]);
+        });
+        it("should display correctly when preset: Hide from titlebar", () => {
+            presetRadioButtons(name, hideParams, [false, true, false]);
+        });
+        it("should display correctly when preset: Disable", () => {
+            presetRadioButtons(name, disableParams, [false, false, true]);
+        });
+        it("should save correctly when edited: Enable", () => {
+            saveRadioButton(name, 0, enableParams);
+        });
+        it("should save correctly when edited: Hide from titlebar", () => {
+            saveRadioButton(name, 1, hideParams);
+        });
+        it("should save correctly when edited: Disable", () => {
+            saveRadioButton(name, 2, disableParams);
+        });
+        it("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons(name, 3);
+        });
+    });
+    describe("Close", () => {
+        const name = "close";
+        const enableParams = {
+            hideClose: false,
+        };
+        const disableParams = {
+            hideClose: true,
+        };
+        it("should display correctly when preset: Enable", () => {
+            presetRadioButtons(name, enableParams, [true, false]);
+        });
+        it("should display correctly when preset: Disable", () => {
+            presetRadioButtons(name, disableParams, [false, true]);
+        });
+        it("should save correctly when edited: Enable", () => {
+            saveRadioButton(name, 0, enableParams);
+        });
+        it("should save correctly when edited: Disable", () => {
+            saveRadioButton(name, 1, disableParams);
+        });
+        it("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons(name, 2);
+        });
+    });
+    describe("Display linker", () => {
+        const name = "linker";
+        const enableParams = {
+            autoConnect: true,
+        };
+        const disableParams = {
+            autoConnect: false,
+        };
+        it("should display correctly when preset: Always", () => {
+            presetRadioButtons(name, enableParams, [true, false]);
+        });
+        it("should display correctly when preset: FDC3 API use", () => {
+            presetRadioButtons(name, disableParams, [false, true]);
+        });
+        it("should save correctly when edited: Always", () => {
+            saveRadioButton(name, 0, enableParams);
+        });
+        it("should save correctly when edited: FDC3 API use", () => {
+            saveRadioButton(name, 1, disableParams);
+        });
+        it("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons(name, 2);
+        });
+    });
+    describe("Intents", () => {
+        it("should save correctly when edited (adding an intent)", () => {
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(".inputTable input")
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "ViewChart",
+                },
+            });
+            wrapper
+                .find(".inputTable input")
+                .at(1)
+                .simulate("change", {
+                target: {
+                    value: "View Chart",
+                },
+            });
+            wrapper
+                .find(".inputTable input")
+                .at(2)
+                .simulate("change", {
+                target: {
+                    value: "fdc3.instrument",
+                },
+            });
+            const collection = wrapper.find("button");
+            collection.at(collection.length - 1).simulate("click");
+            expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign({}, defaults), { intents: [{ name: "ViewChart", displayName: "View Chart", contexts: ["fdc3.instrument"] }] }));
+        });
+        it("should save correctly when edited (adding just an intent name)", () => {
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const wrapper = mount(React.createElement(Page, Object.assign({}, Page.args)));
+            wrapper
+                .find(".inputTable input")
+                .at(0)
+                .simulate("change", {
+                target: {
+                    value: "ViewChart",
+                },
+            });
+            const collection = wrapper.find("button");
+            collection.at(collection.length - 1).simulate("click");
+            expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign({}, defaults), { intents: [{ name: "ViewChart", displayName: "", contexts: [""] }] }));
+        });
+        it("should save correctly when edited (removing an intent)", () => {
+            var _a;
+            const buttonSpy = sinon.spy(Page.args, "submitFn");
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { intents: [{ name: "ViewChart", displayName: "View Chart", contexts: ["fdc3.instrument"] }] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            wrapper.find(".inputTable button[title='Remove row']").at(0).simulate("click");
+            const collection = wrapper.find("button");
+            collection.at(collection.length - 1).simulate("click");
+            expect(buttonSpy.args[0][0]).to.deep.equal(Object.assign(Object.assign({}, defaults), { intents: [] }));
+        });
+        it("should display preset values (empty list of intents)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { intents: [] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find(".inputTable tr"), "List of rows").to.be.lengthOf(2);
+            expect(wrapper.find(".inputTable input").at(0).prop("value"), "Intent table, input field 1").to.be.empty;
+            expect(wrapper.find(".inputTable input").at(1).prop("value"), "Intent table, input field 2").to.be.empty;
+            expect(wrapper.find(".inputTable input").at(2).prop("value"), "Intent table, input field 3").to.be.empty;
+        });
+        it("should display preset values (with 1 intent)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { intents: [{ name: "ViewChart", displayName: "View Chart", contexts: ["fdc3.instrument"] }] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find(".inputTable tr"), "List of rows").to.be.lengthOf(3);
+            expect(wrapper.find(".inputTable input").at(0).prop("value"), "Intent table, input field 1").to.equal("ViewChart");
+            expect(wrapper.find(".inputTable input").at(1).prop("value"), "Intent table, input field 2").to.equal("View Chart");
+            expect(wrapper.find(".inputTable input").at(2).prop("value"), "Intent table, input field 3").to.equal("fdc3.instrument");
+            expect(wrapper.find(".inputTable input").at(3).prop("value"), "Intent table, input field 4").to.be.empty;
+            expect(wrapper.find(".inputTable input").at(4).prop("value"), "Intent table, input field 5").to.be.empty;
+            expect(wrapper.find(".inputTable input").at(5).prop("value"), "Intent table, input field 6").to.be.empty;
+        });
+        it("should display preset values (multiple contexts for an intent)", () => {
+            var _a;
+            const args = Object.assign(Object.assign({}, Page.args), { appData: Object.assign(Object.assign({}, (_a = Page.args) === null || _a === void 0 ? void 0 : _a.appData), { intents: [{ name: "ViewChart", displayName: "View Chart", contexts: ["fdc3.instrument", "custom.symbol"] }] }) });
+            const wrapper = mount(React.createElement(Page, Object.assign({}, args)));
+            expect(wrapper.find(".inputTable tr"), "List of rows").to.be.lengthOf(3);
+            expect(wrapper.find(".inputTable input").at(0).prop("value"), "Intent table, input field 1").to.equal("ViewChart");
+            expect(wrapper.find(".inputTable input").at(1).prop("value"), "Intent table, input field 2").to.equal("View Chart");
+            expect(wrapper.find(".inputTable input").at(2).prop("value"), "Intent table, input field 3").to.equal("fdc3.instrument, custom.symbol");
+        });
+    });
+    describe("Set security", () => {
+        const name = "security";
+        const enableParams = {
+            security: "trusted",
+        };
+        const disableParams = {
+            security: "untrusted",
+        };
+        it("should display correctly when preset: Trusted", () => {
+            presetRadioButtons(name, enableParams, [true, false]);
+        });
+        it("should display correctly when preset: Untrusted", () => {
+            presetRadioButtons(name, disableParams, [false, true]);
+        });
+        it("should save correctly when edited: Trusted", () => {
+            saveRadioButton(name, 0, enableParams);
+        });
+        it.skip("should save correctly when edited: Untrusted", () => {
+            saveRadioButton(name, 1, disableParams);
+        });
+        it.skip("confirm that the radio buttons stay independent", () => {
+            checkUniqueRadioButtons(name, 2);
+        });
+    });
+    describe("Launch timeout", () => {
+        const appDataKey = "native_windowSpawnTimeout";
+        const selector = "#launch-timeout";
+        it("should save correctly when edited", () => {
+            testSaveInputValue(appDataKey, selector, true, 200);
+        });
+        it("should display pre-set values", () => {
+            testPresetInputValue(appDataKey, selector, NativePage, "200");
+        });
+    });
+    describe("Only one instance", () => {
+        const label = "Only one instance";
+        const appDataKey = "singleton";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Launch at startup", () => {
+        const label = "Launch at startup";
+        const appDataKey = "spawnOnStartup";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Include in Apps menu", () => {
+        const label = "Include in Apps menu";
+        const appDataKey = "launchableByUser";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Persist across workspaces", () => {
+        const label = "Persist across workspaces";
+        const appDataKey = "isEvergreen";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Add to workspaces", () => {
+        const label = "Add to workspace";
+        const appDataKey = "addToWorkspace";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+    describe("Persist the location", () => {
+        const label = "Persist the URL";
+        const appDataKey = "persistURL";
+        it("should display pre-set value: checked", () => {
+            presetCheckbox(appDataKey, label, true, true);
+        });
+        it("should display pre-set value: not checked", () => {
+            presetCheckbox(appDataKey, label, false, false);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, true);
+        });
+        it("should save correctly (change to true)", () => {
+            flipCheckbox(appDataKey, label, false);
+        });
+    });
+});
+//# sourceMappingURL=AppEditPage.spec.js.map