@gravitee/ui-policy-studio-angular 9.6.0 → 10.0.0

package/esm2022/testing/lib/components/flows-menu/gio-ps-flows-menu.harness.mjs

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentHarness, parallel } from '@angular/cdk/testing';
+import { MatButtonHarness } from '@angular/material/button/testing';
+import { MatIconHarness } from '@angular/material/icon/testing';
+import { DivHarness } from '@gravitee/ui-particles-angular/testing';
+export class GioPolicyStudioFlowsMenuHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this.locateFlowsGroups = this.locatorForAll(DivHarness.with({ selector: '.list__flowsGroup' }));
+        this.locateFlowByText = (text) => this.locatorForOptional(DivHarness.with({ selector: '.list__flowsGroup__flow', text }));
+        this.locateGroupByText = (text) => this.locatorForOptional(DivHarness.with({ selector: '.list__flowsGroup', text }));
+        this.locateSelectedFlow = this.locatorForOptional(DivHarness.with({ selector: '.list__flowsGroup__flow.selected' }));
+    }
+    static { this.hostSelector = 'gio-ps-flows-menu'; }
+    async getAllFlowsGroups() {
+        const flowsGroups = await this.locateFlowsGroups();
+        return parallel(() => flowsGroups.map(async (flowsGroup) => {
+            const flowsGroupName = await flowsGroup.getText({ childSelector: '.list__flowsGroup__header__label' });
+            const flowsDiv = await flowsGroup.childLocatorForAll(DivHarness.with({ selector: '.list__flowsGroup__flow' }))();
+            const flowsInfos = parallel(() => flowsDiv.map(async (flowDiv) => {
+                return {
+                    name: await flowDiv.getText({ childSelector: '.list__flowsGroup__flow__name' }),
+                    infos: await flowDiv.getText({ childSelector: '.list__flowsGroup__flow__infos' }),
+                    isSelected: await flowDiv.host().then(host => host.hasClass('selected')),
+                    hasCondition: !!(await flowDiv.childLocatorFor(MatIconHarness.with({ name: 'gio:if' }))),
+                };
+            }));
+            return {
+                name: flowsGroupName,
+                flows: await flowsInfos,
+            };
+        }));
+    }
+    async getSelectedFlow() {
+        const selectedFlow = await this.locateSelectedFlow();
+        return selectedFlow ? { name: await selectedFlow.getText({ childSelector: '.list__flowsGroup__flow__name' }) } : null;
+    }
+    /**
+     * Select a flow by it's text content
+     */
+    async selectFlow(flowText) {
+        const flowsGroups = await this.locateFlowByText(flowText)();
+        if (flowsGroups) {
+            await flowsGroups.host().then(host => host.click());
+        }
+    }
+    async addFlow(groupName) {
+        const flowsGroups = await this.locateGroupByText(groupName)();
+        if (flowsGroups) {
+            await (await flowsGroups.childLocatorFor(MatButtonHarness.with({ ancestor: '.list__flowsGroup__header__addBtn' }))()).click();
+        }
+    }
+    async openFlowExecutionConfig() {
+        await (await this.locatorFor(MatButtonHarness.with({ selector: '.header__configBtn_edit' }))())?.click();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gio-ps-flows-menu.harness.js","sourceRoot":"","sources":["../../../../../../../projects/ui-policy-studio-angular/src/lib/components/flows-menu/gio-ps-flows-menu.harness.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2022 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ComponentHarness, parallel } from '@angular/cdk/testing';\nimport { MatButtonHarness } from '@angular/material/button/testing';\nimport { MatIconHarness } from '@angular/material/icon/testing';\nimport { DivHarness } from '@gravitee/ui-particles-angular/testing';\n\nexport class GioPolicyStudioFlowsMenuHarness extends ComponentHarness {\n  public static hostSelector = 'gio-ps-flows-menu';\n\n  private locateFlowsGroups = this.locatorForAll(DivHarness.with({ selector: '.list__flowsGroup' }));\n  private locateFlowByText = (text: string | RegExp) =>\n    this.locatorForOptional(DivHarness.with({ selector: '.list__flowsGroup__flow', text }));\n\n  public locateGroupByText = (text: string | RegExp) => this.locatorForOptional(DivHarness.with({ selector: '.list__flowsGroup', text }));\n\n  private locateSelectedFlow = this.locatorForOptional(DivHarness.with({ selector: '.list__flowsGroup__flow.selected' }));\n\n  public async getAllFlowsGroups(): Promise<\n    {\n      name: string | null;\n      flows: {\n        name: string | null;\n        isSelected: boolean;\n        infos: string | null;\n        hasCondition: boolean;\n      }[];\n    }[]\n  > {\n    const flowsGroups = await this.locateFlowsGroups();\n\n    return parallel(() =>\n      flowsGroups.map(async flowsGroup => {\n        const flowsGroupName = await flowsGroup.getText({ childSelector: '.list__flowsGroup__header__label' });\n\n        const flowsDiv = await flowsGroup.childLocatorForAll(DivHarness.with({ selector: '.list__flowsGroup__flow' }))();\n\n        const flowsInfos = parallel(() =>\n          flowsDiv.map(async flowDiv => {\n            return {\n              name: await flowDiv.getText({ childSelector: '.list__flowsGroup__flow__name' }),\n              infos: await flowDiv.getText({ childSelector: '.list__flowsGroup__flow__infos' }),\n              isSelected: await flowDiv.host().then(host => host.hasClass('selected')),\n              hasCondition: !!(await flowDiv.childLocatorFor(MatIconHarness.with({ name: 'gio:if' }))),\n            };\n          }),\n        );\n\n        return {\n          name: flowsGroupName,\n          flows: await flowsInfos,\n        };\n      }),\n    );\n  }\n\n  public async getSelectedFlow(): Promise<{ name: string | null } | null> {\n    const selectedFlow = await this.locateSelectedFlow();\n\n    return selectedFlow ? { name: await selectedFlow.getText({ childSelector: '.list__flowsGroup__flow__name' }) } : null;\n  }\n\n  /**\n   * Select a flow by it's text content\n   */\n  public async selectFlow(flowText: string | RegExp): Promise<void> {\n    const flowsGroups = await this.locateFlowByText(flowText)();\n\n    if (flowsGroups) {\n      await flowsGroups.host().then(host => host.click());\n    }\n  }\n\n  public async addFlow(groupName: string | RegExp): Promise<void> {\n    const flowsGroups = await this.locateGroupByText(groupName)();\n\n    if (flowsGroups) {\n      await (await flowsGroups.childLocatorFor(MatButtonHarness.with({ ancestor: '.list__flowsGroup__header__addBtn' }))()).click();\n    }\n  }\n\n  public async openFlowExecutionConfig(): Promise<void> {\n    await (await this.locatorFor(MatButtonHarness.with({ selector: '.header__configBtn_edit' }))())?.click();\n  }\n}\n"]}

package/esm2022/testing/lib/components/policies-catalog-dialog/gio-ps-policies-catalog-dialog.harness.mjs

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentHarness, parallel } from '@angular/cdk/testing';
+import { MatButtonHarness } from '@angular/material/button/testing';
+import { DivHarness } from '@gravitee/ui-particles-angular/testing';
+import { MatChipListboxHarness } from '@angular/material/chips/testing';
+import { MatInputHarness } from '@angular/material/input/testing';
+import { GioPolicyStudioStepFormHarness } from '../step-form/gio-ps-step-form.harness';
+export class GioPolicyStudioPoliciesCatalogDialogHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this.policiesLocator = this.locatorForAll(DivHarness.with({ selector: '.policiesCatalog__list__policy' }));
+        this.getCategoriesFilter = this.locatorForOptional(MatChipListboxHarness.with({ selector: '[formControlName="categories"]' }));
+    }
+    static { this.hostSelector = 'gio-ps-policies-catalog-dialog'; }
+    async getPhase() {
+        const phase = await this.locatorFor('.title__phase')();
+        return phase.text();
+    }
+    async getPoliciesName() {
+        const policies = await this.locatorForAll('.policiesCatalog__list__policy__head__name')();
+        return parallel(() => policies.map(policy => policy.text()));
+    }
+    async selectPolicy(policyName) {
+        const policies = await this.policiesLocator();
+        for (const policy of policies) {
+            const name = await policy.getText({ childSelector: '.policiesCatalog__list__policy__head__name' });
+            if (name === policyName) {
+                const selectBtn = await policy.childLocatorFor(MatButtonHarness.with({ selector: '.policiesCatalog__list__policy__selectBtn' }))();
+                await selectBtn.click();
+                return;
+            }
+        }
+        throw new Error(`Policy ${policyName} not found`);
+    }
+    async getSelectedPolicyName() {
+        const policy = await this.locatorFor('.policyForm__info__head__name')();
+        return policy.text();
+    }
+    async hasRequestUpgradeButton() {
+        const requestUpgradeButton = await this.locatorForOptional(MatButtonHarness.with({ text: 'Request upgrade' }))();
+        return !!requestUpgradeButton;
+    }
+    async clickAddPolicyButton() {
+        const addBtn = await this.locatorFor(MatButtonHarness.with({ selector: '.actions__addBtn' }))();
+        await addBtn.click();
+    }
+    async getStepForm() {
+        return await this.locatorFor(GioPolicyStudioStepFormHarness)();
+    }
+    async getCategoriesSelection() {
+        const chipList = await this.getCategoriesFilter();
+        if (!chipList) {
+            return [];
+        }
+        const chips = await chipList.getChips();
+        return parallel(() => chips.map(async (chip) => {
+            const selected = await chip.isSelected();
+            const name = await chip.getText();
+            return { name, selected };
+        }));
+    }
+    async selectCategoryFilter(categoryName) {
+        const chipList = await this.getCategoriesFilter();
+        await chipList?.selectChips({ text: categoryName });
+    }
+    async searchFilter(search) {
+        const searchInput = await this.locatorFor(MatInputHarness.with({ selector: '[formControlName="search"]' }))();
+        if (searchInput) {
+            await searchInput.setValue(search);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gio-ps-policies-catalog-dialog.harness.js","sourceRoot":"","sources":["../../../../../../../projects/ui-policy-studio-angular/src/lib/components/policies-catalog-dialog/gio-ps-policies-catalog-dialog.harness.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2022 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ComponentHarness, parallel } from '@angular/cdk/testing';\nimport { MatButtonHarness } from '@angular/material/button/testing';\nimport { DivHarness } from '@gravitee/ui-particles-angular/testing';\nimport { MatChipListboxHarness, MatChipOptionHarness } from '@angular/material/chips/testing';\nimport { MatInputHarness } from '@angular/material/input/testing';\n\nimport { GioPolicyStudioStepFormHarness } from '../step-form/gio-ps-step-form.harness';\n\nexport class GioPolicyStudioPoliciesCatalogDialogHarness extends ComponentHarness {\n  public static hostSelector = 'gio-ps-policies-catalog-dialog';\n\n  private policiesLocator = this.locatorForAll(DivHarness.with({ selector: '.policiesCatalog__list__policy' }));\n\n  private getCategoriesFilter = this.locatorForOptional(MatChipListboxHarness.with({ selector: '[formControlName=\"categories\"]' }));\n  public async getPhase(): Promise<string> {\n    const phase = await this.locatorFor('.title__phase')();\n    return phase.text();\n  }\n\n  public async getPoliciesName(): Promise<string[]> {\n    const policies = await this.locatorForAll('.policiesCatalog__list__policy__head__name')();\n    return parallel(() => policies.map(policy => policy.text()));\n  }\n\n  public async selectPolicy(policyName: string): Promise<void> {\n    const policies = await this.policiesLocator();\n    for (const policy of policies) {\n      const name = await policy.getText({ childSelector: '.policiesCatalog__list__policy__head__name' });\n      if (name === policyName) {\n        const selectBtn = await policy.childLocatorFor(MatButtonHarness.with({ selector: '.policiesCatalog__list__policy__selectBtn' }))();\n        await selectBtn.click();\n        return;\n      }\n    }\n    throw new Error(`Policy ${policyName} not found`);\n  }\n\n  public async getSelectedPolicyName(): Promise<string> {\n    const policy = await this.locatorFor('.policyForm__info__head__name')();\n    return policy.text();\n  }\n\n  public async hasRequestUpgradeButton(): Promise<boolean> {\n    const requestUpgradeButton = await this.locatorForOptional(MatButtonHarness.with({ text: 'Request upgrade' }))();\n    return !!requestUpgradeButton;\n  }\n\n  public async clickAddPolicyButton(): Promise<void> {\n    const addBtn = await this.locatorFor(MatButtonHarness.with({ selector: '.actions__addBtn' }))();\n    await addBtn.click();\n  }\n\n  public async getStepForm(): Promise<GioPolicyStudioStepFormHarness> {\n    return await this.locatorFor(GioPolicyStudioStepFormHarness)();\n  }\n\n  public async getCategoriesSelection(): Promise<{ name: string; selected: boolean }[]> {\n    const chipList = await this.getCategoriesFilter();\n    if (!chipList) {\n      return [];\n    }\n\n    const chips: MatChipOptionHarness[] = await chipList.getChips();\n\n    return parallel(() =>\n      chips.map(async chip => {\n        const selected = await chip.isSelected();\n        const name = await chip.getText();\n        return { name, selected };\n      }),\n    );\n  }\n\n  public async selectCategoryFilter(categoryName: string): Promise<void> {\n    const chipList = await this.getCategoriesFilter();\n    await chipList?.selectChips({ text: categoryName });\n  }\n\n  public async searchFilter(search: string): Promise<void> {\n    const searchInput = await this.locatorFor(MatInputHarness.with({ selector: '[formControlName=\"search\"]' }))();\n    if (searchInput) {\n      await searchInput.setValue(search);\n    }\n  }\n}\n"]}

package/{esm2020 → esm2022}/testing/lib/components/step-edit-dialog/gio-ps-step-edit-dialog.harness.mjs

@@ -16,6 +16,7 @@
 import { ComponentHarness } from '@angular/cdk/testing';
 import { GioPolicyStudioStepFormHarness } from '../step-form/gio-ps-step-form.harness';
 export class GioPolicyStudioStepEditDialogHarness extends ComponentHarness {
+    static { this.hostSelector = 'gio-ps-step-edit-dialog'; }
     async getPolicyName() {
         return (await this.locatorFor('.title__name')()).text();
     }
@@ -26,5 +27,4 @@ export class GioPolicyStudioStepEditDialogHarness extends ComponentHarness {
         return (await this.locatorFor('.actions__saveBtn')()).click();
     }
 }
-GioPolicyStudioStepEditDialogHarness.hostSelector = 'gio-ps-step-edit-dialog';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/lib/components/step-form/gio-ps-step-form.harness.mjs

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentHarness } from '@angular/cdk/testing';
+import { MatInputHarness } from '@angular/material/input/testing';
+export class GioPolicyStudioStepFormHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this.getDescriptionInput = this.locatorFor(MatInputHarness.with({ selector: '[formControlName="description"]' }));
+        this.getConditionInput = this.locatorFor(MatInputHarness.with({ selector: '[formControlName="condition"]' }));
+    }
+    static { this.hostSelector = 'gio-ps-step-form'; }
+    async setStepForm(stepForm) {
+        if (stepForm.description) {
+            const descriptionInput = await this.getDescriptionInput();
+            await descriptionInput.setValue(stepForm.description);
+        }
+        if (stepForm.condition) {
+            const conditionInput = await this.getConditionInput();
+            await conditionInput.setValue(stepForm.condition);
+        }
+        if (stepForm.waitForPolicyFormCompletionCb) {
+            await stepForm.waitForPolicyFormCompletionCb(this.locatorFactory);
+        }
+    }
+    async getStepFormValue() {
+        const descriptionInput = await this.getDescriptionInput();
+        return {
+            description: await descriptionInput.getValue(),
+        };
+    }
+    async getDocumentation() {
+        const documentation = await this.locatorFor('.documentation__content > gio-asciidoctor')();
+        return documentation.getAttribute('ng-reflect-content');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/lib/gio-policy-studio.harness.mjs

@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentHarness } from '@angular/cdk/testing';
+import { MatButtonHarness } from '@angular/material/button/testing';
+import { MatTabGroupHarness } from '@angular/material/tabs/testing';
+import { GioPolicyStudioFlowsMenuHarness } from './components/flows-menu/gio-ps-flows-menu.harness';
+import { GioPolicyStudioDetailsHarness } from './components/flow-details/gio-ps-flow-details.harness';
+import { GioPolicyStudioFlowProxyFormDialogHarness } from './components/flow-form-dialog/flow-proxy-form-dialog/gio-ps-flow-proxy-form-dialog.harness';
+import { GioPolicyStudioFlowMessageFormDialogHarness } from './components/flow-form-dialog/flow-message-form-dialog/gio-ps-flow-message-form-dialog.harness';
+import { GioPolicyStudioFlowExecutionFormDialogHarness } from './components/flow-execution-form-dialog/gio-ps-flow-execution-form-dialog.harness';
+import { GioPolicyStudioDetailsPhaseHarness } from './components/flow-details-phase/gio-ps-flow-details-phase.harness';
+export class GioPolicyStudioHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this.menuHarness = this.locatorFor(GioPolicyStudioFlowsMenuHarness);
+        this.detailsHarness = this.locatorFor(GioPolicyStudioDetailsHarness);
+        this.phaseHarness = (phaseType) => this.locatorFor(GioPolicyStudioDetailsPhaseHarness.with({ type: phaseType }))();
+    }
+    static { this.hostSelector = 'gio-policy-studio'; }
+    /**
+     * Add a flow to a plan or to "Common flows"
+     *
+     * @param groupName Plan name where to add the flow. You also can define "Common flows" to add a flow to this group.
+     * @param flow Flow to add
+     */
+    async addFlow(groupName, flow) {
+        await (await this.menuHarness()).addFlow(new RegExp(groupName, 'i'));
+        await this.setFlowFormDialog(flow);
+    }
+    /**
+     * Edit a flow configuration
+     *
+     * @param flowName Flow name to edit
+     * @param flow
+     */
+    async editFlowConfig(flowName, flow) {
+        (await this.menuHarness()).selectFlow(new RegExp(flowName, 'i'));
+        await (await this.detailsHarness()).clickEditFlowBtn();
+        await this.setFlowFormDialog(flow);
+    }
+    /**
+     * Delete a flow
+     *
+     * @param flowName Flow name to delete
+     */
+    async deleteFlow(flowName) {
+        (await this.menuHarness()).selectFlow(new RegExp(flowName, 'i'));
+        await (await this.detailsHarness()).clickDeleteFlowBtn();
+    }
+    /**
+     * Select a flow in the menu
+     *
+     * @param flowName Flow name to select
+     */
+    async selectFlowInMenu(flowName) {
+        await (await this.menuHarness()).selectFlow(new RegExp(flowName, 'i'));
+    }
+    /**
+     * Get the list of flows in the menu
+     */
+    async getFlowsMenu() {
+        return (await this.menuHarness()).getAllFlowsGroups();
+    }
+    /**
+     * Get selected flow infos
+     */
+    async getSelectedFlowInfos() {
+        return await (await this.detailsHarness()).getFlowInfos();
+    }
+    /**
+     * Get selected flow phase harness
+     * @param phaseType Phase type to get
+     */
+    async getSelectedFlowPhase(phaseType) {
+        if (phaseType === 'PUBLISH' || phaseType === 'SUBSCRIBE') {
+            const matTabsHarness = await this.locatorFor(MatTabGroupHarness.with({ selector: '.content__tabs' }))();
+            await matTabsHarness.selectTab({ label: 'Event messages' });
+        }
+        const steps = await this.phaseHarness(phaseType);
+        return steps ? steps : undefined;
+    }
+    /**
+     * Get Save button state
+     */
+    async getSaveButtonState() {
+        const saveButton = await this.locatorFor(MatButtonHarness.with({ ancestor: '.header__btn' }))();
+        const disabled = await saveButton.isDisabled();
+        const text = await saveButton.getText();
+        if (text === 'Saving...') {
+            return 'SAVING';
+        }
+        if (disabled) {
+            return 'DISABLED';
+        }
+        return 'VISIBLE';
+    }
+    /**
+     * Click on the "Save" button
+     */
+    async save() {
+        await (await this.locatorFor(MatButtonHarness.with({ text: /Save/ }))()).click();
+    }
+    async setFlowFormDialog(flow) {
+        const channelSelector = flow.selectors?.find(s => s.type === 'CHANNEL');
+        const httpSelector = flow.selectors?.find(s => s.type === 'HTTP');
+        const conditionSelector = flow.selectors?.find(s => s.type === 'CONDITION');
+        if (!!channelSelector && !!httpSelector) {
+            throw new Error('Channel and HTTP selectors are not be used together.');
+        }
+        if (channelSelector) {
+            const flowFormNewDialog = await this.documentRootLocatorFactory().locatorFor(GioPolicyStudioFlowMessageFormDialogHarness)();
+            const toChannelOperator = {
+                STARTS_WITH: 'Starts with',
+                EQUALS: 'Equals',
+            };
+            await flowFormNewDialog.setFlowFormValues({
+                name: flow.name,
+                channel: channelSelector?.channel,
+                channelOperator: toChannelOperator[channelSelector.channelOperator],
+                entrypoints: channelSelector?.entrypoints,
+                operations: channelSelector?.operations,
+                condition: conditionSelector?.condition,
+            });
+            await flowFormNewDialog.save();
+            return;
+        }
+        if (httpSelector) {
+            const flowFormNewDialog = await this.documentRootLocatorFactory().locatorFor(GioPolicyStudioFlowProxyFormDialogHarness)();
+            await flowFormNewDialog.setFlowFormValues({
+                name: flow.name,
+                path: httpSelector?.path,
+                pathOperator: httpSelector?.pathOperator,
+                methods: httpSelector?.methods,
+                condition: conditionSelector?.condition,
+            });
+            await flowFormNewDialog.save();
+            return;
+        }
+        throw new Error('No selector found for this flow. Needed to select Message or Proxy flow form dialog.');
+    }
+    async setFlowExecutionConfig(flowExecution) {
+        await (await this.menuHarness()).openFlowExecutionConfig();
+        const flowExecutionDialog = await this.documentRootLocatorFactory().locatorFor(GioPolicyStudioFlowExecutionFormDialogHarness)();
+        await flowExecutionDialog.setFlowFormValues(flowExecution);
+        await flowExecutionDialog.save();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gio-policy-studio.harness.js","sourceRoot":"","sources":["../../../../../projects/ui-policy-studio-angular/src/lib/gio-policy-studio.harness.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (C) 2022 The Gravitee team (http://gravitee.io)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ComponentHarness } from '@angular/cdk/testing';\nimport { MatButtonHarness } from '@angular/material/button/testing';\nimport { MatTabGroupHarness } from '@angular/material/tabs/testing';\n\nimport { ChannelSelector, ConditionSelector, Flow, FlowExecution, HttpSelector } from './models';\nimport { GioPolicyStudioFlowsMenuHarness } from './components/flows-menu/gio-ps-flows-menu.harness';\nimport { GioPolicyStudioDetailsHarness } from './components/flow-details/gio-ps-flow-details.harness';\nimport { GioPolicyStudioFlowProxyFormDialogHarness } from './components/flow-form-dialog/flow-proxy-form-dialog/gio-ps-flow-proxy-form-dialog.harness';\nimport { GioPolicyStudioFlowMessageFormDialogHarness } from './components/flow-form-dialog/flow-message-form-dialog/gio-ps-flow-message-form-dialog.harness';\nimport { GioPolicyStudioFlowExecutionFormDialogHarness } from './components/flow-execution-form-dialog/gio-ps-flow-execution-form-dialog.harness';\nimport { GioPolicyStudioDetailsPhaseHarness, PhaseType } from './components/flow-details-phase/gio-ps-flow-details-phase.harness';\n\nexport class GioPolicyStudioHarness extends ComponentHarness {\n  public static hostSelector = 'gio-policy-studio';\n\n  private menuHarness = this.locatorFor(GioPolicyStudioFlowsMenuHarness);\n\n  private detailsHarness = this.locatorFor(GioPolicyStudioDetailsHarness);\n\n  private phaseHarness = (phaseType: PhaseType) => this.locatorFor(GioPolicyStudioDetailsPhaseHarness.with({ type: phaseType }))();\n\n  /**\n   * Add a flow to a plan or to \"Common flows\"\n   *\n   * @param groupName Plan name where to add the flow. You also can define \"Common flows\" to add a flow to this group.\n   * @param flow Flow to add\n   */\n  public async addFlow(groupName: string, flow: Flow): Promise<void> {\n    await (await this.menuHarness()).addFlow(new RegExp(groupName, 'i'));\n\n    await this.setFlowFormDialog(flow);\n  }\n\n  /**\n   * Edit a flow configuration\n   *\n   * @param flowName Flow name to edit\n   * @param flow\n   */\n  public async editFlowConfig(flowName: string, flow: Partial<Flow>): Promise<void> {\n    (await this.menuHarness()).selectFlow(new RegExp(flowName, 'i'));\n    await (await this.detailsHarness()).clickEditFlowBtn();\n\n    await this.setFlowFormDialog(flow);\n  }\n\n  /**\n   * Delete a flow\n   *\n   * @param flowName Flow name to delete\n   */\n  public async deleteFlow(flowName: string): Promise<void> {\n    (await this.menuHarness()).selectFlow(new RegExp(flowName, 'i'));\n    await (await this.detailsHarness()).clickDeleteFlowBtn();\n  }\n\n  /**\n   * Select a flow in the menu\n   *\n   * @param flowName Flow name to select\n   */\n  public async selectFlowInMenu(flowName: string): Promise<void> {\n    await (await this.menuHarness()).selectFlow(new RegExp(flowName, 'i'));\n  }\n\n  /**\n   * Get the list of flows in the menu\n   */\n  public async getFlowsMenu(): Promise<\n    {\n      name: string | null;\n      flows: {\n        name: string | null;\n        isSelected: boolean;\n        infos: string | null;\n      }[];\n    }[]\n  > {\n    return (await this.menuHarness()).getAllFlowsGroups();\n  }\n\n  /**\n   * Get selected flow infos\n   */\n  public async getSelectedFlowInfos(): Promise<Record<string, (string | null)[]>> {\n    return await (await this.detailsHarness()).getFlowInfos();\n  }\n\n  /**\n   * Get selected flow phase harness\n   * @param phaseType Phase type to get\n   */\n  public async getSelectedFlowPhase(phaseType: PhaseType): Promise<GioPolicyStudioDetailsPhaseHarness | undefined> {\n    if (phaseType === 'PUBLISH' || phaseType === 'SUBSCRIBE') {\n      const matTabsHarness = await this.locatorFor(MatTabGroupHarness.with({ selector: '.content__tabs' }))();\n      await matTabsHarness.selectTab({ label: 'Event messages' });\n    }\n\n    const steps = await this.phaseHarness(phaseType);\n\n    return steps ? steps : undefined;\n  }\n\n  /**\n   * Get Save button state\n   */\n  public async getSaveButtonState(): Promise<'VISIBLE' | 'DISABLED' | 'SAVING'> {\n    const saveButton = await this.locatorFor(MatButtonHarness.with({ ancestor: '.header__btn' }))();\n    const disabled = await saveButton.isDisabled();\n    const text = await saveButton.getText();\n\n    if (text === 'Saving...') {\n      return 'SAVING';\n    }\n\n    if (disabled) {\n      return 'DISABLED';\n    }\n\n    return 'VISIBLE';\n  }\n\n  /**\n   * Click on the \"Save\" button\n   */\n  public async save(): Promise<void> {\n    await (await this.locatorFor(MatButtonHarness.with({ text: /Save/ }))()).click();\n  }\n\n  private async setFlowFormDialog(flow: Partial<Flow>) {\n    const channelSelector = flow.selectors?.find(s => s.type === 'CHANNEL') as ChannelSelector | undefined;\n    const httpSelector = flow.selectors?.find(s => s.type === 'HTTP') as HttpSelector | undefined;\n    const conditionSelector = flow.selectors?.find(s => s.type === 'CONDITION') as ConditionSelector | undefined;\n\n    if (!!channelSelector && !!httpSelector) {\n      throw new Error('Channel and HTTP selectors are not be used together.');\n    }\n\n    if (channelSelector) {\n      const flowFormNewDialog = await this.documentRootLocatorFactory().locatorFor(GioPolicyStudioFlowMessageFormDialogHarness)();\n\n      const toChannelOperator = {\n        STARTS_WITH: 'Starts with',\n        EQUALS: 'Equals',\n      };\n\n      await flowFormNewDialog.setFlowFormValues({\n        name: flow.name,\n        channel: channelSelector?.channel,\n        channelOperator: toChannelOperator[channelSelector.channelOperator],\n        entrypoints: channelSelector?.entrypoints,\n        operations: channelSelector?.operations,\n        condition: conditionSelector?.condition,\n      });\n\n      await flowFormNewDialog.save();\n      return;\n    }\n\n    if (httpSelector) {\n      const flowFormNewDialog = await this.documentRootLocatorFactory().locatorFor(GioPolicyStudioFlowProxyFormDialogHarness)();\n\n      await flowFormNewDialog.setFlowFormValues({\n        name: flow.name,\n        path: httpSelector?.path,\n        pathOperator: httpSelector?.pathOperator,\n        methods: httpSelector?.methods,\n        condition: conditionSelector?.condition,\n      });\n\n      await flowFormNewDialog.save();\n      return;\n    }\n\n    throw new Error('No selector found for this flow. Needed to select Message or Proxy flow form dialog.');\n  }\n\n  public async setFlowExecutionConfig(flowExecution: FlowExecution): Promise<void> {\n    await (await this.menuHarness()).openFlowExecutionConfig();\n\n    const flowExecutionDialog = await this.documentRootLocatorFactory().locatorFor(GioPolicyStudioFlowExecutionFormDialogHarness)();\n    await flowExecutionDialog.setFlowFormValues(flowExecution);\n    await flowExecutionDialog.save();\n  }\n}\n"]}