diff --git a/tests/Umbraco.Tests.AcceptanceTest/package-lock.json b/tests/Umbraco.Tests.AcceptanceTest/package-lock.json index 99d813ab88b7..d330602bc704 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/package-lock.json +++ b/tests/Umbraco.Tests.AcceptanceTest/package-lock.json @@ -7,8 +7,8 @@ "name": "acceptancetest", "hasInstallScript": true, "dependencies": { - "@umbraco/json-models-builders": "^2.0.44", - "@umbraco/playwright-testhelpers": "^17.0.34", + "@umbraco/json-models-builders": "^18.0.1", + "@umbraco/playwright-testhelpers": "^18.0.3", "camelize": "^1.0.0", "dotenv": "^16.3.1", "node-fetch": "^2.6.7" @@ -58,21 +58,21 @@ } }, "node_modules/@umbraco/json-models-builders": { - "version": "2.0.45", - "resolved": "https://registry.npmjs.org/@umbraco/json-models-builders/-/json-models-builders-2.0.45.tgz", - "integrity": "sha512-MxBoUCXZM5QSFMeWJ9tgbtYBcs0FMHaVjRW15aTr82HjqdO5IjQ/VSMb5KvSMiQDYSGDeS50mW8DTMnwG1ws6Q==", + "version": "18.0.1", + "resolved": "https://registry.npmjs.org/@umbraco/json-models-builders/-/json-models-builders-18.0.1.tgz", + "integrity": "sha512-PNKUe61EPaUNhbtahpgjS4Yk3dw3Jp8GEKlAkXTrNIiz4hxevFIBDlXW+euEmYwlyreAw/oAE5UgGbFVPKDFhQ==", "license": "MIT", "dependencies": { "camelize": "^1.0.1" } }, "node_modules/@umbraco/playwright-testhelpers": { - "version": "17.0.34", - "resolved": "https://registry.npmjs.org/@umbraco/playwright-testhelpers/-/playwright-testhelpers-17.0.34.tgz", - "integrity": "sha512-p9x1TRCqKCiYfm1gUndY7hEgtwjaVc05o1HHQ/wVuWQIP8l0ho1Shf5u7D4yiFQtXbQCy8746gWGSgaaTqQGxA==", + "version": "18.0.3", + "resolved": "https://registry.npmjs.org/@umbraco/playwright-testhelpers/-/playwright-testhelpers-18.0.3.tgz", + "integrity": "sha512-gRQo0tm1DcxKYl+iM2cjz2h6OwtC64gyqAs3ajX2sKuSGT54n5C9kgSUWKYnPGatkBGTxgvVtbParUdyQXQZVA==", "license": "MIT", "dependencies": { - "@umbraco/json-models-builders": "2.0.45", + "@umbraco/json-models-builders": "18.0.1", "node-fetch": "^2.6.7" } }, diff --git a/tests/Umbraco.Tests.AcceptanceTest/package.json b/tests/Umbraco.Tests.AcceptanceTest/package.json index 67a7eafc6c31..3af9001d7472 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/package.json +++ b/tests/Umbraco.Tests.AcceptanceTest/package.json @@ -22,8 +22,8 @@ "typescript": "^4.8.3" }, "dependencies": { - "@umbraco/json-models-builders": "^2.0.44", - "@umbraco/playwright-testhelpers": "^17.0.34", + "@umbraco/json-models-builders": "^18.0.1", + "@umbraco/playwright-testhelpers": "^18.0.3", "camelize": "^1.0.0", "dotenv": "^16.3.1", "node-fetch": "^2.6.7" diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ElementPicker.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ElementPicker.spec.ts new file mode 100644 index 000000000000..c07db4c300ea --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ElementPicker.spec.ts @@ -0,0 +1,79 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Element Picker'; +const customDataTypeName = 'Custom Element Picker'; +const editorAlias = 'Umbraco.ElementPicker'; +const editorUiAlias = 'Umb.PropertyEditorUi.ElementPicker'; + +test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + await umbracoApi.dataType.ensureNameNotExists(customDataTypeName); +}); + +test.afterEach(async ({umbracoApi}) => { + await umbracoApi.dataType.ensureNameNotExists(customDataTypeName); +}); + +test('can create an element picker data type', async ({umbracoApi, umbracoUi}) => { + // Act + await umbracoUi.dataType.clickActionsMenuForName('Data Types'); + await umbracoUi.dataType.clickCreateActionMenuOption(); + await umbracoUi.dataType.clickDataTypeButton(); + await umbracoUi.dataType.enterDataTypeName(customDataTypeName); + await umbracoUi.dataType.clickSelectAPropertyEditorButton(); + await umbracoUi.dataType.selectAPropertyEditor(dataTypeName); + await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeCreated(); + + // Assert + await umbracoUi.dataType.isDataTypeTreeItemVisible(customDataTypeName); + expect(await umbracoApi.dataType.doesNameExist(customDataTypeName)).toBeTruthy(); + const dataTypeData = await umbracoApi.dataType.getByName(customDataTypeName); + expect(dataTypeData.editorAlias).toBe(editorAlias); + expect(dataTypeData.editorUiAlias).toBe(editorUiAlias); + expect(dataTypeData.values).toEqual([]); +}); + +test('can set minimum amount', async ({umbracoApi, umbracoUi}) => { + // Arrange + const minAmount = 2; + await umbracoApi.dataType.createDefaultElementPickerDataType(customDataTypeName); + await umbracoUi.dataType.goToDataType(customDataTypeName); + + // Act + await umbracoUi.dataType.enterMinAmount(minAmount.toString()); + await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated(); + + // Assert + expect(await umbracoApi.dataType.doesElementPickerHaveMinAndMaxAmount(customDataTypeName, minAmount)).toBeTruthy(); +}); + +test('can set maximum amount', async ({umbracoApi, umbracoUi}) => { + // Arrange + const maxAmount = 5; + await umbracoApi.dataType.createDefaultElementPickerDataType(customDataTypeName); + await umbracoUi.dataType.goToDataType(customDataTypeName); + + // Act + await umbracoUi.dataType.enterMaxAmount(maxAmount.toString()); + await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated(); + + // Assert + expect(await umbracoApi.dataType.doesElementPickerHaveMinAndMaxAmount(customDataTypeName, undefined, maxAmount)).toBeTruthy(); +}); + +test('can set minimum and maximum amount', async ({umbracoApi, umbracoUi}) => { + // Arrange + const minAmount = 1; + const maxAmount = 10; + await umbracoApi.dataType.createDefaultElementPickerDataType(customDataTypeName); + await umbracoUi.dataType.goToDataType(customDataTypeName); + + // Act + await umbracoUi.dataType.enterAmountValue(minAmount.toString(), maxAmount.toString()); + await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated(); + + // Assert + expect(await umbracoApi.dataType.doesElementPickerHaveMinAndMaxAmount(customDataTypeName, minAmount, maxAmount)).toBeTruthy(); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts new file mode 100644 index 000000000000..b47a4aecb9d2 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts @@ -0,0 +1,212 @@ +import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +let elementTypeId = ''; +let elementId = ''; +const elementName = 'TestElement'; +const elementTypeName = 'TestElementTypeForElement3'; +const dataTypeName = 'Textstring'; +const elementText = 'This is test element text'; + +test.beforeEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementName); + const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', dataTypeName, dataTypeData.id); +}); + +test.afterEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); +}); + +test('can create empty element', async ({umbracoApi, umbracoUi}) => { + // Arrange + const expectedState = 'Draft'; + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + const elementData = await umbracoApi.element.getByName(elementName); + expect(elementData.variants[0].state).toBe(expectedState); +}); + +test('can save and publish empty element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + const expectedState = 'Published'; + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementName); + await umbracoUi.library.clickSaveAndPublishButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + const elementData = await umbracoApi.element.getByName(elementName); + expect(elementData.variants[0].state).toBe(expectedState); +}); + +test('can create element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementName); + await umbracoUi.library.enterTextstring(elementText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + const elementData = await umbracoApi.element.getByName(elementName); + expect(elementData.values[0].value).toBe(elementText); +}); + +test('can rename element', async ({umbracoApi, umbracoUi}) => { + // Arrange + const wrongElementName = 'Wrong Element Name'; + elementId = await umbracoApi.element.createDefaultElement(wrongElementName, elementTypeId); + expect(await umbracoApi.element.doesNameExist(wrongElementName)).toBeTruthy(); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.goToElementWithName(wrongElementName); + await umbracoUi.library.enterElementName(elementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + const updatedelementData = await umbracoApi.element.get(elementId); + expect(updatedelementData.variants[0].name).toEqual(elementName); +}); + +test('can update element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + const wrongElementText = 'This is wrong test element text'; + elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, wrongElementText, dataTypeName); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.goToElementWithName(elementName); + await umbracoUi.library.enterTextstring(elementText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + const updatedelementData = await umbracoApi.element.getByName(elementName); + expect(updatedelementData.values[0].value).toBe(elementText); +}); + +test('can unpublish element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, elementText, dataTypeName); + await umbracoApi.element.publish(elementId); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuForElement(elementName); + await umbracoUi.library.clickUnpublishActionMenuOption(); + await umbracoUi.library.clickConfirmToUnpublishButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.unpublished); + const elementData = await umbracoApi.element.getByName(elementName); + expect(elementData.variants[0].state).toBe('Draft'); +}); + +test('can duplicate a element node to root', async ({umbracoApi, umbracoUi}) => { + // Arrange + const duplicatedElementName = elementName + ' (1)'; + elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, elementText, dataTypeName); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuForElement(elementName); + // Duplicate to root + await umbracoUi.library.clickDuplicateToActionMenuOption(); + await umbracoUi.library.clickLabelWithName('Elements'); + await umbracoUi.library.clickDuplicateButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.duplicated); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + expect(await umbracoApi.element.doesNameExist(duplicatedElementName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementName); + await umbracoUi.library.isElementInTreeVisible(duplicatedElementName); + const elementData = await umbracoApi.element.getByName(elementName); + const duplicatedElementData = await umbracoApi.element.getByName(duplicatedElementName); + expect(elementData.values[0].value).toEqual(duplicatedElementData.values[0].value); + + // Clean + await umbracoApi.element.ensureNameNotExists(duplicatedElementName); +}); + +test('can duplicate a element node to other parent', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementFolderName = 'TestElementFolder'; + await umbracoApi.element.createDefaultElementFolder(elementFolderName); + elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, elementText, dataTypeName); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuForElement(elementName); + await umbracoUi.library.clickDuplicateToActionMenuOption(); + await umbracoUi.library.clickModalMenuItemWithName(elementFolderName); + await umbracoUi.library.clickDuplicateButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.duplicated); + await umbracoUi.library.isElementInTreeVisible(elementName); + await umbracoUi.library.isElementInTreeVisible(elementFolderName); + await umbracoUi.library.goToElementWithName(elementFolderName); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +test('can move a element node to other parent', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, elementText, dataTypeName); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act; + await umbracoUi.library.clickActionsMenuForElement(elementName); + await umbracoUi.library.clickMoveToActionMenuOption(); + await umbracoUi.library.moveToElementWithName([], elementFolderName); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.moved); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickReloadChildrenActionMenuOption(); + await umbracoUi.library.isCaretButtonVisibleForElementName(elementFolderName, true); + await umbracoUi.library.openElementCaretButtonForName(elementFolderName); + await umbracoUi.library.isChildElementInTreeVisible(elementFolderName, elementName, true); + await umbracoUi.library.isCaretButtonVisibleForElementName(elementName, false); + expect(await umbracoApi.element.getChildrenAmount(elementFolderId)).toEqual(1); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts new file mode 100644 index 000000000000..9b9b08d6ecfa --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts @@ -0,0 +1,177 @@ +import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; +import {expect} from '@playwright/test'; + +const elementFolderName = 'TestElementFolder'; +const elementName = 'TestElementInFolder'; +const elementTypeName = 'TestElementTypeForFolder'; +const dataTypeName = 'Textstring'; +let elementTypeId = ''; + +test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementFolderName); + await umbracoApi.element.ensureNameNotExists(elementName); + const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', dataTypeName, dataTypeData.id); + await umbracoUi.goToBackOffice(); +}); + +test.afterEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementFolderName); + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); +}); + +test('can create an empty element folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementFolderButton(); + await umbracoUi.library.enterFolderName(elementFolderName); + await umbracoUi.library.clickCreateFolderButtonAndWaitForElementFolderToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementFolderName); +}); + +test('can trash an element folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.createDefaultElementFolder(elementFolderName); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickTrashActionMenuOption(); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementFolderToBeTrashed(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeFalsy(); + await umbracoUi.library.isElementInTreeVisible(elementFolderName, false); +}); + +test('can rename an element folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const oldFolderName = 'OldFolderName'; + await umbracoApi.element.ensureNameNotExists(oldFolderName); + await umbracoApi.element.createDefaultElementFolder(oldFolderName); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.clickActionsMenuForElement(oldFolderName); + await umbracoUi.library.clickRenameActionMenuOption(); + await umbracoUi.library.enterFolderName(elementFolderName); + await umbracoUi.library.clickConfirmRenameFolderButtonAndWaitForElementFolderToBeRenamed(); + + // Assert + expect(await umbracoApi.element.doesNameExist(oldFolderName)).toBeFalsy(); + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(oldFolderName, false); + await umbracoUi.library.isElementInTreeVisible(elementFolderName); +}); + +test('can create an element folder in a folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const childFolderName = 'ChildElementFolder'; + await umbracoApi.element.ensureNameNotExists(childFolderName); + const parentFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementFolderButton(); + await umbracoUi.library.enterFolderName(childFolderName); + await umbracoUi.library.clickCreateFolderButtonAndWaitForElementFolderToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(childFolderName)).toBeTruthy(); + const parentFolder = await umbracoApi.element.getChildren(parentFolderId); + expect(parentFolder[0].name).toBe(childFolderName); + + // Clean + await umbracoApi.element.ensureNameNotExists(childFolderName); +}); + +test('can create a folder in a folder in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + const grandParentFolderName = 'GrandParentElementFolder'; + const parentFolderName = 'ParentElementFolder'; + await umbracoApi.element.ensureNameNotExists(grandParentFolderName); + await umbracoApi.element.ensureNameNotExists(parentFolderName); + const grandParentFolderId = await umbracoApi.element.createDefaultElementFolder(grandParentFolderName); + const parentFolderId = await umbracoApi.element.createFolder(parentFolderName, grandParentFolderId); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.openElementCaretButtonForName(grandParentFolderName); + await umbracoUi.library.clickActionsMenuForElement(parentFolderName); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementFolderButton(); + await umbracoUi.library.enterFolderName(elementFolderName); + await umbracoUi.library.clickCreateFolderButtonAndWaitForElementFolderToBeCreated(); + + // Assert + await umbracoUi.library.clickActionsMenuForElement(parentFolderName); + await umbracoUi.library.clickReloadChildrenActionMenuOption(); + await umbracoUi.library.openElementCaretButtonForName(parentFolderName); + await umbracoUi.library.isChildElementInTreeVisible(parentFolderName, elementFolderName); + const grandParentChildren = await umbracoApi.element.getChildren(grandParentFolderId); + expect(grandParentChildren[0].name).toBe(parentFolderName); + const parentChildren = await umbracoApi.element.getChildren(parentFolderId); + expect(parentChildren[0].name).toBe(elementFolderName); + + // Clean + await umbracoApi.element.ensureNameNotExists(grandParentFolderName); + await umbracoApi.element.ensureNameNotExists(parentFolderName); +}); + +test('can create and publish an element in a folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementName); + await umbracoUi.library.clickSaveAndPublishButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + const folderChildren = await umbracoApi.element.getChildren(folderId); + expect(folderChildren[0].name).toBe(elementName); + const elementData = await umbracoApi.element.getByName(elementName); + expect(elementData.variants[0].state).toBe('Published'); +}); + +test('can create an element in a nested folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const parentFolderName = 'ParentElementFolder'; + await umbracoApi.element.ensureNameNotExists(parentFolderName); + const parentFolderId = await umbracoApi.element.createDefaultElementFolder(parentFolderName); + const childFolderId = await umbracoApi.element.createFolder(elementFolderName, parentFolderId); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.openElementCaretButtonForName(parentFolderName); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + const folderChildren = await umbracoApi.element.getChildren(childFolderId); + expect(folderChildren[0].name).toBe(elementName); + + // Clean + await umbracoApi.element.ensureNameNotExists(parentFolderName); +}); + diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts new file mode 100644 index 000000000000..4373a1644967 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts @@ -0,0 +1,96 @@ +import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers'; +import {expect} from '@playwright/test'; + +const elementFolderName = 'TestElementFolder'; +const firstElementName = 'FirstTestElement'; +const secondElementName = 'SecondTestElement'; +const elementTypeName = 'TestElementTypeForBulk'; +const dataTypeName = 'Textstring'; +let elementTypeId = ''; +let folderId = ''; +let firstElementId = ''; +let secondElementId = ''; + +test.beforeEach(async ({umbracoUi, umbracoApi}) => { + const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', dataTypeName, dataTypeData.id); + folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + firstElementId = await umbracoApi.element.createDefaultElementWithParent(firstElementName, elementTypeId, folderId); + secondElementId = await umbracoApi.element.createDefaultElementWithParent(secondElementName, elementTypeId, folderId); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.goToElementWithName(elementFolderName); +}); + +test.afterEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementFolderName); + await umbracoApi.element.ensureNameNotExists(firstElementName); + await umbracoApi.element.ensureNameNotExists(secondElementName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); +}); + +test('can bulk publish elements in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Act + await umbracoUi.library.selectElementWithNameInElementCollectionView(firstElementName); + await umbracoUi.library.selectElementWithNameInElementCollectionView(secondElementName); + await umbracoUi.library.clickPublishSelectedListItems(); + await umbracoUi.library.clickConfirmToPublishButtonAndWaitForElementToBePublished(); + + // Assert + expect(await umbracoApi.element.isElementPublished(firstElementId)).toBeTruthy(); + expect(await umbracoApi.element.isElementPublished(secondElementId)).toBeTruthy(); +}); + +test('can bulk unpublish elements in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.publish(firstElementId); + await umbracoApi.element.publish(secondElementId); + + // Act + await umbracoUi.library.selectElementWithNameInElementCollectionView(firstElementName); + await umbracoUi.library.selectElementWithNameInElementCollectionView(secondElementName); + await umbracoUi.library.clickUnpublishSelectedListItems(); + await umbracoUi.library.clickConfirmToUnpublishButtonAndWaitForElementToBeUnpublished(); + + // Assert + expect(await umbracoApi.element.isElementPublished(firstElementId)).toBeFalsy(); + expect(await umbracoApi.element.isElementPublished(secondElementId)).toBeFalsy(); +}); + +test('can bulk move elements to another folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const targetFolderName = 'TargetElementFolder'; + await umbracoApi.element.ensureNameNotExists(targetFolderName); + const targetFolderId = await umbracoApi.element.createDefaultElementFolder(targetFolderName); + + // Act + await umbracoUi.library.selectElementWithNameInElementCollectionView(firstElementName); + await umbracoUi.library.selectElementWithNameInElementCollectionView(secondElementName); + await umbracoUi.library.clickMoveToSelectedListItems(); + await umbracoUi.library.moveToElementWithName(['Elements'], targetFolderName); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.moved); + const targetFolderChildren = await umbracoApi.element.getChildren(targetFolderId); + expect(targetFolderChildren.length).toBe(2); + const childNames = targetFolderChildren.map((child: any) => child.name); + expect(childNames).toContain(firstElementName); + expect(childNames).toContain(secondElementName); + + // Clean + await umbracoApi.element.ensureNameNotExists(targetFolderName); +}); + +test('can bulk trash elements in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Act + await umbracoUi.library.selectElementWithNameInElementCollectionView(firstElementName); + await umbracoUi.library.selectElementWithNameInElementCollectionView(secondElementName); + await umbracoUi.library.clickTrashSelectedListItems(); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementToBeTrashed(); + + // Assert + expect(await umbracoApi.element.doesNameExist(firstElementName)).toBeFalsy(); + expect(await umbracoApi.element.doesNameExist(secondElementName)).toBeFalsy(); + const folderChildren = await umbracoApi.element.getChildren(folderId); + expect(folderChildren.length).toBe(0); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts new file mode 100644 index 000000000000..99504cdf8d09 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts @@ -0,0 +1,142 @@ +import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers'; +import {expect} from '@playwright/test'; + +const elementName = 'TestElementForRecycleBin'; +const elementFolderName = 'TestElementFolderForRecycleBin'; +const elementTypeName = 'TestElementTypeForRecycleBin'; +const dataTypeName = 'Textstring'; +let elementTypeId = ''; + +test.beforeEach(async ({umbracoUi, umbracoApi}) => { + const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', dataTypeName, dataTypeData.id); + await umbracoUi.goToBackOffice(); +}); + +test.afterEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.element.ensureNameNotExists(elementFolderName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); + await umbracoApi.element.emptyRecycleBin(); +}); + +test('can trash an element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.createDefaultElement(elementName, elementTypeId); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuForElement(elementName); + await umbracoUi.library.clickTrashActionMenuOption(); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementToBeTrashed(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementName)).toBeFalsy(); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementName, false); +}); + +test('can trash an element folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.createDefaultElementFolder(elementFolderName); + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickTrashActionMenuOption(); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementFolderToBeTrashed(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeFalsy(); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementFolderName, false); +}); + +test('can trash an element folder with children', async ({umbracoApi, umbracoUi}) => { + // Arrange + const folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + await umbracoApi.element.createDefaultElementWithParent(elementName, elementTypeId, folderId); + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy(); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickTrashActionMenuOption(); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementFolderToBeTrashed(); + + // Assert + expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeFalsy(); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeFalsy(); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementFolderName, false); +}); + +test('can empty recycle bin', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId); + await umbracoApi.element.moveToRecycleBin(elementId); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeTruthy(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.clickRecycleBinButton(); + await umbracoUi.waitForTimeout(ConstantHelper.wait.medium); + await umbracoUi.library.clickEmptyRecycleBinButton(); + await umbracoUi.library.clickConfirmEmptyRecycleBinButtonAndWaitForRecycleBinToBeEmptied(); + + // Assert + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeFalsy(); +}); + +test('can see trashed element in recycle bin', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId); + await umbracoApi.element.moveToRecycleBin(elementId); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Assert + await umbracoUi.library.isItemVisibleInRecycleBin(elementName); +}); + +test('can delete element permanently from recycle bin', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId); + await umbracoApi.element.moveToRecycleBin(elementId); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeTruthy(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.isItemVisibleInRecycleBin(elementName); + + // Act + await umbracoUi.library.clickDeleteButtonForTrashedElememtWithName(elementName); + await umbracoUi.library.clickConfirmToDeleteButtonAndWaitForElementToBeDeleted(); + + // Assert + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeFalsy(); +}); + +// Unskip once the front-end is ready +test.skip('can restore element from recycle bin', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId); + await umbracoApi.element.moveToRecycleBin(elementId); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeTruthy(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + await umbracoUi.library.isItemVisibleInRecycleBin(elementName); + await umbracoUi.library.clickActionsMenuForElement(elementName); + await umbracoUi.library.clickRestoreActionMenuOption(); + await umbracoUi.library.clickRestoreButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.restored); + expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeFalsy(); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementName); +}); + diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/VariantElement.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/VariantElement.spec.ts new file mode 100644 index 000000000000..ab194e2514ac --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/VariantElement.spec.ts @@ -0,0 +1,284 @@ +import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +// Element Type +let variantElementTypeId = ''; +const variantElementTypeName = 'VariantElementType'; +const mixedElementTypeName = 'MixedPropertyElementType'; + +// Element +const elementName = 'TestVariantElement'; +const elementNameEnglish = 'Test Variant Element EN'; +const elementNameDanish = 'Test Variant Element DA'; + +// Data Types +const textStringDataTypeName = 'Textstring'; +let textStringDataTypeId = ''; + +// Property Names +const variantPropertyName = 'TestVariantText'; +const invariantPropertyName = 'TestInvariantText'; + +// Test Content +const englishText = 'This is English text'; +const danishText = 'Dette er dansk tekst'; +const updatedEnglishText = 'Updated English text'; +const invariantText = 'This is shared invariant text'; + +// Languages +const danishLanguage = 'Danish'; +const danishIsoCode = 'da'; + +// Group/Tab Names +const groupName = 'Content'; + +test.beforeEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.element.ensureNameNotExists(elementNameEnglish); + await umbracoApi.element.ensureNameNotExists(elementNameDanish); + await umbracoApi.documentType.ensureNameNotExists(variantElementTypeName); + await umbracoApi.documentType.ensureNameNotExists(mixedElementTypeName); + await umbracoApi.language.createDanishLanguage(); + const textStringDataType = await umbracoApi.dataType.getByName(textStringDataTypeName); + textStringDataTypeId = textStringDataType.id; +}); + +test.afterEach(async ({umbracoApi}) => { + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.element.ensureNameNotExists(elementNameEnglish); + await umbracoApi.element.ensureNameNotExists(elementNameDanish); + await umbracoApi.documentType.ensureNameNotExists(variantElementTypeName); + await umbracoApi.documentType.ensureNameNotExists(mixedElementTypeName); + await umbracoApi.language.ensureIsoCodeNotExists(danishIsoCode); +}); + +test('can create element with multiple culture variants', async ({umbracoApi, umbracoUi}) => { + // Arrange + variantElementTypeId = await umbracoApi.documentType.createDefaultElementTypeWithVaryByCulture( + variantElementTypeName, + groupName, + variantPropertyName, + textStringDataTypeId, + true, + true + ); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + // Create element with English culture + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(variantElementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementNameEnglish); + await umbracoUi.library.enterTextstring(englishText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + await umbracoUi.waitForTimeout(ConstantHelper.wait.short); + // Add Danish variant using variant selector + await umbracoUi.library.clickSelectVariantButton(); + await umbracoUi.library.clickVariantAddModeButtonForLanguageName(danishLanguage); + await umbracoUi.library.enterElementName(elementNameDanish); + await umbracoUi.library.enterTextstring(danishText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + const elementData = await umbracoApi.element.getByName(elementNameEnglish); + expect(elementData.variants.length).toBeGreaterThanOrEqual(2); + const englishVariant = elementData.variants.find((variant: any) => variant.culture === 'en-US'); + expect(englishVariant).toBeDefined(); + expect(englishVariant.name).toBe(elementNameEnglish); + expect(englishVariant.state).toBe('Draft'); + const danishVariant = elementData.variants.find((variant: any) => variant.culture === 'da'); + expect(danishVariant).toBeDefined(); + expect(danishVariant.name).toBe(elementNameDanish); + expect(danishVariant.state).toBe('Draft'); +}); + +test('can create element with invariant and variant properties', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.documentType.createVariantElementTypeWithVariantAndInvariantProperty( + mixedElementTypeName, + groupName, + variantPropertyName, + invariantPropertyName, + textStringDataTypeId + ); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + // Create element with English culture + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(mixedElementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(elementNameEnglish); + await umbracoUi.library.enterPropertyValue(variantPropertyName, englishText); + await umbracoUi.library.enterPropertyValue(invariantPropertyName, invariantText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + await umbracoUi.waitForTimeout(ConstantHelper.wait.short); + // Add Danish variant + await umbracoUi.library.clickSelectVariantButton(); + await umbracoUi.library.clickVariantAddModeButtonForLanguageName(danishLanguage); + await umbracoUi.library.enterElementName(elementNameDanish); + await umbracoUi.library.enterPropertyValue(variantPropertyName, danishText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + const elementData = await umbracoApi.element.getByName(elementNameEnglish); + expect(elementData.variants.length).toBeGreaterThanOrEqual(2); + // Verify variant properties have different values per culture + const englishVariantValue = elementData.values.find((variant: any) => variant.culture === 'en-US' && variant.alias === variantPropertyName.toLowerCase()); + const danishVariantValue = elementData.values.find((variant: any) => variant.culture === 'da' && variant.alias === variantPropertyName.toLowerCase()); + expect(englishVariantValue?.value).toBe(englishText); + expect(danishVariantValue?.value).toBe(danishText); + // Verify invariant property is shared (culture is null) + const invariantValue = elementData.values.find((variant: any) => variant.culture === null && variant.alias === invariantPropertyName.toLowerCase()); + expect(invariantValue?.value).toBe(invariantText); +}); + +test('can publish single culture variant only', async ({umbracoApi, umbracoUi}) => { + // Arrange + variantElementTypeId = await umbracoApi.documentType.createDefaultElementTypeWithVaryByCulture( + variantElementTypeName, + groupName, + variantPropertyName, + textStringDataTypeId, + true, + true + ); + await umbracoApi.element.createDefaultElementWithEnglishAndDanishVariants( + variantElementTypeId, + elementNameEnglish, + elementNameDanish, + variantPropertyName, + englishText, + danishText + ); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.goToElementWithName(elementNameEnglish); + await umbracoUi.library.switchLanguage(danishLanguage); + await umbracoUi.library.clickSaveAndPublishButton(); + await umbracoUi.library.clickConfirmToPublishButtonAndWaitForElementToBePublished(); + + // Assert + const elementData = await umbracoApi.element.getByName(elementNameEnglish); + const englishVariant = elementData.variants.find((variant: any) => variant.culture === 'en-US'); + expect(englishVariant.state).toBe('Draft'); + const danishVariant = elementData.variants.find((variant: any) => variant.culture === 'da'); + expect(danishVariant.state).toBe('Published'); +}); + +test('can publish all cultures at once', async ({umbracoApi, umbracoUi}) => { + // Arrange + variantElementTypeId = await umbracoApi.documentType.createDefaultElementTypeWithVaryByCulture( + variantElementTypeName, + groupName, + variantPropertyName, + textStringDataTypeId, + true, + true + ); + await umbracoApi.element.createDefaultElementWithEnglishAndDanishVariants( + variantElementTypeId, + elementNameEnglish, + elementNameDanish, + variantPropertyName, + englishText, + danishText + ); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.goToElementWithName(elementNameEnglish); + await umbracoUi.library.clickSaveAndPublishButton(); + await umbracoUi.library.clickSelectAllCheckbox(); + await umbracoUi.library.clickConfirmToPublishButtonAndWaitForElementToBePublished(); + + // Assert + const elementData = await umbracoApi.element.getByName(elementNameEnglish); + for (const variant of elementData.variants) { + if (variant.culture !== null) { + expect(variant.state).toBe('Published'); + } + } +}); + +test('can edit variant property for specific culture only', async ({umbracoApi, umbracoUi}) => { + // Arrange + variantElementTypeId = await umbracoApi.documentType.createDefaultElementTypeWithVaryByCulture( + variantElementTypeName, + groupName, + variantPropertyName, + textStringDataTypeId, + true, + true + ); + await umbracoApi.element.createDefaultElementWithEnglishAndDanishVariants( + variantElementTypeId, + elementNameEnglish, + elementNameDanish, + variantPropertyName, + englishText, + danishText + ); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.goToElementWithName(elementNameEnglish); + await umbracoUi.library.enterTextstring(updatedEnglishText); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + const elementData = await umbracoApi.element.getByName(elementNameEnglish); + const englishValue = elementData.values.find((variant: any) => variant.culture === 'en-US'); + expect(englishValue.value).toBe(updatedEnglishText); + const danishValue = elementData.values.find((variant: any) => variant.culture === 'da'); + expect(danishValue.value).toBe(danishText); +}); + +test('can edit element name for specific culture only', async ({umbracoApi, umbracoUi}) => { + // Arrange + const updatedEnglishName = 'Updated English Name'; + variantElementTypeId = await umbracoApi.documentType.createDefaultElementTypeWithVaryByCulture( + variantElementTypeName, + groupName, + variantPropertyName, + textStringDataTypeId, + true, + true + ); + await umbracoApi.element.createDefaultElementWithEnglishAndDanishVariants( + variantElementTypeId, + elementNameEnglish, + elementNameDanish, + variantPropertyName, + englishText, + danishText + ); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library); + + // Act + await umbracoUi.library.goToElementWithName(elementNameEnglish); + await umbracoUi.library.enterElementName(updatedEnglishName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + const elementData = await umbracoApi.element.getByName(updatedEnglishName); + const englishVariant = elementData.variants.find((variant: any) => variant.culture === 'en-US'); + expect(englishVariant.name).toBe(updatedEnglishName); + const danishVariant = elementData.variants.find((variant: any) => variant.culture === 'da'); + expect(danishVariant.name).toBe(elementNameDanish); + + // Clean + await umbracoApi.element.ensureNameNotExists(updatedEnglishName); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ContentStartNodes.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ContentStartNodes.spec.ts index f29aa1df06ad..c003defb3ad8 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ContentStartNodes.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ContentStartNodes.spec.ts @@ -1,94 +1,51 @@ -import { expect } from "@playwright/test"; -import { ConstantHelper, test } from "@umbraco/playwright-testhelpers"; +import {expect} from '@playwright/test'; +import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; const testUser = ConstantHelper.testUserCredentials; -let testUserCookieAndToken = { cookie: "", accessToken: "", refreshToken: "" }; +let testUserCookieAndToken = {cookie: '', accessToken: '', refreshToken: ''}; -const userGroupName = "TestUserGroup"; +const userGroupName = 'TestUserGroup'; let userGroupId = null; -const rootDocumentTypeName = "RootDocumentType"; -const childDocumentTypeOneName = "ChildDocumentTypeOne"; -const childDocumentTypeTwoName = "ChildDocumentTypeTwo"; +const rootDocumentTypeName = 'RootDocumentType'; +const childDocumentTypeOneName = 'ChildDocumentTypeOne'; +const childDocumentTypeTwoName = 'ChildDocumentTypeTwo'; let childDocumentTypeOneId = null; let rootDocumentTypeId = null; -const rootDocumentName = "RootDocument"; -const childDocumentOneName = "ChildDocumentOne"; -const childDocumentTwoName = "ChildDocumentTwo"; +const rootDocumentName = 'RootDocument'; +const childDocumentOneName = 'ChildDocumentOne'; +const childDocumentTwoName = 'ChildDocumentTwo'; let rootDocumentId = null; let childDocumentOneId = null; -test.beforeEach(async ({ umbracoApi }) => { +test.beforeEach(async ({umbracoApi}) => { await umbracoApi.documentType.ensureNameNotExists(rootDocumentTypeName); await umbracoApi.documentType.ensureNameNotExists(childDocumentTypeOneName); await umbracoApi.documentType.ensureNameNotExists(childDocumentTypeTwoName); await umbracoApi.user.ensureNameNotExists(testUser.name); await umbracoApi.userGroup.ensureNameNotExists(userGroupName); - childDocumentTypeOneId = - await umbracoApi.documentType.createDefaultDocumentType( - childDocumentTypeOneName - ); - const childDocumentTypeTwoId = - await umbracoApi.documentType.createDefaultDocumentType( - childDocumentTypeTwoName - ); - rootDocumentTypeId = - await umbracoApi.documentType.createDocumentTypeWithAllowedTwoChildNodes( - rootDocumentTypeName, - childDocumentTypeOneId, - childDocumentTypeTwoId - ); - rootDocumentId = await umbracoApi.document.createDefaultDocument( - rootDocumentName, - rootDocumentTypeId - ); - childDocumentOneId = - await umbracoApi.document.createDefaultDocumentWithParent( - childDocumentOneName, - childDocumentTypeOneId, - rootDocumentId - ); - await umbracoApi.document.createDefaultDocumentWithParent( - childDocumentTwoName, - childDocumentTypeTwoId, - rootDocumentId - ); - userGroupId = - await umbracoApi.userGroup.createSimpleUserGroupWithContentSection( - userGroupName - ); + childDocumentTypeOneId = await umbracoApi.documentType.createDefaultDocumentType(childDocumentTypeOneName); + const childDocumentTypeTwoId = await umbracoApi.documentType.createDefaultDocumentType(childDocumentTypeTwoName); + rootDocumentTypeId = await umbracoApi.documentType.createDocumentTypeWithAllowedTwoChildNodes(rootDocumentTypeName, childDocumentTypeOneId, childDocumentTypeTwoId); + rootDocumentId = await umbracoApi.document.createDefaultDocument(rootDocumentName, rootDocumentTypeId); + childDocumentOneId = await umbracoApi.document.createDefaultDocumentWithParent(childDocumentOneName, childDocumentTypeOneId, rootDocumentId); + await umbracoApi.document.createDefaultDocumentWithParent(childDocumentTwoName, childDocumentTypeTwoId, rootDocumentId); + userGroupId = await umbracoApi.userGroup.createSimpleUserGroupWithContentSection(userGroupName); }); -test.afterEach(async ({ umbracoApi }) => { +test.afterEach(async ({umbracoApi}) => { // Ensure we are logged in to admin - await umbracoApi.loginToAdminUser( - testUserCookieAndToken.cookie, - testUserCookieAndToken.accessToken, - testUserCookieAndToken.refreshToken - ); + await umbracoApi.loginToAdminUser(testUserCookieAndToken.cookie, testUserCookieAndToken.accessToken, testUserCookieAndToken.refreshToken); await umbracoApi.documentType.ensureNameNotExists(rootDocumentTypeName); await umbracoApi.documentType.ensureNameNotExists(childDocumentTypeOneName); await umbracoApi.documentType.ensureNameNotExists(childDocumentTypeTwoName); await umbracoApi.userGroup.ensureNameNotExists(userGroupName); }); -test("can see root start node and children", async ({ - umbracoApi, - umbracoUi, -}) => { +test('can see root start node and children', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId, - [rootDocumentId] - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId, [rootDocumentId]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act @@ -97,81 +54,41 @@ test("can see root start node and children", async ({ // Assert await umbracoUi.content.isContentInTreeVisible(rootDocumentName); await umbracoUi.content.openContentCaretButtonForName(rootDocumentName); - await umbracoUi.content.isChildContentInTreeVisible( - rootDocumentName, - childDocumentOneName - ); - await umbracoUi.content.isChildContentInTreeVisible( - rootDocumentName, - childDocumentTwoName - ); + await umbracoUi.content.isChildContentInTreeVisible(rootDocumentName, childDocumentOneName); + await umbracoUi.content.isChildContentInTreeVisible(rootDocumentName, childDocumentTwoName); }); -test("can see parent of start node but not access it", async ({ - umbracoApi, - umbracoUi, -}) => { +test('can see parent of start node but not access it', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId, - [childDocumentOneId] - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId, [childDocumentOneId]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act await umbracoUi.user.goToSection(ConstantHelper.sections.content, false); // Assert - // Get initial URL (should be on content section) - await umbracoUi.waitForTimeout(100); // Wait for workspace to load + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load const initialUrl = umbracoUi.page.url(); await umbracoUi.content.isContentInTreeVisible(rootDocumentName); await umbracoUi.content.goToContentWithName(rootDocumentName); - await umbracoUi.waitForTimeout(100); // Wait for workspace to load + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load // Assert - URL should not have changed (no navigation occurred) const currentUrl = umbracoUi.page.url(); expect(currentUrl).toBe(initialUrl); await umbracoUi.content.openContentCaretButtonForName(rootDocumentName); - await umbracoUi.content.isChildContentInTreeVisible( - rootDocumentName, - childDocumentOneName - ); - await umbracoUi.content.isChildContentInTreeVisible( - rootDocumentName, - childDocumentTwoName, - false - ); + await umbracoUi.content.isChildContentInTreeVisible(rootDocumentName, childDocumentOneName); + await umbracoUi.content.isChildContentInTreeVisible(rootDocumentName, childDocumentTwoName, false); }); -test("see no-access view when deep-linking to restricted document", async ({ - umbracoApi, - umbracoUi, -}) => { +test('see no-access view when deep-linking to restricted document', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId, - [childDocumentOneId] - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId, [childDocumentOneId]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act @@ -179,29 +96,15 @@ test("see no-access view when deep-linking to restricted document", async ({ // Assert await umbracoUi.content.isContentInTreeVisible(rootDocumentName); - await umbracoUi.page.goto( - `${umbracoUi.page.url()}/workspace/document/edit/${rootDocumentId!}` - ); - await umbracoUi.waitForTimeout(100); // Wait for workspace to load - await umbracoUi.content.doesDocumentWorkspaceHaveText("Access denied"); + await umbracoUi.page.goto(`${umbracoUi.page.url()}/workspace/document/edit/${rootDocumentId!}`); + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load + await umbracoUi.content.doesDocumentWorkspaceHaveText('Access denied'); }); -test("can not see any content when no start nodes specified", async ({ - umbracoApi, - umbracoUi, -}) => { +test('can not see any content when no start nodes specified', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ElementStartNodes.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ElementStartNodes.spec.ts new file mode 100644 index 000000000000..7edfd156e990 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/ElementStartNodes.spec.ts @@ -0,0 +1,110 @@ +import {expect} from '@playwright/test'; +import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; + +const testUser = ConstantHelper.testUserCredentials; +let testUserCookieAndToken = {cookie: '', accessToken: '', refreshToken: ''}; + +const userGroupName = 'TestUserGroup'; +let userGroupId = null; + +let rootFolderId = null; +let childElementOneId = null; +const rootFolderName = 'RootFolder'; +const childElementOneName = 'ChildElementOne'; +const childElementTwoName = 'ChildElementTwo'; +const elementTypeName = 'TestElementType'; +let elementTypeId = null; + +test.beforeEach(async ({umbracoApi}) => { + elementTypeId = await umbracoApi.documentType.createEmptyElementType(elementTypeName); + rootFolderId = await umbracoApi.element.createDefaultElementFolder(rootFolderName); + childElementOneId = await umbracoApi.element.createDefaultElementWithParent(childElementOneName, elementTypeId, rootFolderId); + await umbracoApi.element.createDefaultElementWithParent(childElementTwoName, elementTypeId, rootFolderId); + userGroupId = await umbracoApi.userGroup.createSimpleUserGroupWithLibrarySection(userGroupName); +}); + +test.afterEach(async ({umbracoApi}) => { + // Ensure we are logged in to admin + await umbracoApi.loginToAdminUser(testUserCookieAndToken.cookie, testUserCookieAndToken.accessToken, testUserCookieAndToken.refreshToken); + await umbracoApi.user.ensureNameNotExists(testUser.name); + await umbracoApi.userGroup.ensureNameNotExists(userGroupName); + await umbracoApi.element.ensureNameNotExists(childElementOneName); + await umbracoApi.element.ensureNameNotExists(childElementTwoName); + await umbracoApi.element.ensureNameNotExists(rootFolderName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); +}); + +// Currently user only see the parent and cannot see the element children +test.fixme('can see root element start node and children', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId, [rootFolderId]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isElementInTreeVisible(rootFolderName); + await umbracoUi.library.openElementCaretButtonForName(rootFolderName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementOneName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementTwoName); +}); + +// Currently the front-end does not support adding a specific element as start nodes +test.fixme('can see parent of start node but not access it', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId!, [childElementOneId!]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + // Get initial URL (should be on library section) + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load + const initialUrl = umbracoUi.page.url(); + + await umbracoUi.library.isElementInTreeVisible(rootFolderName); + await umbracoUi.library.goToElementWithName(rootFolderName); + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load + + // Assert - URL should not have changed (no navigation occurred) + const currentUrl = umbracoUi.page.url(); + expect(currentUrl).toBe(initialUrl); + + await umbracoUi.library.openElementCaretButtonForName(rootFolderName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementOneName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementTwoName, false); +}); + +// Currently the front-end does not support adding a specific element as start nodes +test.fixme('see no-access view when deep-linking to restricted element', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId!, [childElementOneId!]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isElementInTreeVisible(rootFolderName); + await umbracoUi.page.goto(`${umbracoUi.page.url().replace('/collection', '')}/workspace/element/edit/${rootFolderId!}`); + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load + await umbracoUi.library.doesElementWorkspaceHaveText('Access denied'); +}); + +test('can not see any element when no element start nodes specified', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isElementInTreeVisible(rootFolderName, false); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/MediaStartNodes.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/MediaStartNodes.spec.ts index 075b321ee7f4..d9c9ede208b1 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/MediaStartNodes.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/User/MediaStartNodes.spec.ts @@ -1,48 +1,33 @@ -import { expect } from "@playwright/test"; -import { ConstantHelper, test } from "@umbraco/playwright-testhelpers"; +import {expect} from '@playwright/test'; +import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; const testUser = ConstantHelper.testUserCredentials; -let testUserCookieAndToken = { cookie: "", accessToken: "", refreshToken: "" }; +let testUserCookieAndToken = {cookie: '', accessToken: '', refreshToken: ''}; -const userGroupName = "TestUserGroup"; +const userGroupName = 'TestUserGroup'; let userGroupId = null; let rootFolderId = null; let childFolderOneId = null; -const rootFolderName = "RootFolder"; -const childFolderOneName = "ChildFolderOne"; -const childFolderTwoName = "ChildFolderTwo"; +const rootFolderName = 'RootFolder'; +const childFolderOneName = 'ChildFolderOne'; +const childFolderTwoName = 'ChildFolderTwo'; -test.beforeEach(async ({ umbracoApi }) => { +test.beforeEach(async ({umbracoApi}) => { await umbracoApi.user.ensureNameNotExists(testUser.name); await umbracoApi.userGroup.ensureNameNotExists(userGroupName); await umbracoApi.media.ensureNameNotExists(rootFolderName); await umbracoApi.media.ensureNameNotExists(childFolderOneName); await umbracoApi.media.ensureNameNotExists(childFolderTwoName); - rootFolderId = await umbracoApi.media.createDefaultMediaFolder( - rootFolderName - ); - childFolderOneId = await umbracoApi.media.createDefaultMediaFolderAndParentId( - childFolderOneName, - rootFolderId - ); - await umbracoApi.media.createDefaultMediaFolderAndParentId( - childFolderTwoName, - rootFolderId - ); - userGroupId = - await umbracoApi.userGroup.createSimpleUserGroupWithMediaSection( - userGroupName - ); + rootFolderId = await umbracoApi.media.createDefaultMediaFolder(rootFolderName); + childFolderOneId = await umbracoApi.media.createDefaultMediaFolderAndParentId(childFolderOneName, rootFolderId); + await umbracoApi.media.createDefaultMediaFolderAndParentId(childFolderTwoName, rootFolderId); + userGroupId = await umbracoApi.userGroup.createSimpleUserGroupWithMediaSection(userGroupName); }); -test.afterEach(async ({ umbracoApi }) => { +test.afterEach(async ({umbracoApi}) => { // Ensure we are logged in to admin - await umbracoApi.loginToAdminUser( - testUserCookieAndToken.cookie, - testUserCookieAndToken.accessToken, - testUserCookieAndToken.refreshToken - ); + await umbracoApi.loginToAdminUser(testUserCookieAndToken.cookie, testUserCookieAndToken.accessToken, testUserCookieAndToken.refreshToken); await umbracoApi.user.ensureNameNotExists(testUser.name); await umbracoApi.userGroup.ensureNameNotExists(userGroupName); await umbracoApi.media.ensureNameNotExists(rootFolderName); @@ -50,25 +35,10 @@ test.afterEach(async ({ umbracoApi }) => { await umbracoApi.media.ensureNameNotExists(childFolderTwoName); }); -test("can see root media start node and children", async ({ - umbracoApi, - umbracoUi, -}) => { +test('can see root media start node and children', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId, - [], - false, - [rootFolderId] - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId, [], false, [rootFolderId]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act @@ -81,32 +51,16 @@ test("can see root media start node and children", async ({ await umbracoUi.media.isChildMediaVisible(rootFolderName, childFolderTwoName); }); -test("can see parent of start node but not access it", async ({ - umbracoApi, - umbracoUi, -}) => { +test('can see parent of start node but not access it', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId!, - [], - false, - [childFolderOneId!] - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId!, [], false, [childFolderOneId!]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act await umbracoUi.user.goToSection(ConstantHelper.sections.media, false); // Assert - // Get initial URL (should be on media section) await umbracoUi.waitForTimeout(100); // Wait for workspace to load const initialUrl = umbracoUi.page.url(); @@ -121,32 +75,13 @@ test("can see parent of start node but not access it", async ({ await umbracoUi.media.openMediaCaretButtonForName(rootFolderName); await umbracoUi.media.isChildMediaVisible(rootFolderName, childFolderOneName); - await umbracoUi.media.isChildMediaVisible( - rootFolderName, - childFolderTwoName, - false - ); + await umbracoUi.media.isChildMediaVisible(rootFolderName, childFolderTwoName, false); }); -test("see no-access view when deep-linking to restricted media", async ({ - umbracoApi, - umbracoUi, -}) => { +test('see no-access view when deep-linking to restricted media', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId!, - [], - false, - [childFolderOneId!] - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId!, [], false, [childFolderOneId!]); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act @@ -154,29 +89,15 @@ test("see no-access view when deep-linking to restricted media", async ({ // Assert await umbracoUi.media.isMediaTreeItemVisible(rootFolderName); - await umbracoUi.page.goto( - `${umbracoUi.page.url().replace('/collection', '')}/workspace/media/edit/${rootFolderId!}` - ); + await umbracoUi.page.goto(`${umbracoUi.page.url().replace('/collection', '')}/workspace/media/edit/${rootFolderId!}`); await umbracoUi.waitForTimeout(100); // Wait for workspace to load - await umbracoUi.media.doesMediaWorkspaceHaveText("Access denied"); + await umbracoUi.media.doesMediaWorkspaceHaveText('Access denied'); }); -test("can not see any media when no media start nodes specified", async ({ - umbracoApi, - umbracoUi, -}) => { +test('can not see any media when no media start nodes specified', async ({umbracoApi, umbracoUi}) => { // Arrange - await umbracoApi.user.setUserPermissions( - testUser.name, - testUser.email, - testUser.password, - userGroupId - ); - testUserCookieAndToken = await umbracoApi.user.loginToUser( - testUser.name, - testUser.email, - testUser.password - ); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); // Act diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInContent.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInContent.spec.ts index daf841e28e9a..8dc09405727e 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInContent.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInContent.spec.ts @@ -58,7 +58,7 @@ test.afterEach(async ({umbracoApi}) => { test('can read content node with permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -74,7 +74,7 @@ test('can read content node with permission enabled', {tag: '@release'}, async ( // Skip this test due to this issue: https://github.com/umbraco/Umbraco-CMS/issues/20505 test.skip('can not read content node with permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -221,7 +221,7 @@ test('can not create content with create permission disabled', async ({umbracoAp test('can set up notifications with notification permission enabled', async ({umbracoApi, umbracoUi}) => { // Arrange const notificationActionIds = ['Umb.Document.Delete', 'Umb.Document.Publish']; - userGroupId = await umbracoApi.userGroup.createUserGroupWithNotificationsPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithNotificationsDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -242,7 +242,7 @@ test('can set up notifications with notification permission enabled', async ({um test('can not set up notifications with notification permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithNotificationsPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithNotificationsDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -256,7 +256,7 @@ test('can not set up notifications with notification permission disabled', async test('can publish content with publish permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -274,7 +274,7 @@ test('can publish content with publish permission enabled', {tag: '@release'}, a test('can not publish content with publish permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -289,7 +289,7 @@ test('can not publish content with publish permission disabled', async ({umbraco // Skip this as this function is removed from the front-end. test.skip('can set permissions with set permissions permission enabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithSetPermissionsPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithSetPermissionsDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -306,7 +306,7 @@ test.skip('can set permissions with set permissions permission enabled', async ( // Skip this as this function is removed from the front-end. test.skip('can not set permissions with set permissions permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithSetPermissionsPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithSetPermissionsDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -322,7 +322,7 @@ test('can unpublish content with unpublish permission enabled', {tag: '@release' // Arrange await umbracoApi.document.publish(rootDocumentId); expect(await umbracoApi.document.isDocumentPublished(rootDocumentId)).toBeTruthy(); - userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -342,7 +342,7 @@ test('can not unpublish content with unpublish permission disabled', async ({umb // Arrange await umbracoApi.document.publish(rootDocumentId); expect(await umbracoApi.document.isDocumentPublished(rootDocumentId)).toBeTruthy(); - userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -356,7 +356,7 @@ test('can not unpublish content with unpublish permission disabled', async ({umb test('can update content with update permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -375,7 +375,7 @@ test('can update content with update permission enabled', {tag: '@release'}, asy test('can not update content with update permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -392,7 +392,7 @@ test('can not update content with update permission disabled', async ({umbracoAp test('can duplicate content with duplicate permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange const duplicatedContentName = rootDocumentName + ' (1)'; - userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicatePermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicateDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -418,7 +418,7 @@ test('can duplicate content with duplicate permission enabled', {tag: '@release' test('can not duplicate content with duplicate permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicatePermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicateDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -434,7 +434,7 @@ test('can move content with move to permission enabled', {tag: '@release'}, asyn // Arrange const moveToDocumentName = 'SecondRootDocument'; const moveToDocumentId = await umbracoApi.document.createDocumentWithTextContent(moveToDocumentName, rootDocumentTypeId, documentText, dataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithMoveToPermission(userGroupName, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithMoveToDocumentPermission(userGroupName, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -462,7 +462,7 @@ test('can not move content with move to permission disabled', async ({umbracoApi // Arrange const moveToDocumentName = 'SecondRootDocument'; await umbracoApi.document.createDocumentWithTextContent(moveToDocumentName, rootDocumentTypeId, documentText, dataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithMoveToPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithMoveToDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -478,7 +478,7 @@ test('can not move content with move to permission disabled', async ({umbracoApi test('can sort children with sort children permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange await umbracoApi.document.createDefaultDocumentWithParent(childDocumentTwoName, childDocumentTypeId, rootDocumentId); - userGroupId = await umbracoApi.userGroup.createUserGroupWithSortChildrenPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithSortChildrenDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -501,7 +501,7 @@ test('can sort children with sort children permission enabled', {tag: '@release' test('can not sort children with sort children permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange await umbracoApi.document.createDefaultDocumentWithParent(childDocumentTwoName, childDocumentTypeId, rootDocumentId); - userGroupId = await umbracoApi.userGroup.createUserGroupWithSortChildrenPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithSortChildrenDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -516,7 +516,7 @@ test('can not sort children with sort children permission disabled', async ({umb test('can set culture and hostnames with culture and hostnames permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange const domainName = '/domain'; - userGroupId = await umbracoApi.userGroup.createUserGroupWithCultureAndHostnamesPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithCultureAndHostnamesDocumentPermission(userGroupName); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -538,7 +538,7 @@ test('can set culture and hostnames with culture and hostnames permission enable test('can not set culture and hostnames with culture and hostnames permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithCultureAndHostnamesPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithCultureAndHostnamesDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -552,7 +552,7 @@ test('can not set culture and hostnames with culture and hostnames permission di test('can set public access with public access permission enabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithPublicAccessPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublicAccessDocumentPermission(userGroupName); const testMemberGroup = 'TestMemberGroup'; await umbracoApi.memberGroup.ensureNameNotExists(testMemberGroup); await umbracoApi.memberGroup.create(testMemberGroup) @@ -572,7 +572,7 @@ test('can set public access with public access permission enabled', async ({umbr test('can not set public access with public access permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithPublicAccessPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublicAccessDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -586,7 +586,7 @@ test('can not set public access with public access permission disabled', async ( test('can rollback content with rollback permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackPermission(userGroupName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackDocumentPermission(userGroupName); await umbracoApi.document.publish(rootDocumentId); const updatedTextStringText = 'This is an updated textString text'; const content = await umbracoApi.document.get(rootDocumentId); @@ -614,7 +614,7 @@ test('can rollback content with rollback permission enabled', {tag: '@release'}, test('can not rollback content with rollback permission disabled', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackPermission(userGroupName, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackDocumentPermission(userGroupName, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -628,7 +628,7 @@ test('can not rollback content with rollback permission disabled', async ({umbra test('can not see delete button in content for userGroup with delete permission disabled and create permission enabled', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithDeletePermissionAndCreatePermission(userGroupName, false, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithDeleteDocumentPermissionAndCreateDocumentPermission(userGroupName, false, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts new file mode 100644 index 000000000000..8359aa57ee6f --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts @@ -0,0 +1,444 @@ +import {ConstantHelper, NotificationConstantHelper, test} from "@umbraco/playwright-testhelpers"; +import {expect} from "@playwright/test"; + +// Element Type +const elementTypeName = 'TestElementTypeForPermissions'; +let elementTypeId = ''; + +// Element +const elementName = 'TestElement'; +const newElementName = 'NewTestElement'; +let elementId = ''; + +// Data Type +const dataTypeName = 'Textstring'; +const elementText = 'This is test element text'; + +// User +const testUser = ConstantHelper.testUserCredentials; +let testUserCookieAndToken = {cookie: "", accessToken: "", refreshToken: ""}; + +// User Group +const userGroupName = 'TestUserGroup'; +let userGroupId = ''; + +test.beforeEach(async ({umbracoApi}) => { + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.element.ensureNameNotExists(newElementName); + await umbracoApi.user.ensureNameNotExists(testUser.name); + await umbracoApi.userGroup.ensureNameNotExists(userGroupName); + const dataType = await umbracoApi.dataType.getByName(dataTypeName); + elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', dataTypeName, dataType.id); + elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, elementText, dataTypeName); +}); + +test.afterEach(async ({umbracoApi}) => { + // Ensure we are logged in to admin + await umbracoApi.loginToAdminUser(testUserCookieAndToken.cookie, testUserCookieAndToken.accessToken, testUserCookieAndToken.refreshToken); + await umbracoApi.element.ensureNameNotExists(elementName); + await umbracoApi.element.ensureNameNotExists(newElementName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); + await umbracoApi.userGroup.ensureNameNotExists(userGroupName); + await umbracoApi.element.emptyRecycleBin(); +}); + +test('can read element with permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.userGroup.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.goToElementWithName(elementName); + + // Assert + await umbracoUi.library.doesElementHaveName(elementName); +}); + +// Currently user can see element even with read permission disabled +test.fixme('can not see element in tree with read permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.userGroup.goToSection(ConstantHelper.sections.library, false); + await umbracoUi.waitForTimeout(ConstantHelper.wait.short); + + // Assert + await umbracoUi.library.isElementInTreeVisible(elementName, false); + await umbracoUi.page.goto(`${umbracoUi.page.url()}/workspace/element/edit/${elementId}`); + await umbracoUi.waitForTimeout(ConstantHelper.wait.minimal); // Wait for workspace to load + await umbracoUi.library.doesElementWorkspaceHaveText('Access denied'); +}); + +// Currently user cannot choose element type to create element even with permission enabled +test.fixme('can create element with create permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithCreateElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(newElementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(newElementName)).toBeTruthy(); + await umbracoUi.library.isElementReadOnly(true); +}); + +test('can not see create action menu with create permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithCreateElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); +}); + +test('can trash element with delete permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithDeleteElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(elementName); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementToBeTrashed(); + + // Assert + await umbracoUi.library.isItemVisibleInRecycleBin(elementName); +}); + +test('can not trash element with delete permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithDeleteElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); +}); + +test('can empty recycle bin with delete permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.moveToRecycleBin(elementId); + userGroupId = await umbracoApi.userGroup.createUserGroupWithDeleteElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickRecycleBinButton(); + await umbracoUi.waitForTimeout(ConstantHelper.wait.medium); + await umbracoUi.library.clickEmptyRecycleBinButton(); + await umbracoUi.library.clickConfirmEmptyRecycleBinButtonAndWaitForRecycleBinToBeEmptied(); + + // Assert + await umbracoUi.library.isItemVisibleInRecycleBin(elementName, false, false); +}); + +test('can not empty recycle bin with delete permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.moveToRecycleBin(elementId); + userGroupId = await umbracoApi.userGroup.createUserGroupWithDeleteElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForRecycleBinVisible(false); +}); + +test('can publish element with publish permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(elementName); + await umbracoUi.library.clickConfirmToPublishButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.published); + expect(await umbracoApi.element.isElementPublished(elementId)).toBeTruthy(); +}); + +test('can not publish element with publish permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); +}); + +test('can unpublish element with unpublish permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.publish(elementId); + expect(await umbracoApi.element.isElementPublished(elementId)).toBeTruthy(); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(elementName); + await umbracoUi.library.clickConfirmToUnpublishButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.unpublished); + expect(await umbracoApi.element.isElementPublished(elementId)).toBeFalsy(); +}); + +test('can not unpublish element with unpublish permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.publish(elementId); + expect(await umbracoApi.element.isElementPublished(elementId)).toBeTruthy(); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); +}); + +test('can update element with update permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.goToElementWithName(elementName); + await umbracoUi.library.isElementReadOnly(false); + await umbracoUi.library.enterElementName(newElementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(newElementName)).toBeTruthy(); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeFalsy(); +}); + +// Currently user can edit element even with update permission disabled +test.fixme('can not update element with update permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + await umbracoUi.library.goToElementWithName(elementName); + + // Assert + await umbracoUi.library.isElementReadOnly(true); +}); + +test('can duplicate element with duplicate permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + const duplicatedElementName = elementName + ' (1)'; + userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicateElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(elementName); + await umbracoUi.library.clickLabelWithName('Elements'); + await umbracoUi.library.clickDuplicateButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.duplicated); + expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy(); + expect(await umbracoApi.element.doesNameExist(duplicatedElementName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(elementName); + await umbracoUi.library.isElementInTreeVisible(duplicatedElementName); + const originalElement = await umbracoApi.element.getByName(elementName); + const duplicatedElement = await umbracoApi.element.getByName(duplicatedElementName); + expect(originalElement.values[0].value).toEqual(duplicatedElement.values[0].value); + + // Clean + await umbracoApi.element.ensureNameNotExists(duplicatedElementName); +}); + +test('can not duplicate element with duplicate permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicateElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); +}); + +test('can move element with move to permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithMoveElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(elementName); + await umbracoUi.library.moveToElementWithName([], elementFolderName); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.moved); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickReloadChildrenActionMenuOption(); + await umbracoUi.library.isCaretButtonVisibleForElementName(elementFolderName, true); + await umbracoUi.library.openElementCaretButtonForName(elementFolderName); + await umbracoUi.library.isChildElementInTreeVisible(elementFolderName, elementName, true); + expect(await umbracoApi.element.getChildrenAmount(elementFolderId)).toEqual(1); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +test('can not move element with move to permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementFolderName = 'TestElementFolder'; + await umbracoApi.element.createDefaultElementFolder(elementFolderName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithMoveElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +// Currently the rollback functionality in elements is not working. +test.fixme('can rollback element with rollback permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackElementPermission(userGroupName); + await umbracoApi.element.publish(elementId); + const updatedTextStringText = 'This is an updated textString text'; + const element = await umbracoApi.element.get(elementId); + element.values[0].value = updatedTextStringText; + await umbracoApi.element.update(elementId, element); + await umbracoApi.element.publish(elementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.goToElementWithName(elementName); + await umbracoUi.library.doesElementPropertyHaveValue(dataTypeName, updatedTextStringText); + await umbracoUi.library.clickInfoTab(); + await umbracoUi.library.clickRollbackButton(); + await umbracoUi.waitForTimeout(ConstantHelper.wait.medium);// Wait for the rollback items to load + await umbracoUi.library.clickLatestRollBackItem(); + await umbracoUi.library.clickRollbackContainerButton(); + + // Assert + await umbracoUi.library.clickContentTab(); + await umbracoUi.library.doesElementPropertyHaveValue(dataTypeName, elementText); +}); + +test('can not rollback element with rollback permission disabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackElementPermission(userGroupName, false); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isActionsMenuForNameVisible(elementName, false); +}); + +// Currently user cannot choose element type to create element even with permission enabled +test.fixme('can create and update element with permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + const updatedElementName = newElementName + ' Updated'; + userGroupId = await umbracoApi.userGroup.createUserGroupWithCreateAndUpdateElementPermission(userGroupName); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickActionsMenuAtRoot(); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(newElementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(newElementName)).toBeTruthy(); + // Update the element + await umbracoUi.library.goToElementWithName(newElementName); + await umbracoUi.library.isElementReadOnly(false); + await umbracoUi.library.enterElementName(updatedElementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + expect(await umbracoApi.element.doesNameExist(updatedElementName)).toBeTruthy(); + await umbracoUi.library.doesElementHaveName(updatedElementName); + + // Cleanup + await umbracoApi.element.ensureNameNotExists(updatedElementName); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermission.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermission.spec.ts index a0c5b0d929fb..4a2264174a71 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermission.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermission.spec.ts @@ -30,7 +30,7 @@ test.afterEach(async ({umbracoApi}) => { test('cannot see property values without UI read permission', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermissionAndReadPropertyValuePermission(userGroupName, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermissionAndReadPropertyValueDocumentPermission(userGroupName, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -45,7 +45,7 @@ test('cannot see property values without UI read permission', async ({umbracoApi test('can see property values with UI read but not UI write permission', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermissionAndReadPropertyValuePermission(userGroupName, true, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermissionAndReadPropertyValueDocumentPermission(userGroupName, true, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -61,7 +61,7 @@ test('can see property values with UI read but not UI write permission', {tag: ' // Skip this test due to this issue: https://github.com/umbraco/Umbraco-CMS/issues/20505 test.skip('cannot open content without document read permission even with UI read permission', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermissionAndReadPropertyValuePermission(userGroupName, false, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermissionAndReadPropertyValueDocumentPermission(userGroupName, false, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -76,7 +76,7 @@ test.skip('cannot open content without document read permission even with UI rea test('cannot edit property values without UI write permission', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -93,7 +93,7 @@ test('cannot edit property values without UI write permission', async ({umbracoA test('can edit property values with UI write permission', async ({umbracoApi, umbracoUi}) => { // Arrange const updatedText = 'Updated test text'; - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -112,7 +112,7 @@ test('can edit property values with UI write permission', async ({umbracoApi, um test('cannot see property values with only UI write but no UI read permission', async ({umbracoApi, umbracoUi}) => { // Arrange - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermissionInBlock.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermissionInBlock.spec.ts index 25236fc7f0ce..0c23182449eb 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermissionInBlock.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DocumentPropertyValuePermissionInBlock.spec.ts @@ -34,7 +34,7 @@ test.afterEach(async ({umbracoApi}) => { test('can see property values in block list with UI read but not UI write permission', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange await umbracoApi.document.createDefaultDocumentWithABlockListEditor(documentName, elementTypeId, documentTypeName, customDataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermissionAndReadPropertyValuePermission(userGroupName, true, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermissionAndReadPropertyValueDocumentPermission(userGroupName, true, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -55,7 +55,7 @@ test.skip('can edit property values in block list with UI write permission', {ta // Arrange const updatedText = 'Updated test text'; await umbracoApi.document.createDefaultDocumentWithABlockListEditor(documentName, elementTypeId, documentTypeName, customDataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -77,7 +77,7 @@ test.skip('can edit property values in block list with UI write permission', {ta test('cannot see property values in block list with only UI write but no UI read permission', async ({umbracoApi, umbracoUi}) => { // Arrange await umbracoApi.document.createDefaultDocumentWithABlockListEditor(documentName, elementTypeId, documentTypeName, customDataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -93,7 +93,7 @@ test('cannot see property values in block list with only UI write but no UI read test('can see property values in block grid with UI read but not UI write permission', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange await umbracoApi.document.createDefaultDocumentWithABlockGridEditor(documentName, elementTypeId, documentTypeName, customDataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermissionAndReadPropertyValuePermission(userGroupName, true, true); + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadDocumentPermissionAndReadPropertyValueDocumentPermission(userGroupName, true, true); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -114,7 +114,7 @@ test.skip('can edit property values in block grid with UI write permission', {ta // Arrange const updatedText = 'Updated test text'; await umbracoApi.document.createDefaultDocumentWithABlockGridEditor(documentName, elementTypeId, documentTypeName, customDataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); @@ -136,7 +136,7 @@ test.skip('can edit property values in block grid with UI write permission', {ta test('cannot see property values in block grid with only UI write but no UI read permission', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange await umbracoApi.document.createDefaultDocumentWithABlockGridEditor(documentName, elementTypeId, documentTypeName, customDataTypeName); - userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionAndWritePropertyValuePermission(userGroupName, true, true, false); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateDocumentPermissionAndWritePropertyValueDocumentPermission(userGroupName, true, true, false); await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); await umbracoUi.goToBackOffice(); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/ElementStartNodes.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/ElementStartNodes.spec.ts new file mode 100644 index 000000000000..2bdf6e9be738 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/ElementStartNodes.spec.ts @@ -0,0 +1,86 @@ +import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; + +const testUser = ConstantHelper.testUserCredentials; +let testUserCookieAndToken = {cookie: '', accessToken: '', refreshToken: ''}; + +const userGroupName = 'TestUserGroup'; +let userGroupId = null; + +let rootFolderId = null; +let childElementOneId = null; +const rootFolderName = 'RootFolder'; +const childElementOneName = 'ChildElementOne'; +const childElementTwoName = 'ChildElementTwo'; +const elementTypeName = 'TestElementType'; +let elementTypeId = null; + +test.beforeEach(async ({umbracoApi}) => { + elementTypeId = await umbracoApi.documentType.createEmptyElementType(elementTypeName); + rootFolderId = await umbracoApi.element.createDefaultElementFolder(rootFolderName); + childElementOneId = await umbracoApi.element.createDefaultElementWithParent(childElementOneName, elementTypeId, rootFolderId); + await umbracoApi.element.createDefaultElementWithParent(childElementTwoName, elementTypeId, rootFolderId); +}); + +test.afterEach(async ({umbracoApi}) => { + // Ensure we are logged in to admin + await umbracoApi.loginToAdminUser(testUserCookieAndToken.cookie, testUserCookieAndToken.accessToken, testUserCookieAndToken.refreshToken); + await umbracoApi.user.ensureNameNotExists(testUser.name); + await umbracoApi.userGroup.ensureNameNotExists(userGroupName); + await umbracoApi.element.ensureNameNotExists(childElementOneName); + await umbracoApi.element.ensureNameNotExists(childElementTwoName); + await umbracoApi.element.ensureNameNotExists(rootFolderName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); +}); + +// Currently user only see the parent and cannot see the element children +test.fixme('can see root element start node and children', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithElementStartNode(userGroupName, rootFolderId); + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isElementInTreeVisible(rootFolderName); + await umbracoUi.library.openElementCaretButtonForName(rootFolderName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementOneName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementTwoName); +}); + +// Skip this test since currently the front-end does not support adding a specific element as start nodes +test.skip('can see parent of start node but not access it', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithElementStartNode(userGroupName, childElementOneId); + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isElementInTreeVisible(rootFolderName); + await umbracoUi.library.goToElementWithName(rootFolderName); + await umbracoUi.waitForTimeout(ConstantHelper.wait.short); // Wait for workspace to load + await umbracoUi.library.doesElementWorkspaceHaveText('Access denied'); + await umbracoUi.library.openElementCaretButtonForName(rootFolderName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementOneName); + await umbracoUi.library.isChildElementInTreeVisible(rootFolderName, childElementTwoName, false); +}); + +test('can not see any element when no element start nodes specified', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createSimpleUserGroupWithLibrarySection(userGroupName); + await umbracoApi.user.setUserPermissionsForElement(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + + // Act + await umbracoUi.user.goToSection(ConstantHelper.sections.library, false); + + // Assert + await umbracoUi.library.isElementInTreeVisible(rootFolderName, false); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/GranularPermissionsInElement.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/GranularPermissionsInElement.spec.ts new file mode 100644 index 000000000000..6a0d10b6b019 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/GranularPermissionsInElement.spec.ts @@ -0,0 +1,256 @@ +import {ConstantHelper, NotificationConstantHelper, test} from "@umbraco/playwright-testhelpers"; +import {expect} from "@playwright/test"; + +// Element Type +const elementTypeName = 'TestElementType3'; +let elementTypeId = ''; + +// Elements +const firstElementName = 'FirstElement'; +const secondElementName = 'SecondElement'; +let firstElementId = ''; +let secondElementId = ''; + +// Data Type +const dataTypeName = 'Textstring'; +const elementText = 'This is test element text'; + +// User +const testUser = ConstantHelper.testUserCredentials; +let testUserCookieAndToken = {cookie: "", accessToken: "", refreshToken: ""}; + +// User Group +const userGroupName = 'TestUserGroup'; +let userGroupId = ''; + +test.beforeEach(async ({umbracoApi}) => { + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); + await umbracoApi.element.ensureNameNotExists(firstElementName); + await umbracoApi.element.ensureNameNotExists(secondElementName); + await umbracoApi.user.ensureNameNotExists(testUser.name); + await umbracoApi.userGroup.ensureNameNotExists(userGroupName); + const dataType = await umbracoApi.dataType.getByName(dataTypeName); + elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', dataTypeName, dataType.id); + firstElementId = await umbracoApi.element.createElementWithTextContent(firstElementName, elementTypeId, elementText, dataTypeName); + secondElementId = await umbracoApi.element.createElementWithTextContent(secondElementName, elementTypeId, elementText, dataTypeName); +}); + +test.afterEach(async ({umbracoApi}) => { + //Ensure we are logged in to admin + await umbracoApi.loginToAdminUser(testUserCookieAndToken.cookie, testUserCookieAndToken.accessToken, testUserCookieAndToken.refreshToken); + await umbracoApi.element.ensureNameNotExists(firstElementName); + await umbracoApi.element.ensureNameNotExists(secondElementName); + await umbracoApi.documentType.ensureNameNotExists(elementTypeName); + await umbracoApi.userGroup.ensureNameNotExists(userGroupName); + await umbracoApi.element.emptyRecycleBin(); +}); + +test.fixme('can read a specific element with read permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithReadPermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.userGroup.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.goToElementWithName(firstElementName); + + // Assert + await umbracoUi.library.doesElementHaveName(firstElementName); + // TODO: Uncomment this when front-end is ready, currently the element with read permission disabled is not hidden in the tree + await umbracoUi.library.isElementInTreeVisible(secondElementName, false); +}); + +// Currently the delete functionality in elements is not working +test.fixme('can trash a specific element with delete permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithDeletePermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(firstElementName); + await umbracoUi.library.clickConfirmTrashButtonAndWaitForElementToBeTrashed(); + + // Assert + await umbracoUi.library.isItemVisibleInRecycleBin(firstElementName); + +}); + +test('can publish a specific element with publish permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishPermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(firstElementName); + await umbracoUi.library.clickConfirmToPublishButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.published); + expect(await umbracoApi.element.isElementPublished(firstElementId)).toBeTruthy(); + await umbracoUi.library.isEntityActionForElementWithNameHidden(secondElementName); +}); + +test('can unpublish a specific element with unpublish permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.element.publish(firstElementId); + await umbracoApi.element.publish(secondElementId); + expect(await umbracoApi.element.isElementPublished(firstElementId)).toBeTruthy(); + expect(await umbracoApi.element.isElementPublished(secondElementId)).toBeTruthy(); + userGroupId = await umbracoApi.userGroup.createUserGroupWithUnpublishPermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(firstElementName); + await umbracoUi.library.clickConfirmToUnpublishButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.unpublished); + expect(await umbracoApi.element.isElementPublished(firstElementId)).toBeFalsy(); + await umbracoUi.library.isEntityActionForElementWithNameHidden(secondElementName); +}); + +// When the update permission for an element is disabled, the element is still editable; only the “Save” button is hidden. +test.fixme('can update a specific element with update permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + const newElementName = 'UpdatedElement'; + userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdatePermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.goToElementWithName(firstElementName); + await umbracoUi.library.isElementReadOnly(false); + await umbracoUi.library.enterElementName(newElementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeUpdated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(newElementName)).toBeTruthy(); + await umbracoUi.library.goToElementWithName(secondElementName); + await umbracoUi.library.isActionsMenuForNameVisible(secondElementName, false); + await umbracoUi.library.isElementReadOnly(true); + + // Clean + await umbracoApi.element.ensureNameNotExists(newElementName); +}); + +test.fixme('can duplicate a specific element with duplicate permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + const duplicatedElementName = firstElementName + ' (1)'; + userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicatePermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(firstElementName); + await umbracoUi.library.clickLabelWithName('Elements'); + await umbracoUi.library.clickDuplicateButton(); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.duplicated); + expect(await umbracoApi.element.doesNameExist(firstElementName)).toBeTruthy(); + expect(await umbracoApi.element.doesNameExist(duplicatedElementName)).toBeTruthy(); + await umbracoUi.library.isEntityActionForElementWithNameHidden(secondElementName); + + // Clean + await umbracoApi.element.ensureNameNotExists(duplicatedElementName); +}); + +test('can move a specific element with move permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + userGroupId = await umbracoApi.userGroup.createUserGroupWithMovePermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickEntityActionOnElementWithName(firstElementName); + await umbracoUi.library.moveToElementWithName([], elementFolderName); + + // Assert + await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.moved); + await umbracoUi.library.clickActionsMenuForElement(elementFolderName); + await umbracoUi.library.clickReloadChildrenActionMenuOption(); + await umbracoUi.library.isCaretButtonVisibleForElementName(elementFolderName, true); + await umbracoUi.library.openElementCaretButtonForName(elementFolderName); + await umbracoUi.library.isChildElementInTreeVisible(elementFolderName, firstElementName, true); + expect(await umbracoApi.element.getChildrenAmount(elementFolderId)).toEqual(1); + await umbracoUi.library.isEntityActionForElementWithNameHidden(secondElementName); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +// Currently the rollback functionality in elements is not working +test.fixme('can rollback a specific element with rollback permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackPermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.element.publish(firstElementId); + const updatedTextStringText = 'This is an updated textString text'; + const element = await umbracoApi.element.get(firstElementId); + element.values[0].value = updatedTextStringText; + await umbracoApi.element.update(firstElementId, element); + await umbracoApi.element.publish(firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.goToElementWithName(firstElementName); + await umbracoUi.library.doesElementPropertyHaveValue(dataTypeName, updatedTextStringText); + await umbracoUi.library.clickInfoTab(); + await umbracoUi.library.clickRollbackButton(); + await umbracoUi.waitForTimeout(ConstantHelper.wait.medium); + await umbracoUi.library.clickLatestRollBackItem(); + await umbracoUi.library.clickRollbackContainerButton(); + + // Assert + await umbracoUi.library.clickContentTab(); + await umbracoUi.library.doesElementPropertyHaveValue(dataTypeName, elementText); + await umbracoUi.library.isElementInTreeVisible(secondElementName, false); +}); + +// Currently user cannot choose element type to create element even with permission enabled +test.fixme('can create element from a specific element with create permission enabled', async ({umbracoApi, umbracoUi}) => { + // Arrange + const newElementName = 'NewElement'; + userGroupId = await umbracoApi.userGroup.createUserGroupWithCreatePermissionForSpecificElement(userGroupName, firstElementId); + await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId); + testUserCookieAndToken = await umbracoApi.user.loginToUser(testUser.name, testUser.email, testUser.password); + await umbracoUi.goToBackOffice(); + await umbracoUi.library.goToSection(ConstantHelper.sections.library, false); + + // Act + await umbracoUi.library.clickActionsMenuForElement(firstElementName); + await umbracoUi.library.clickCreateActionMenuOption(); + await umbracoUi.library.clickElementButton(); + await umbracoUi.library.clickModalMenuItemWithName(elementTypeName); + await umbracoUi.library.clickChooseModalButton(); + await umbracoUi.library.enterElementName(newElementName); + await umbracoUi.library.clickSaveButtonAndWaitForElementToBeCreated(); + + // Assert + expect(await umbracoApi.element.doesNameExist(newElementName)).toBeTruthy(); + await umbracoUi.library.isElementInTreeVisible(secondElementName, false); + + // Clean + await umbracoApi.element.ensureNameNotExists(newElementName); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/User.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/User.spec.ts index dd301e7c0ab8..fd726fee83d2 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/User.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/User.spec.ts @@ -609,4 +609,68 @@ test('cannot remove all user group from a user', {tag: '@release'}, async ({umbr // Assert await umbracoUi.user.isErrorNotificationVisible(); -}); \ No newline at end of file +}); + +// Currently user cannot add a element folder as start node +test.fixme('can add an element start node to a user', async ({umbracoApi, umbracoUi}) => { + // Arrange + const userGroup = await umbracoApi.userGroup.getByName(defaultUserGroupName); + await umbracoApi.user.createDefaultUser(nameOfTheUser, userEmail, [userGroup.id]); + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + await umbracoUi.user.goToUserWithName(nameOfTheUser); + + // Act + await umbracoUi.user.clickChooseElementStartNodeButton(); + await umbracoUi.user.clickButtonWithName(elementFolderName); + await umbracoUi.user.clickChooseContainerButton(); + await umbracoUi.user.clickSaveButtonAndWaitForUserToBeUpdated(); + + // Assert + expect(await umbracoApi.user.doesUserContainElementStartNodeIds(nameOfTheUser, [elementFolderId])).toBeTruthy(); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +// Currently user cannot add a element folder as start node +test.fixme('can remove an element start node from a user', async ({umbracoApi, umbracoUi}) => { + // Arrange + const userGroup = await umbracoApi.userGroup.getByName(defaultUserGroupName); + const userId = await umbracoApi.user.createDefaultUser(nameOfTheUser, userEmail, [userGroup.id]); + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + // Adds the element start node to the user + const userData = await umbracoApi.user.getByName(nameOfTheUser); + userData.elementStartNodeIds.push({id: elementFolderId}); + await umbracoApi.user.update(userId, userData); + expect(await umbracoApi.user.doesUserContainElementStartNodeIds(nameOfTheUser, [elementFolderId])).toBeTruthy(); + await umbracoUi.user.goToUserWithName(nameOfTheUser); + + // Act + await umbracoUi.user.clickRemoveButtonForElementNodeWithName(elementFolderName); + await umbracoUi.user.clickConfirmRemoveButton(); + await umbracoUi.user.clickSaveButtonAndWaitForUserToBeUpdated(); + + // Assert + expect(await umbracoApi.user.doesUserContainElementStartNodeIds(nameOfTheUser, [elementFolderId])).toBeFalsy(); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +// Currently element start node configuration is not saved after updating +test.fixme('can allow access to all elements for a user', async ({umbracoApi, umbracoUi}) => { + // Arrange + const userGroup = await umbracoApi.userGroup.getByName(defaultUserGroupName); + await umbracoApi.user.createDefaultUser(nameOfTheUser, userEmail, [userGroup.id]); + await umbracoUi.user.goToUserWithName(nameOfTheUser); + + // Act + await umbracoUi.user.clickAllowAccessToAllElements(); + await umbracoUi.user.clickSaveButtonAndWaitForUserToBeUpdated(); + + // Assert + const userData = await umbracoApi.user.getByName(nameOfTheUser); + expect(userData.hasElementRootAccess).toBeTruthy(); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroups.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroups.spec.ts index 7c72febfe881..be6fce5d442c 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroups.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroups.spec.ts @@ -2,36 +2,59 @@ import {ConstantHelper, test} from '@umbraco/playwright-testhelpers'; import {expect} from "@playwright/test"; const allPermissions = { - uiPermission: - ['Read', - 'Create Document Blueprint', - 'Delete', - 'Create', - 'Notifications', - 'Publish', - 'Unpublish', - 'Update', - 'Duplicate', - 'Move to', - 'Sort children', - 'Culture and Hostnames', - 'Public Access', - 'Rollback'], - verbPermission: [ - 'Umb.Document.Read', - 'Umb.Document.CreateBlueprint', - 'Umb.Document.Delete', - 'Umb.Document.Create', - 'Umb.Document.Notifications', - 'Umb.Document.Publish', - 'Umb.Document.Unpublish', - 'Umb.Document.Update', - 'Umb.Document.Duplicate', - 'Umb.Document.Move', - 'Umb.Document.Sort', - 'Umb.Document.CultureAndHostnames', - 'Umb.Document.PublicAccess', - 'Umb.Document.Rollback' + uiDocumentPermission: [ + "Read", + "Create Document Blueprint", + "Delete", + "Create", + "Notifications", + "Publish", + "Unpublish", + "Update", + "Duplicate", + "Move to", + "Sort children", + "Culture and Hostnames", + "Public Access", + "Rollback", + ], + verbDocumentPermission: [ + "Umb.Document.Read", + "Umb.Document.CreateBlueprint", + "Umb.Document.Delete", + "Umb.Document.Create", + "Umb.Document.Notifications", + "Umb.Document.Publish", + "Umb.Document.Unpublish", + "Umb.Document.Update", + "Umb.Document.Duplicate", + "Umb.Document.Move", + "Umb.Document.Sort", + "Umb.Document.CultureAndHostnames", + "Umb.Document.PublicAccess", + "Umb.Document.Rollback", + ], + uiElementPermission: [ + "Read", + "Create", + "Delete", + "Publish", + "Unpublish", + "Update", + "Duplicate", + "Move", + "Rollback", + ], + verbElementPermission: [ + "Umb.Element.Read", + "Umb.Element.Create", + "Umb.Element.Delete", + "Umb.Element.Publish", + "Umb.Element.Unpublish", + "Umb.Element.Update", + "Umb.Element.Duplicate", + "Umb.Element.Move", + "Umb.Element.Rollback", ] }; @@ -90,14 +113,14 @@ test('can update a user group', {tag: '@release'}, async ({umbracoApi, umbracoUi await umbracoUi.userGroup.clickUserGroupWithName(userGroupName); // Act - await umbracoUi.userGroup.clickPermissionsByName([allPermissions.uiPermission[0]]); + await umbracoUi.userGroup.clickDocumentPermissionsByName([allPermissions.uiDocumentPermission[0]]); await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); // Assert await umbracoUi.reloadPage(); - await umbracoUi.userGroup.doesUserGroupHavePermission(allPermissions.uiPermission[0]); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermission(allPermissions.uiDocumentPermission[0]); const userGroupData = await umbracoApi.userGroup.getByName(userGroupName); - expect(userGroupData.fallbackPermissions).toContain(allPermissions.verbPermission[0]); + expect(userGroupData.fallbackPermissions).toContain(allPermissions.verbDocumentPermission[0]); }); test('can delete a user group', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { @@ -365,14 +388,17 @@ test('can enable all permissions for a user group', async ({umbracoApi, umbracoU // Act await umbracoUi.userGroup.clickUserGroupsButton(); await umbracoUi.userGroup.clickUserGroupWithName(userGroupName); - await umbracoUi.userGroup.clickPermissionsByName(allPermissions.uiPermission); + await umbracoUi.userGroup.clickDocumentPermissionsByName(allPermissions.uiDocumentPermission); + await umbracoUi.userGroup.clickElementPermissionsByName(allPermissions.uiElementPermission); await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); // Assert await umbracoUi.reloadPage(); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(allPermissions.uiPermission); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(allPermissions.uiDocumentPermission); + await umbracoUi.userGroup.doesUserGroupHaveElementPermissionEnabled(allPermissions.uiElementPermission); const userGroupData = await umbracoApi.userGroup.getByName(userGroupName); - expect(userGroupData.fallbackPermissions).toEqual(allPermissions.verbPermission); + const allFallbackPermissions = [...allPermissions.verbDocumentPermission, ...allPermissions.verbElementPermission]; + expect(userGroupData.fallbackPermissions).toEqual(allFallbackPermissions); }); test('can add granular permission to a specific document for a user group', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { @@ -389,12 +415,12 @@ test('can add granular permission to a specific document for a user group', {tag // Act await umbracoUi.userGroup.clickAddGranularPermission(); await umbracoUi.userGroup.clickLabelWithName(documentName); - await umbracoUi.userGroup.clickGranularPermissionsByName([allPermissions.uiPermission[0]]); + await umbracoUi.userGroup.clickGranularPermissionsByName([allPermissions.uiDocumentPermission[0]]); await umbracoUi.userGroup.clickConfirmButton(); await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); // Assert - expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, [allPermissions.verbPermission[0]])).toBeTruthy(); + expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, [allPermissions.verbDocumentPermission[0]])).toBeTruthy(); // Clean await umbracoApi.document.ensureNameNotExists(documentTypeName); @@ -414,15 +440,15 @@ test('can add all granular permissions to a specific document for a user group', // Act await umbracoUi.userGroup.clickAddGranularPermission(); await umbracoUi.userGroup.clickLabelWithName(documentName); - await umbracoUi.userGroup.clickGranularPermissionsByName(allPermissions.uiPermission); + await umbracoUi.userGroup.clickGranularPermissionsByName(allPermissions.uiDocumentPermission); await umbracoUi.userGroup.clickConfirmButton(); await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); // Assert await umbracoUi.reloadPage(); await umbracoUi.userGroup.clickGranularPermissionWithName(documentName); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(allPermissions.uiPermission); - expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, allPermissions.verbPermission)).toBeTruthy(); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(allPermissions.uiDocumentPermission); + expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, allPermissions.verbDocumentPermission)).toBeTruthy(); // Clean await umbracoApi.document.ensureNameNotExists(documentTypeName); @@ -436,7 +462,7 @@ test('can remove granular permission to a specific document for a user group', a const documentTypeId = await umbracoApi.documentType.createDefaultDocumentTypeWithAllowAsRoot(documentTypeName); const documentId = await umbracoApi.document.createDefaultDocument(documentName, documentTypeId); await umbracoApi.userGroup.createUserGroupWithPermissionsForSpecificDocumentWithRead(userGroupName, documentId); - expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, [allPermissions.verbPermission[0]])).toBeTruthy(); + expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, [allPermissions.verbDocumentPermission[0]])).toBeTruthy(); await umbracoUi.userGroup.clickUserGroupsButton(); await umbracoUi.userGroup.clickUserGroupWithName(userGroupName); @@ -445,8 +471,66 @@ test('can remove granular permission to a specific document for a user group', a await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); // Assert - expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, [allPermissions.verbPermission[0]])).toBeFalsy(); + expect(await umbracoApi.userGroup.doesUserGroupContainGranularPermissionsForDocument(userGroupName, documentId, [allPermissions.verbDocumentPermission[0]])).toBeFalsy(); // Clean await umbracoApi.document.ensureNameNotExists(documentTypeName); -}); \ No newline at end of file +}); + +// Currently element start nodes are not working correctly +test.fixme('can add an element start node to a user group', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.userGroup.createEmptyUserGroup(userGroupName); + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + await umbracoUi.userGroup.clickUserGroupsButton(); + await umbracoUi.userGroup.clickUserGroupWithName(userGroupName); + + // Act + await umbracoUi.userGroup.clickChooseElementStartNodeButton(); + await umbracoUi.userGroup.clickLabelWithName(elementFolderName); + await umbracoUi.userGroup.clickChooseContainerButton(); + await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); + + // Assert + expect(await umbracoApi.userGroup.doesUserGroupContainElementStartNodeId(userGroupName, elementFolderId)).toBeTruthy(); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +// Currently element start nodes are not working correctly +test.fixme('can remove an element start node from a user group', async ({umbracoApi, umbracoUi}) => { + // Arrange + const elementFolderName = 'TestElementFolder'; + const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName); + await umbracoApi.userGroup.createUserGroupWithElementStartNode(userGroupName, elementFolderId); + expect(await umbracoApi.userGroup.doesUserGroupContainElementStartNodeId(userGroupName, elementFolderId)).toBeTruthy(); + await umbracoUi.userGroup.clickUserGroupsButton(); + await umbracoUi.userGroup.clickUserGroupWithName(userGroupName); + + // Act + await umbracoUi.userGroup.clickRemoveButtonForElementNodeWithName(elementFolderName); + await umbracoUi.userGroup.clickConfirmRemoveButton(); + await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); + + // Assert + expect(await umbracoApi.userGroup.doesUserGroupContainElementStartNodeId(userGroupName, elementFolderId)).toBeFalsy(); + + // Clean + await umbracoApi.element.ensureNameNotExists(elementFolderName); +}); + +test('can enable access to all elements in a user group', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.userGroup.createEmptyUserGroup(userGroupName); + await umbracoUi.userGroup.clickUserGroupsButton(); + await umbracoUi.userGroup.clickUserGroupWithName(userGroupName); + + // Act + await umbracoUi.userGroup.clickAllowAccessToAllElements(); + await umbracoUi.userGroup.clickSaveButtonAndWaitForUserGroupToBeUpdated(); + + // Assert + expect(await umbracoApi.userGroup.doesUserGroupContainElementRootAccess(userGroupName)).toBeTruthy(); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroupsDefaultConfiguration.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroupsDefaultConfiguration.spec.ts index 286e26cc88b9..0b3bd6384932 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroupsDefaultConfiguration.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/UserGroupsDefaultConfiguration.spec.ts @@ -17,9 +17,10 @@ test('the default configuration of Administrators is correct', {tag: '@release'} "Umb.Section.Packages", "Umb.Section.Settings", "Umb.Section.Translation", - "Umb.Section.Users" + "Umb.Section.Users", + "Umb.Section.Library" ]; - const fallbackPermissions = [ + const fallbackDocumentPermissions = [ "Umb.Document.Create", "Umb.Document.Update", "Umb.Document.Delete", @@ -35,11 +36,23 @@ test('the default configuration of Administrators is correct', {tag: '@release'} "Umb.Document.CreateBlueprint", "Umb.Document.Notifications", ]; + const fallbackElementPermissions = [ + "Umb.Element.Create", + "Umb.Element.Update", + "Umb.Element.Delete", + "Umb.Element.Move", + "Umb.Element.Duplicate", + "Umb.Element.Publish", + "Umb.Element.Unpublish", + "Umb.Element.Read", + "Umb.Element.Rollback", + ]; const granularPermissions: any = []; const hasAccessToAllLanguages = true; const documentRootAccess = true; const mediaRootAccess = true; - const uiPermissions = await umbracoApi.userGroup.convertApiPermissionsToUiPermissions(fallbackPermissions); + const uiDocumentPermissions = await umbracoApi.userGroup.convertApiDocumentPermissionsToUiDocumentPermissions(fallbackDocumentPermissions); + const uiElementPermissions = await umbracoApi.userGroup.convertApiElementPermissionsToUiElementPermissions(fallbackElementPermissions); const uiSections = await umbracoApi.userGroup.convertApiSectionsToUiSections(sections); // Act @@ -49,8 +62,10 @@ test('the default configuration of Administrators is correct', {tag: '@release'} await umbracoUi.userGroup.doesSettingHaveValue('Assign access', ConstantHelper.userGroupAssignAccessSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document permissions', ConstantHelper.userGroupDefaultPermissionsSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document Property Value permissions', ConstantHelper.userGroupGranularPermissionsSettings); - await umbracoUi.userGroup.doesPermissionsSettingsHaveValue(ConstantHelper.userGroupPermissionsSettings); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(uiPermissions); + await umbracoUi.userGroup.doesDocumentPermissionsSettingsHaveValue(ConstantHelper.userGroupDocumentPermissionsSettings); + await umbracoUi.userGroup.doesElementPermissionsSettingsHaveValue(ConstantHelper.userGroupElementPermissionsSettings); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(uiDocumentPermissions); + await umbracoUi.userGroup.doesUserGroupHaveElementPermissionEnabled(uiElementPermissions); await umbracoUi.userGroup.doesUserGroupHaveSections(uiSections); await umbracoUi.userGroup.doesUserGroupSectionsHaveCount(uiSections.length); // Fixme - Uncomment this when the front-end is ready. Currently the sections includes "Umb.Section.Forms" which should be removed. @@ -69,9 +84,10 @@ test('the default configuration of Editors is correct', {tag: '@release'}, async const userGroupName = 'Editors'; const sections = [ "Umb.Section.Content", - "Umb.Section.Media" + "Umb.Section.Media", + "Umb.Section.Library" ]; - const fallbackPermissions = [ + const fallbackDocumentPermissions = [ "Umb.Document.Create", "Umb.Document.Update", "Umb.Document.Delete", @@ -86,11 +102,23 @@ test('the default configuration of Editors is correct', {tag: '@release'}, async "Umb.Document.CreateBlueprint", "Umb.Document.Notifications", ]; + const fallbackElementPermissions = [ + "Umb.Element.Create", + "Umb.Element.Update", + "Umb.Element.Delete", + "Umb.Element.Move", + "Umb.Element.Duplicate", + "Umb.Element.Publish", + "Umb.Element.Unpublish", + "Umb.Element.Read", + "Umb.Element.Rollback", + ]; const granularPermissions: string[] = []; const hasAccessToAllLanguages = true; const documentRootAccess = true; const mediaRootAccess = true; - const uiPermissions = await umbracoApi.userGroup.convertApiPermissionsToUiPermissions(fallbackPermissions); + const uiDocumentPermissions = await umbracoApi.userGroup.convertApiDocumentPermissionsToUiDocumentPermissions(fallbackDocumentPermissions); + const uiElementPermissions = await umbracoApi.userGroup.convertApiElementPermissionsToUiElementPermissions(fallbackElementPermissions); const uiSections = await umbracoApi.userGroup.convertApiSectionsToUiSections(sections); // Act @@ -98,10 +126,12 @@ test('the default configuration of Editors is correct', {tag: '@release'}, async // Act await umbracoUi.userGroup.doesSettingHaveValue('Assign access', ConstantHelper.userGroupAssignAccessSettings); - await umbracoUi.userGroup.doesSettingHaveValue('Document permissions', ConstantHelper.userGroupDefaultPermissionsSettings); + await umbracoUi.userGroup.doesSettingHaveValue('Document permissions', ConstantHelper.userGroupDefaultPermissionsSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document Property Value permissions', ConstantHelper.userGroupGranularPermissionsSettings); - await umbracoUi.userGroup.doesPermissionsSettingsHaveValue(ConstantHelper.userGroupPermissionsSettings); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(uiPermissions); + await umbracoUi.userGroup.doesDocumentPermissionsSettingsHaveValue(ConstantHelper.userGroupDocumentPermissionsSettings); + await umbracoUi.userGroup.doesElementPermissionsSettingsHaveValue(ConstantHelper.userGroupElementPermissionsSettings); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(uiDocumentPermissions); + await umbracoUi.userGroup.doesUserGroupHaveElementPermissionEnabled(uiElementPermissions); await umbracoUi.userGroup.doesUserGroupHaveSections(uiSections); await umbracoUi.userGroup.doesUserGroupSectionsHaveCount(uiSections.length); // Fixme - Uncomment this when the front-end is ready. Currently the sections includes "Umb.Section.Forms" which should be removed. @@ -119,12 +149,14 @@ test('the default configuration of Sensitive data is correct', {tag: '@release'} // Arrange const userGroupName = 'Sensitive data'; const sections: string[] = []; - const fallbackPermissions: string[] = []; + const fallbackDocumentPermissions: string[] = []; + const fallbackElementPermissions: string[] = []; const granularPermissions: string[] = []; const hasAccessToAllLanguages = false; const documentRootAccess = false; const mediaRootAccess = false; - const uiPermissions = await umbracoApi.userGroup.convertApiPermissionsToUiPermissions(fallbackPermissions); + const uiDocumentPermissions = await umbracoApi.userGroup.convertApiDocumentPermissionsToUiDocumentPermissions(fallbackDocumentPermissions); + const uiElementPermissions = await umbracoApi.userGroup.convertApiElementPermissionsToUiElementPermissions(fallbackElementPermissions); const uiSections = await umbracoApi.userGroup.convertApiSectionsToUiSections(sections); // Act @@ -134,8 +166,10 @@ test('the default configuration of Sensitive data is correct', {tag: '@release'} await umbracoUi.userGroup.doesSettingHaveValue('Assign access', ConstantHelper.userGroupAssignAccessSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document permissions', ConstantHelper.userGroupDefaultPermissionsSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document Property Value permissions', ConstantHelper.userGroupGranularPermissionsSettings); - await umbracoUi.userGroup.doesPermissionsSettingsHaveValue(ConstantHelper.userGroupPermissionsSettings); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(uiPermissions); + await umbracoUi.userGroup.doesDocumentPermissionsSettingsHaveValue(ConstantHelper.userGroupDocumentPermissionsSettings); + await umbracoUi.userGroup.doesElementPermissionsSettingsHaveValue(ConstantHelper.userGroupElementPermissionsSettings); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(uiDocumentPermissions); + await umbracoUi.userGroup.doesUserGroupHaveElementPermissionEnabled(uiElementPermissions); await umbracoUi.userGroup.doesUserGroupHaveSections(uiSections); await umbracoUi.userGroup.doesUserGroupSectionsHaveCount(uiSections.length); // Fixme - Uncomment this when the front-end is ready. Currently the sections includes "Umb.Section.Forms" which should be removed. @@ -153,15 +187,20 @@ test('the default configuration of Translators data is correct', {tag: '@release // Arrange const userGroupName = 'Translators'; const sections = ["Umb.Section.Translation"]; - const fallbackPermissions = [ + const fallbackDocumentPermissions = [ "Umb.Document.Update", "Umb.Document.Read", ]; + const fallbackElementPermissions = [ + "Umb.Document.Update", + "Umb.Element.Read", + ]; const granularPermissions: string[] = []; const hasAccessToAllLanguages = true; const documentRootAccess = true; const mediaRootAccess = true; - const uiPermissions = await umbracoApi.userGroup.convertApiPermissionsToUiPermissions(fallbackPermissions); + const uiDocumentPermissions = await umbracoApi.userGroup.convertApiDocumentPermissionsToUiDocumentPermissions(fallbackDocumentPermissions); + const uiElementPermissions = await umbracoApi.userGroup.convertApiElementPermissionsToUiElementPermissions(fallbackElementPermissions); const uiSections = await umbracoApi.userGroup.convertApiSectionsToUiSections(sections); // Act @@ -171,8 +210,10 @@ test('the default configuration of Translators data is correct', {tag: '@release await umbracoUi.userGroup.doesSettingHaveValue('Assign access', ConstantHelper.userGroupAssignAccessSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document permissions', ConstantHelper.userGroupDefaultPermissionsSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document Property Value permissions', ConstantHelper.userGroupGranularPermissionsSettings); - await umbracoUi.userGroup.doesPermissionsSettingsHaveValue(ConstantHelper.userGroupPermissionsSettings); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(uiPermissions); + await umbracoUi.userGroup.doesDocumentPermissionsSettingsHaveValue(ConstantHelper.userGroupDocumentPermissionsSettings); + await umbracoUi.userGroup.doesElementPermissionsSettingsHaveValue(ConstantHelper.userGroupElementPermissionsSettings); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(uiDocumentPermissions); + await umbracoUi.userGroup.doesUserGroupHaveElementPermissionEnabled(uiElementPermissions); await umbracoUi.userGroup.doesUserGroupHaveSections(uiSections); await umbracoUi.userGroup.doesUserGroupSectionsHaveCount(uiSections.length); expect(await umbracoApi.userGroup.doesUserGroupHaveSections(userGroupName, sections)).toBeTruthy(); @@ -188,18 +229,24 @@ test('the default configuration of Translators data is correct', {tag: '@release test('the default configuration of Writers data is correct', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => { // Arrange const userGroupName = 'Writers'; - const sections = ["Umb.Section.Content"]; - const fallbackPermissions = [ + const sections = ["Umb.Section.Content", "Umb.Section.Library"]; + const fallbackDocumentPermissions = [ "Umb.Document.Create", "Umb.Document.Update", "Umb.Document.Read", "Umb.Document.Notifications", ]; + const fallbackElementPermissions = [ + "Umb.Element.Create", + "Umb.Element.Update", + "Umb.Element.Read", + ]; const granularPermissions: string[] = []; const hasAccessToAllLanguages = true; const documentRootAccess = true; const mediaRootAccess = true; - const uiPermissions = await umbracoApi.userGroup.convertApiPermissionsToUiPermissions(fallbackPermissions); + const uiDocumentPermissions = await umbracoApi.userGroup.convertApiDocumentPermissionsToUiDocumentPermissions(fallbackDocumentPermissions); + const uiElementPermissions = await umbracoApi.userGroup.convertApiElementPermissionsToUiElementPermissions(fallbackElementPermissions); const uiSections = await umbracoApi.userGroup.convertApiSectionsToUiSections(sections); // Act @@ -209,8 +256,10 @@ test('the default configuration of Writers data is correct', {tag: '@release'}, await umbracoUi.userGroup.doesSettingHaveValue('Assign access', ConstantHelper.userGroupAssignAccessSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document permissions', ConstantHelper.userGroupDefaultPermissionsSettings); await umbracoUi.userGroup.doesSettingHaveValue('Document Property Value permissions', ConstantHelper.userGroupGranularPermissionsSettings); - await umbracoUi.userGroup.doesPermissionsSettingsHaveValue(ConstantHelper.userGroupPermissionsSettings); - await umbracoUi.userGroup.doesUserGroupHavePermissionEnabled(uiPermissions); + await umbracoUi.userGroup.doesDocumentPermissionsSettingsHaveValue(ConstantHelper.userGroupDocumentPermissionsSettings); + await umbracoUi.userGroup.doesElementPermissionsSettingsHaveValue(ConstantHelper.userGroupElementPermissionsSettings); + await umbracoUi.userGroup.doesUserGroupHaveDocumentPermissionEnabled(uiDocumentPermissions); + await umbracoUi.userGroup.doesUserGroupHaveElementPermissionEnabled(uiElementPermissions); await umbracoUi.userGroup.doesUserGroupHaveSections(uiSections); await umbracoUi.userGroup.doesUserGroupSectionsHaveCount(uiSections.length); expect(await umbracoApi.userGroup.doesUserGroupHaveSections(userGroupName, sections)).toBeTruthy();