From d057626f2909eb5e6ace3665322d42fca6f4f6e4 Mon Sep 17 00:00:00 2001 From: Nhu Dinh <150406148+nhudinh0309@users.noreply.github.com> Date: Mon, 12 Feb 2024 19:59:39 +0700 Subject: [PATCH] V14 Added acceptance tests for DataTypes (#15679) * Fixed failing tests * Updated tests to use the updated helpers * Clean up tests * Enabled our pipeline for E2E testing * Updated the CMS URl for our E2E tests * Bumped version of our testHelpers * Did some fixing, still a bit more to do * Updated auth tests to use LoginUiHelper * Updated Telemetry tests to use TelemetryUiHelper * Updated LogViewer tests to use LogViewerUiHelper * Updated api tests to apply AAA pattern and fix failed tests * Removed unused import * Fixed comments * Bumped version of test helper * Updated the version to 10 instead of 11 * Updated the package-lock.json file to contain the correct versions * Added a waitForTimeout The reason for this is that this test is failing on the pipeline * V14 Added acceptance test for basic functions of Data Type, Approved Color and Label (#15551) * Updated api tests for DataType * Added ui tests for basic functions of DataType * Added ui tests for Approved color * Added ui tests for Label * Fixed comments * V14 Added acceptance tests for Date Picker (#15561) * Updated api tests for DataType * Added ui tests for basic functions of DataType * Added ui tests for Approved color * Added ui tests for Label * Added ui tests for Date Picker * Removed blank line Co-authored-by: Andreas Zerbst <73799582+andr317c@users.noreply.github.com> --------- Co-authored-by: Andreas Zerbst <73799582+andr317c@users.noreply.github.com> * V14 Added acceptance test for List View (#15575) * Updated api tests for DataType * Added ui tests for basic functions of DataType * Added ui tests for Approved color * Added ui tests for Label * Added ui tests for Date Picker * Fix merged * Updated DatePicker and Label tests to apply best practices * Added ui tests for ListView * V14 Added acceptance tests for Image Cropper, Numeric and Radiobox (#15599) * Added ui tests for ImageCropper * Added ui tests for Numeric * Added ui tests for Radiobox * Updated tests for Approved Color to change the way to arrange test data * Change "" to '' and updated before/after methods * V14 Added acceptance test for Textarea, Textstring, Upload (#15606) * Added ui tests for Textarea * Added ui tests for Textstring * Added ui tests for Upload Article, Upload Audio, Upload File, Upload Vector Graphics, Upload Video * Fixed failing tests due to api changes * Changed propertyEditorAlias to editorAlias due to api changes * Removed the step to check notification displays and changed string variables to numeric variables due to api changes * Updated the skip tests * Added skip tests and update method name due to test helper changes * Splited tests out * Bumped version * Changed '' to ' --------- Co-authored-by: Andreas Zerbst Co-authored-by: Andreas Zerbst <73799582+andr317c@users.noreply.github.com> --- .../package-lock.json | 76 +++---- .../Umbraco.Tests.AcceptanceTest/package.json | 2 +- .../ApiTesting/DataType/DataType.spec.ts | 55 +++-- .../DataType/DataTypeFolder.spec.ts | 16 +- .../DataType/ApprovedColor.spec.ts | 102 +++++++++ .../DefaultConfig/DataType/DataType.spec.ts | 83 +++++++ .../DataType/DataTypeFolder.spec.ts | 131 +++++++++++ .../DefaultConfig/DataType/DatePicker.spec.ts | 73 +++++++ .../DataType/ImageCropper.spec.ts | 125 +++++++++++ .../DefaultConfig/DataType/Label.spec.ts | 41 ++++ .../DefaultConfig/DataType/ListView.spec.ts | 204 ++++++++++++++++++ .../DefaultConfig/DataType/Numeric.spec.ts | 72 +++++++ .../DefaultConfig/DataType/Radiobox.spec.ts | 74 +++++++ .../DefaultConfig/DataType/Textarea.spec.ts | 89 ++++++++ .../DefaultConfig/DataType/Textstring.spec.ts | 38 ++++ .../DefaultConfig/DataType/Upload.spec.ts | 79 +++++++ 16 files changed, 1177 insertions(+), 83 deletions(-) create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ApprovedColor.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataType.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataTypeFolder.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DatePicker.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ImageCropper.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Label.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ListView.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Numeric.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Radiobox.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textarea.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textstring.spec.ts create mode 100644 tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Upload.spec.ts diff --git a/tests/Umbraco.Tests.AcceptanceTest/package-lock.json b/tests/Umbraco.Tests.AcceptanceTest/package-lock.json index f6bf8d9533..2707bfddad 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/package-lock.json +++ b/tests/Umbraco.Tests.AcceptanceTest/package-lock.json @@ -8,7 +8,7 @@ "hasInstallScript": true, "dependencies": { "@umbraco/json-models-builders": "^2.0.1 ", - "@umbraco/playwright-testhelpers": "^2.0.0-beta.17", + "@umbraco/playwright-testhelpers": "^2.0.0-beta.18", "camelize": "^1.0.0", "dotenv": "^16.3.1", "faker": "^4.1.0", @@ -87,12 +87,12 @@ } }, "node_modules/@playwright/test": { - "version": "1.39.0", - "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.39.0.tgz", - "integrity": "sha512-3u1iFqgzl7zr004bGPYiN/5EZpRUSFddQBra8Rqll5N0/vfpqlP9I9EXqAoGacuAbX6c9Ulg/Cjqglp5VkK6UQ==", + "version": "1.40.1", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.40.1.tgz", + "integrity": "sha512-EaaawMTOeEItCRvfmkI9v6rBkF1svM8wjl/YPRrg2N2Wmp+4qJYkWtJsbew1szfKKDm6fPLy4YAanBhIlf9dWw==", "dev": true, "dependencies": { - "playwright": "1.39.0" + "playwright": "1.40.1" }, "bin": { "playwright": "cli.js" @@ -123,9 +123,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "20.9.0", - "resolved": "https://registry.npmjs.org/@types/node/-/node-20.9.0.tgz", - "integrity": "sha512-nekiGu2NDb1BcVofVcEKMIwzlx4NjHlcjhoxxKBNLtz15Y1z7MYf549DFvkHSId02Ax6kGwWntIBPC3l/JZcmw==", + "version": "20.10.7", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.7.tgz", + "integrity": "sha512-fRbIKb8C/Y2lXxB5eVMj4IU7xpdox0Lh8bUPEdtLysaylsml1hOOx1+STloRs/B9nf7C6kPRmmg/V7aQW7usNg==", "dev": true, "dependencies": { "undici-types": "~5.26.4" @@ -146,9 +146,9 @@ "integrity": "sha512-9tCqYEDHI5RYFQigXFwF1hnCwcWCOJl/hmll0lr5D2Ljjb0o4wphb69wikeJDz5qCEzXCoPvG6ss5SDP6IfOdg==" }, "node_modules/@umbraco/playwright-testhelpers": { - "version": "2.0.0-beta.17", - "resolved": "https://registry.npmjs.org/@umbraco/playwright-testhelpers/-/playwright-testhelpers-2.0.0-beta.17.tgz", - "integrity": "sha512-wUaF7AB+x0PHAyfAgGxvBvM+o6QKLcDM6itHjjOJLtnF0Q96JZlZ4wf4d9GcaBdpZkaYq5MBjZtXg8ZSzFFJuw==", + "version": "2.0.0-beta.18", + "resolved": "https://registry.npmjs.org/@umbraco/playwright-testhelpers/-/playwright-testhelpers-2.0.0-beta.18.tgz", + "integrity": "sha512-krL/FwgisdmIJRy1ThaC/BOqeebJj9sCtDDbcy2h0B8Tmz4NhYdjdEMh3X+IvJDnfHX+rS2DiYa97cHyvVMhHA==", "dependencies": { "@umbraco/json-models-builders": "2.0.1", "camelize": "^1.0.0", @@ -192,12 +192,12 @@ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" }, "node_modules/axios": { - "version": "1.6.2", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.2.tgz", - "integrity": "sha512-7i24Ri4pmDRfJTR7LDBhsOTtcm+9kjX5WiY1X3wIisx6G9So3pfMkEiU7emUBe46oceVImccTEM3k6C5dbVW8A==", + "version": "1.6.5", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.5.tgz", + "integrity": "sha512-Ii012v05KEVuUoFWmMW/UQv9aRIc3ZwkWDcM+h5Il8izZCtRVpDUfwpoFf7eOtajT3QiGR4yDUx7lPqHJULgbg==", "dev": true, "dependencies": { - "follow-redirects": "^1.15.0", + "follow-redirects": "^1.15.4", "form-data": "^4.0.0", "proxy-from-env": "^1.1.0" } @@ -366,9 +366,9 @@ } }, "node_modules/fastq": { - "version": "1.15.0", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", - "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.16.0.tgz", + "integrity": "sha512-ifCoaXsDrsdkWTtiNJX5uzHDsrck5TzfKKDcuFFTIrrc/BS076qgEIfoIy1VeZqViznfKiysPYTh/QeHtnIsYA==", "dev": true, "dependencies": { "reusify": "^1.0.4" @@ -387,9 +387,9 @@ } }, "node_modules/follow-redirects": { - "version": "1.15.3", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.3.tgz", - "integrity": "sha512-1VzOtuEM8pC9SFU1E+8KfTjZyMztRsgEfwQl44z8A25uy13jSzTj6dyK2Df52iV0vgHCfBwLhDWevLn95w5v6Q==", + "version": "1.15.4", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz", + "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==", "dev": true, "funding": [ { @@ -425,20 +425,6 @@ "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", "dev": true }, - "node_modules/fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, - "hasInstallScript": true, - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, "node_modules/glob": { "version": "7.2.3", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", @@ -498,9 +484,9 @@ "dev": true }, "node_modules/ignore": { - "version": "5.2.4", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", - "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.0.tgz", + "integrity": "sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg==", "dev": true, "engines": { "node": ">= 4" @@ -755,12 +741,12 @@ } }, "node_modules/playwright": { - "version": "1.39.0", - "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.39.0.tgz", - "integrity": "sha512-naE5QT11uC/Oiq0BwZ50gDmy8c8WLPRTEWuSSFVG2egBka/1qMoSqYQcROMT9zLwJ86oPofcTH2jBY/5wWOgIw==", + "version": "1.40.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.40.1.tgz", + "integrity": "sha512-2eHI7IioIpQ0bS1Ovg/HszsN/XKNwEG1kbzSDDmADpclKc7CyqkHw7Mg2JCz/bbCxg25QUPcjksoMW7JcIFQmw==", "dev": true, "dependencies": { - "playwright-core": "1.39.0" + "playwright-core": "1.40.1" }, "bin": { "playwright": "cli.js" @@ -773,9 +759,9 @@ } }, "node_modules/playwright-core": { - "version": "1.39.0", - "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.39.0.tgz", - "integrity": "sha512-+k4pdZgs1qiM+OUkSjx96YiKsXsmb59evFoqv8SKO067qBA+Z2s/dCzJij/ZhdQcs2zlTAgRKfeiiLm8PQ2qvw==", + "version": "1.40.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.40.1.tgz", + "integrity": "sha512-+hkOycxPiV534c4HhpfX6yrlawqVUzITRKwHAmYfmsVreltEl6fAZJ3DPfLMOODw0H3s1Itd6MDCWmP1fl/QvQ==", "dev": true, "bin": { "playwright-core": "cli.js" diff --git a/tests/Umbraco.Tests.AcceptanceTest/package.json b/tests/Umbraco.Tests.AcceptanceTest/package.json index 9819127902..d29ede9e12 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/package.json +++ b/tests/Umbraco.Tests.AcceptanceTest/package.json @@ -21,7 +21,7 @@ }, "dependencies": { "@umbraco/json-models-builders": "^2.0.1 ", - "@umbraco/playwright-testhelpers": "^2.0.0-beta.17", + "@umbraco/playwright-testhelpers": "^2.0.0-beta.18", "camelize": "^1.0.0", "dotenv": "^16.3.1", "faker": "^4.1.0", diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataType.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataType.spec.ts index b4565d00f0..c520af75f1 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataType.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataType.spec.ts @@ -2,11 +2,13 @@ import {expect} from "@playwright/test"; test.describe('DataType tests', () => { - let dataTypeId = ""; - let dataTypeFolderId = ""; + let dataTypeId = ''; + let dataTypeFolderId = ''; + let copiedDataTypeId = ''; - const dataTypeName = "TestType"; - const propertyEditorAlias = "Umbraco.DateTime"; + const dataTypeName = 'TestDataType'; + const folderName = 'TestDataTypeFolder'; + const editorAlias = 'Umbraco.DateTime'; const dataTypeData = [ { "alias": "tester", @@ -15,24 +17,27 @@ test.describe('DataType tests', () => { ]; test.beforeEach(async ({umbracoApi}) => { - await umbracoApi.dataType.ensureNameNotExistsAtRoot(dataTypeName); + await umbracoApi.dataType.ensureNameNotExists(dataTypeName); }); test.afterEach(async ({umbracoApi}) => { - await umbracoApi.dataType.delete(dataTypeId); + await umbracoApi.dataType.ensureNameNotExists(dataTypeName); + if (dataTypeFolderId != '') { + await umbracoApi.dataType.ensureNameNotExists(folderName); + } }); test('can create dataType', async ({umbracoApi}) => { // Act - dataTypeId = await umbracoApi.dataType.create(dataTypeName, propertyEditorAlias, dataTypeData); + dataTypeId = await umbracoApi.dataType.create(dataTypeName, editorAlias, dataTypeData); // Assert - expect(umbracoApi.dataType.exists(dataTypeId)).toBeTruthy(); + expect(umbracoApi.dataType.doesExist(dataTypeId)).toBeTruthy(); }); test('can update dataType', async ({umbracoApi}) => { // Arrange - dataTypeId = await umbracoApi.dataType.create(dataTypeName, propertyEditorAlias, []); + dataTypeId = await umbracoApi.dataType.create(dataTypeName, editorAlias, []); const dataType = await umbracoApi.dataType.get(dataTypeId); dataType.values = dataTypeData; @@ -47,22 +52,23 @@ test.describe('DataType tests', () => { test('can delete dataType', async ({umbracoApi}) => { // Arrange - dataTypeId = await umbracoApi.dataType.create(dataTypeName, propertyEditorAlias, dataTypeData); - expect(await umbracoApi.dataType.exists(dataTypeId)).toBeTruthy(); + dataTypeId = await umbracoApi.dataType.create(dataTypeName, editorAlias, dataTypeData); + expect(await umbracoApi.dataType.doesExist(dataTypeId)).toBeTruthy(); // Act await umbracoApi.dataType.delete(dataTypeId); // Assert - expect(await umbracoApi.dataType.exists(dataTypeId)).toBeFalsy(); + expect(await umbracoApi.dataType.doesExist(dataTypeId)).toBeFalsy(); }); test('can move a dataType to a folder', async ({umbracoApi}) => { // Arrange - const folderName = 'FolderToMoveToo'; - await umbracoApi.dataType.ensureNameNotExistsAtRoot(folderName); - dataTypeId = await umbracoApi.dataType.create(dataTypeName, propertyEditorAlias, dataTypeData); + await umbracoApi.dataType.ensureNameNotExists(folderName); + dataTypeId = await umbracoApi.dataType.create(dataTypeName, editorAlias, dataTypeData); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); dataTypeFolderId = await umbracoApi.dataType.createFolder(folderName); + expect(await umbracoApi.dataType.doesFolderExist(dataTypeFolderId)).toBeTruthy(); // Act await umbracoApi.dataType.moveToFolder(dataTypeId, dataTypeFolderId); @@ -70,19 +76,13 @@ test.describe('DataType tests', () => { // Assert // Checks if the datatype has the parentId of the folder const dataTypeInFolder = await umbracoApi.dataType.getChildren(dataTypeFolderId); - expect(dataTypeInFolder.items[0].parentId).toEqual(dataTypeFolderId); - - // Clean - await umbracoApi.dataType.deleteFolder(dataTypeFolderId); + expect(dataTypeInFolder[0].parent.id).toEqual(dataTypeFolderId); }); test('can copy a dataType to a folder', async ({umbracoApi}) => { // Arrange - let copiedDataTypeId = ""; - const folderName = 'FolderToCopyToo'; - await umbracoApi.dataType.ensureNameNotExistsAtRoot(folderName); - - dataTypeId = await umbracoApi.dataType.create(dataTypeName, propertyEditorAlias, dataTypeData); + await umbracoApi.dataType.ensureNameNotExists(folderName); + dataTypeId = await umbracoApi.dataType.create(dataTypeName, editorAlias, dataTypeData); dataTypeFolderId = await umbracoApi.dataType.createFolder(folderName); const dataType = await umbracoApi.dataType.get(dataTypeId); @@ -95,10 +95,7 @@ test.describe('DataType tests', () => { const copiedDataType = await umbracoApi.dataType.get(copiedDataTypeId); expect(copiedDataType.name).toEqual(dataTypeName + ' (copy)'); // Checks if both dataTypes exists - expect(await umbracoApi.dataType.exists(dataTypeId)).toBeTruthy(); - expect(await umbracoApi.dataType.exists(copiedDataTypeId)).toBeTruthy(); - - // Clean - await umbracoApi.dataType.deleteFolder(dataTypeFolderId); + expect(await umbracoApi.dataType.doesExist(dataTypeId)).toBeTruthy(); + expect(await umbracoApi.dataType.doesExist(copiedDataTypeId)).toBeTruthy(); }); }); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataTypeFolder.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataTypeFolder.spec.ts index 1990031524..75b48525ce 100644 --- a/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataTypeFolder.spec.ts +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/ApiTesting/DataType/DataTypeFolder.spec.ts @@ -2,15 +2,15 @@ import {expect} from "@playwright/test"; test.describe('DataTypeFolder tests', () => { - let dataTypeFolderId = ""; - const dataTypeFolderName = "TestTypeFolder"; + let dataTypeFolderId = ''; + const dataTypeFolderName = 'TestDataTypeFolder'; test.beforeEach(async ({umbracoApi}) => { - await umbracoApi.dataType.ensureNameNotExistsAtRoot(dataTypeFolderName); + await umbracoApi.dataType.ensureNameNotExists(dataTypeFolderName); }); test.afterEach(async ({umbracoApi}) => { - await umbracoApi.dataType.deleteFolder(dataTypeFolderId); + await umbracoApi.dataType.ensureNameNotExists(dataTypeFolderName); }); test('can create a dataType folder', async ({umbracoApi}) => { @@ -18,7 +18,7 @@ test.describe('DataTypeFolder tests', () => { dataTypeFolderId = await umbracoApi.dataType.createFolder(dataTypeFolderName); // Assert - expect(umbracoApi.dataType.folderExists(dataTypeFolderId)).toBeTruthy(); + expect(umbracoApi.dataType.doesFolderExist(dataTypeFolderId)).toBeTruthy(); }); test('can update a dataType folder', async ({umbracoApi}) => { @@ -33,7 +33,7 @@ test.describe('DataTypeFolder tests', () => { await umbracoApi.dataType.updateFolder(dataTypeFolderId, dataTypeFolder); // Assert - expect(umbracoApi.dataType.folderExists(dataTypeFolderId)).toBeTruthy(); + expect(umbracoApi.dataType.doesFolderExist(dataTypeFolderId)).toBeTruthy(); // Checks if the dataType folder was updated const newDataTypeFolderName = await umbracoApi.dataType.getFolder(dataTypeFolderId); expect(newDataTypeFolderName.name).toEqual(dataTypeFolderName); @@ -42,12 +42,12 @@ test.describe('DataTypeFolder tests', () => { test('can delete a dataType folder', async ({umbracoApi}) => { // Arrange await umbracoApi.dataType.createFolder(dataTypeFolderName); - expect(umbracoApi.dataType.folderExists(dataTypeFolderId)).toBeTruthy(); + expect(umbracoApi.dataType.doesFolderExist(dataTypeFolderId)).toBeTruthy(); // Act await umbracoApi.dataType.delete(dataTypeFolderId); // Assert - expect(await umbracoApi.dataType.folderExists(dataTypeFolderId)).toBeFalsy(); + expect(await umbracoApi.dataType.doesFolderExist(dataTypeFolderId)).toBeFalsy(); }); }); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ApprovedColor.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ApprovedColor.spec.ts new file mode 100644 index 0000000000..e97f1b8e9a --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ApprovedColor.spec.ts @@ -0,0 +1,102 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Approved Color'; +test.describe(`${dataTypeName} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + const colorValue = '#ffffff'; + const colorLabel = 'TestColor'; + + test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName); + }); + + test.afterEach(async ({umbracoApi}) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test('can include label', async ({umbracoApi, umbracoUi}) => { + // Arrange + const expectedDataTypeValues = [ + { + "alias": "useLabel", + "value": true + } + ]; + // Remove all existing values + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = []; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.clickIncludeLabelsSlider(); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + test('can add color', async ({umbracoApi, umbracoUi}) => { + // Arrange + const expectedDataTypeValues = [ + { + "alias": "items", + "value": [ + { + "value": colorValue, + "label": colorLabel + } + ] + } + ]; + // Remove all existing values + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = []; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.addColor(colorValue, colorLabel); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + // TODO: remove .skip when the frontend is able to display the added color. Currently the added colors are not displayed after reloading page + test.skip('can remove color', async ({umbracoApi, umbracoUi}) => { + // Arrange + const removedDataTypeValues = [ + { + "alias": "items", + "value": [ + { + "value": colorValue, + "label": colorLabel + } + ] + } + ]; + // Remove all existing values and add a color to remove + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = removedDataTypeValues; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.removeColorByValue(colorValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual([]); + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataType.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataType.spec.ts new file mode 100644 index 0000000000..11ded9aae3 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataType.spec.ts @@ -0,0 +1,83 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +test.describe('Data Types basic functionalities tests', () => { + const dataTypeName = 'TestDataType'; + const editorAlias = 'Umbraco.DateTime'; + + test.beforeEach(async ({umbracoApi, umbracoUi}) => { + await umbracoApi.dataType.ensureNameNotExists(dataTypeName); + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + }); + + test.afterEach(async ({umbracoApi}) => { + await umbracoApi.dataType.ensureNameNotExists(dataTypeName); + }); + + test('can create a data type', async ({umbracoApi, umbracoUi}) => { + // Act + await umbracoUi.dataType.clickActionsMenuAtRoot(); + await umbracoUi.dataType.clickCreateThreeDotsButton(); + await umbracoUi.dataType.clickNewDataTypeThreeDotsButton(); + await umbracoUi.dataType.enterDataTypeName(dataTypeName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + await umbracoUi.dataType.isSuccessNotificationVisible(); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + }); + + test('can update a data type name', async ({umbracoApi, umbracoUi}) => { + // Arrange + const wrongDataTypeName = 'Wrong Data Type'; + await umbracoApi.dataType.ensureNameNotExists(wrongDataTypeName); + await umbracoApi.dataType.create(wrongDataTypeName, editorAlias, []); + expect(await umbracoApi.dataType.doesNameExist(wrongDataTypeName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.goToDataType(wrongDataTypeName); + await umbracoUi.dataType.enterDataTypeName(dataTypeName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + expect(await umbracoApi.dataType.doesNameExist(wrongDataTypeName)).toBeFalsy(); + }); + + test('can delete a data type', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.dataType.create(dataTypeName, editorAlias, []); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.clickRootFolderCaretButton(); + await umbracoUi.dataType.deleteDataType(dataTypeName); + + // Assert + await umbracoUi.dataType.isSuccessNotificationVisible(); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeFalsy(); + }); + + test('can change Property Editor in a data type', async ({umbracoApi, umbracoUi}) => { + // Arrange + const updatedEditorName = 'Text Area'; + const updatedEditorAlias = 'Umbraco.TextArea'; + const updatedEditorUiAlias = 'Umb.PropertyEditorUi.TextArea'; + + await umbracoApi.dataType.create(dataTypeName, editorAlias, []); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.goToDataType(dataTypeName); + await umbracoUi.dataType.clickChangeButton(); + await umbracoUi.dataType.selectPropertyEditorUIByName(updatedEditorName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.editorAlias).toBe(updatedEditorAlias); + expect(dataTypeData.editorUiAlias).toBe(updatedEditorUiAlias); + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataTypeFolder.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataTypeFolder.spec.ts new file mode 100644 index 0000000000..6c31a0e699 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataTypeFolder.spec.ts @@ -0,0 +1,131 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +test.describe('Data Types Folder tests', () => { + const dataTypeName = 'TestDataType'; + const dataTypeFolderName = 'TestDataTypeFolder'; + const editorAlias = 'Umbraco.DateTime'; + + test.beforeEach(async ({umbracoApi, umbracoUi}) => { + await umbracoApi.dataType.ensureNameNotExists(dataTypeFolderName); + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + }); + + test.afterEach(async ({umbracoApi}) => { + await umbracoApi.dataType.ensureNameNotExists(dataTypeFolderName); + }); + + test('can create a data type folder', async ({umbracoApi, umbracoUi}) => { + // Act + await umbracoUi.dataType.clickActionsMenuAtRoot(); + await umbracoUi.dataType.clickCreateThreeDotsButton(); + await umbracoUi.dataType.clickNewDataTypeFolderButton(); + await umbracoUi.dataType.enterFolderName(dataTypeFolderName); + await umbracoUi.dataType.clickCreateFolderButton(); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + }); + + test('can rename a data type folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const wrongDataTypeFolderName = 'Wrong Folder'; + await umbracoApi.dataType.ensureNameNotExists(wrongDataTypeFolderName); + await umbracoApi.dataType.createFolder(wrongDataTypeFolderName); + expect(await umbracoApi.dataType.doesNameExist(wrongDataTypeFolderName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.clickRootFolderCaretButton(); + await umbracoUi.dataType.clickActionsMenuForDataType(wrongDataTypeFolderName); + await umbracoUi.dataType.clickRenameFolderThreeDotsButton(); + await umbracoUi.dataType.enterFolderName(dataTypeFolderName); + await umbracoUi.dataType.clickUpdateFolderButton(); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + expect(await umbracoApi.dataType.doesNameExist(wrongDataTypeFolderName)).toBeFalsy(); + }); + + test('can delete a data type folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + await umbracoApi.dataType.createFolder(dataTypeFolderName); + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.clickRootFolderCaretButton(); + await umbracoUi.dataType.deleteDataTypeFolder(dataTypeFolderName); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeFalsy(); + }); + + test('can create a data type in a folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + let dataTypeFolderId = await umbracoApi.dataType.createFolder(dataTypeFolderName); + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.clickRootFolderCaretButton(); + await umbracoUi.dataType.clickActionsMenuForDataType(dataTypeFolderName); + await umbracoUi.dataType.clickCreateThreeDotsButton(); + await umbracoUi.dataType.clickNewDataTypeThreeDotsButton(); + await umbracoUi.dataType.enterDataTypeName(dataTypeName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + const dataTypeChildren = await umbracoApi.dataType.getChildren(dataTypeFolderId); + expect(dataTypeChildren[0].name).toBe(dataTypeName); + expect(dataTypeChildren[0].isFolder).toBeFalsy(); + }); + + test('can create a folder in a folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + const childFolderName = 'Child Folder'; + let dataTypeFolderId = await umbracoApi.dataType.createFolder(dataTypeFolderName); + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.clickRootFolderCaretButton(); + await umbracoUi.dataType.clickActionsMenuForDataType(dataTypeFolderName); + await umbracoUi.dataType.clickCreateThreeDotsButton(); + await umbracoUi.dataType.clickNewDataTypeFolderButton(); + await umbracoUi.dataType.enterFolderName(childFolderName); + await umbracoUi.dataType.clickCreateFolderButton(); + + // Assert + expect(await umbracoApi.dataType.doesNameExist(childFolderName)).toBeTruthy(); + const dataTypeChildren = await umbracoApi.dataType.getChildren(dataTypeFolderId); + expect(dataTypeChildren[0].name).toBe(childFolderName); + expect(dataTypeChildren[0].isFolder).toBeTruthy(); + }); + + test('cannot delete a non-empty data type folder', async ({umbracoApi, umbracoUi}) => { + // Arrange + let dataTypeFolderId = await umbracoApi.dataType.createFolder(dataTypeFolderName); + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + await umbracoApi.dataType.create(dataTypeName, editorAlias, [], dataTypeFolderId); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + + // Act + await umbracoUi.dataType.clickRootFolderCaretButton(); + await umbracoUi.dataType.deleteDataTypeFolder(dataTypeFolderName); + + // Assert + await umbracoUi.dataType.isErrorNotificationVisible(); + expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy(); + expect(await umbracoApi.dataType.doesNameExist(dataTypeFolderName)).toBeTruthy(); + const dataTypeChildren = await umbracoApi.dataType.getChildren(dataTypeFolderId); + expect(dataTypeChildren[0].name).toBe(dataTypeName); + expect(dataTypeChildren[0].isFolder).toBeFalsy(); + }); + + test.skip('can move a data type to a data type folder', async ({}) => { + // TODO: implement this test later when the front-end is ready + }); + + test.skip('can copy a data type to a data type folder', async ({}) => { + // TODO: implement this test later when the front-end is ready + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DatePicker.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DatePicker.spec.ts new file mode 100644 index 0000000000..d2ef80ec8f --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DatePicker.spec.ts @@ -0,0 +1,73 @@ +import { test } from "@umbraco/playwright-testhelpers"; +import { expect } from "@playwright/test"; + +const datePickerTypes = ['Date Picker', 'Date Picker with time']; +for (const datePickerType of datePickerTypes) { + test.describe(`${datePickerType} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({ umbracoUi, umbracoApi }) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + dataTypeDefaultData = await umbracoApi.dataType.getByName(datePickerType); + await umbracoUi.dataType.goToDataType(datePickerType); + }); + + test.afterEach(async ({ umbracoApi }) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id,dataTypeDefaultData); + } + }); + + test(`can update offset time`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const expectedDataTypeValues = + datePickerType === 'Date Picker' + ? [ + { + alias: "format", + value: "YYYY-MM-DD", + }, + { + alias: "offsetTime", + value: true, + }, + ] + : [ + { + alias: "offsetTime", + value: true, + }, + ]; + + // Act + await umbracoUi.dataType.clickOffsetTimeSlider(); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(datePickerType); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + test(`can update date format`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const dateFormatValue = + datePickerType === 'Date Picker' ? 'DD-MM-YYYY' : 'DD-MM-YYYY hh:mm:ss'; + const expectedDataTypeValues = [ + { + alias: "format", + value: dateFormatValue, + }, + ]; + + // Act + await umbracoUi.dataType.enterDateFormatValue(dateFormatValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(datePickerType); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + }); +} diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ImageCropper.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ImageCropper.spec.ts new file mode 100644 index 0000000000..130f418234 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ImageCropper.spec.ts @@ -0,0 +1,125 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Image Cropper'; +test.describe(`${dataTypeName} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName); + }); + + test.afterEach(async ({umbracoApi}) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test('can add crop', async ({umbracoApi, umbracoUi}) => { + // Arrange + const cropData = ['Test Alias', 100, 50]; + const expectedDataTypeValues = [{ + "alias": "crops", + "value": [ + { + "alias": cropData[0], + "width": cropData[1], + "height": cropData[2] + } + ] + }]; + // Remove all existing crops + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = []; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.enterCropValues( + cropData[0].toString(), + cropData[1].toString(), + cropData[2].toString() + ); + await umbracoUi.dataType.clickAddCropButton(); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + //await umbracoUi.dataType.isSuccessNotificationVisible(); + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + test('can edit crop', async ({umbracoApi, umbracoUi}) => { + // Arrange + const wrongCropData = ['Wrong Alias', 50, 100]; + const wrongDataTypeValues = [{ + "alias": "crops", + "value": [ + { + "alias": wrongCropData[0], + "width": wrongCropData[1], + "height": wrongCropData[2] + } + ] + }]; + const updatedCropData = ['Updated Test Alias', 100, 50]; + const expectedDataTypeValues = [{ + "alias": "crops", + "value": [ + { + "alias": updatedCropData[0], + "width": updatedCropData[1], + "height": updatedCropData[2] + } + ] + }]; + // Remove all existing crops and add a crop to edit + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = wrongDataTypeValues; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.editCropByAlias(wrongCropData[0].toString()); + await umbracoUi.dataType.enterCropValues(updatedCropData[0].toString(), updatedCropData[1].toString(), updatedCropData[2].toString()); + await umbracoUi.dataType.clickSaveCropButton(); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + //await umbracoUi.dataType.isSuccessNotificationVisible(); + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + test('can delete crop', async ({umbracoApi, umbracoUi}) => { + // Arrange + const wrongCropData = ['Wrong Alias', 50, 100]; + const wrongDataTypeValues = [{ + "alias": "crops", + "value": [ + { + "alias": wrongCropData[0], + "width": wrongCropData[1], + "height": wrongCropData[2] + } + ] + }]; + // Remove all existing crops and add a crop to remove + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = wrongDataTypeValues; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.removeCropByAlias(wrongCropData[0].toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + //await umbracoUi.dataType.isSuccessNotificationVisible(); + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual([]); + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Label.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Label.spec.ts new file mode 100644 index 0000000000..8cfe096a76 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Label.spec.ts @@ -0,0 +1,41 @@ +import { test } from "@umbraco/playwright-testhelpers"; +import { expect } from "@playwright/test"; + +const labelTypes = ['Label (bigint)', 'Label (datetime)', 'Label (decimal)', 'Label (integer)', 'Label (string)', 'Label (time)']; +for (const labelType of labelTypes) { + test.describe(`${labelType} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({ umbracoUi, umbracoApi }) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem("Data Types"); + dataTypeDefaultData = await umbracoApi.dataType.getByName(labelType); + await umbracoUi.dataType.goToDataType(labelType); + }); + + test.afterEach(async ({ umbracoApi }) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id,dataTypeDefaultData); + } + }); + + test(`can change value type`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const expectedDataTypeValues = [ + { + alias: "umbracoDataValueType", + value: "TEXT", + }, + ]; + + // Act + await umbracoUi.dataType.changeValueType("Long String"); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(labelType); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + }); +} diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ListView.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ListView.spec.ts new file mode 100644 index 0000000000..220bf6ae8a --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ListView.spec.ts @@ -0,0 +1,204 @@ +import { test } from "@umbraco/playwright-testhelpers"; +import { expect } from "@playwright/test"; + +const listViewTypes = ['List View - Content', 'List View - Media', 'List View - Members']; +for (const listViewType of listViewTypes) { + test.describe(`${listViewType} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({ umbracoUi, umbracoApi }) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + dataTypeDefaultData = await umbracoApi.dataType.getByName(listViewType); + await umbracoUi.dataType.goToDataType(listViewType); + }); + + test.afterEach(async ({ umbracoApi }) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id,dataTypeDefaultData); + } + }); + + test(`can update Page Size`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const pageSizeValue = 5; + const expectedDataTypeValues = { + alias: "pageSize", + value: pageSizeValue, + }; + + // Act + await umbracoUi.dataType.enterPageSizeValue(pageSizeValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can update Order Direction`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const isAscending = listViewType == 'List View - Members' ? false : true; + const orderDirectionValue = isAscending ? 'asc' : 'desc'; + const expectedDataTypeValues = { + alias: "orderDirection", + value: orderDirectionValue, + }; + + // Act + await umbracoUi.dataType.chooseOrderDirection(isAscending); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can add Column Displayed`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const columnName = 'Document Type'; + const expectedIncludePropertiesValues = { + alias: "contentTypeAlias", + header: "Document Type", + isSystem: true, + }; + + // Act + await umbracoUi.dataType.addColumnDisplayed(columnName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + const includePropertiesData = dataTypeData.values.find(value => value.alias === "includeProperties"); + expect(includePropertiesData.value).toContainEqual(expectedIncludePropertiesValues); + }); + + test(`can remove Column Displayed`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const columnName = 'Last edited'; + const expectedIncludePropertiesValues = { + alias: "updateDate", + header: "Last edited", + isSystem: 1, + }; + + // Act + await umbracoUi.dataType.removeColumnDisplayed(columnName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + const includePropertiesData = dataTypeData.values.find(value => value.alias === "includeProperties"); + expect(includePropertiesData.value).not.toContainEqual(expectedIncludePropertiesValues); + }); + + test(`can update Order By`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const orderByValue = 'Last edited'; + const expectedDataTypeValues = { + alias: "orderBy", + value: "updateDate", + }; + + // Act + await umbracoUi.dataType.chooseOrderByValue(orderByValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can update Bulk Action Permission`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const bulkActionPermissionValue = 'Allow bulk copy (content only)'; + const expectedDataTypeValues = { + alias: "bulkActionPermissions", + value: { + allowBulkPublish: false, + allowBulkUnpublish: false, + allowBulkCopy: true, + allowBulkDelete: false, + allowBulkMove: false, + }, + }; + + // Act + await umbracoUi.dataType.clickBulkActionPermissionsSliderByValue(bulkActionPermissionValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can update Content App Icon`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const iconValue = 'icon-activity'; + const expectedDataTypeValues = { + "alias": "icon", + "value": iconValue + }; + + // Act + await umbracoUi.dataType.clickContentAppIconButton(); + await umbracoUi.dataType.chooseContentAppIconByValue(iconValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can update Content App Name`, async ({ umbracoApi, umbracoUi }) => { + // Arrange + const contentAppName = 'Test Content App Name'; + const expectedDataTypeValues = { + alias: "tabName", + value: contentAppName, + }; + + // Act + await umbracoUi.dataType.enterContentAppName(contentAppName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can enable Show Content App First`, async ({umbracoApi, umbracoUi}) => { + // Arrange + const expectedDataTypeValues = { + alias: "showContentFirst", + value: true, + }; + + // Act + await umbracoUi.dataType.clickShowContentAppFirstSlider(); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test(`can enable Edit in Infinite Editor`, async ({umbracoApi, umbracoUi}) => { + // Arrange + const expectedDataTypeValues = { + alias: "useInfiniteEditor", + value: true, + }; + + // Act + await umbracoUi.dataType.clickEditInInfiniteEditorSlider(); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + //await umbracoUi.dataType.isSuccessNotificationVisible(); + dataTypeData = await umbracoApi.dataType.getByName(listViewType); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + }); +} diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Numeric.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Numeric.spec.ts new file mode 100644 index 0000000000..4c79d297ba --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Numeric.spec.ts @@ -0,0 +1,72 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Numeric'; +test.describe(`${dataTypeName} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + await umbracoUi.dataType.goToDataType(dataTypeName); + dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName); + }); + + test.afterEach(async ({umbracoApi}) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test('can update Minimum value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const minimumValue = -5; + const expectedDataTypeValues = { + alias: "min", + value: minimumValue, + }; + + // Act + await umbracoUi.dataType.enterMinimumValue(minimumValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test('can update Maximum value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const maximumValue = 1000000; + const expectedDataTypeValues = { + alias: "max", + value: maximumValue, + }; + + // Act + await umbracoUi.dataType.enterMaximumValue(maximumValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test('can update Step Size value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const stepSizeValue = 5; + const expectedDataTypeValues = { + alias: "step", + value: stepSizeValue, + }; + + // Act + await umbracoUi.dataType.enterStepSizeValue(stepSizeValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Radiobox.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Radiobox.spec.ts new file mode 100644 index 0000000000..e9129cb414 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Radiobox.spec.ts @@ -0,0 +1,74 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Radiobox'; +test.describe(`${dataTypeName} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName); + }); + + test.afterEach(async ({umbracoApi}) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test('can add option', async ({umbracoApi, umbracoUi}) => { + // Arrange + const optionName = 'Test option'; + const expectedDataTypeValues = [{ + "alias": "items", + "value": [ + { + "value": optionName + } + ] + }]; + // Remove all existing options + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = []; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.clickAddOptionButton(); + await umbracoUi.dataType.enterOptionName(optionName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + test('can remove option', async ({umbracoApi, umbracoUi}) => { + // Arrange + const removedOptionName = 'Removed Option'; + const removedOptionValues = [{ + "alias": "items", + "value": [ + { + "value": removedOptionName + } + ] + }]; + // Remove all existing options and add an option to remove + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + dataTypeData.values = removedOptionValues; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(dataTypeName); + + // Act + await umbracoUi.dataType.removeOptionByName(removedOptionName); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toEqual([]); + }); + +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textarea.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textarea.spec.ts new file mode 100644 index 0000000000..474aad3f39 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textarea.spec.ts @@ -0,0 +1,89 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Textarea'; +test.describe(`${dataTypeName} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + await umbracoUi.dataType.goToDataType(dataTypeName); + dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName); + }); + + test.afterEach(async ({umbracoApi}) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test('can update Maximum allowed characters value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const maxCharsValue = 126; + const expectedDataTypeValues = { + alias: "maxChars", + value: maxCharsValue, + }; + + // Act + await umbracoUi.dataType.enterMaximumAllowedCharactersValue(maxCharsValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test('can update Number of rows value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const numberOfRowsValue = 9; + const expectedDataTypeValues = { + alias: "rows", + value: numberOfRowsValue, + }; + + // Act + await umbracoUi.dataType.enterNumberOfRowsValue(numberOfRowsValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test('can update Min height (pixels) value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const minHeightValue = 150; + const expectedDataTypeValues = { + alias: "minHeight", + value: minHeightValue, + }; + + // Act + await umbracoUi.dataType.enterMinHeightValue(minHeightValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); + + test('can update Max height (pixels) value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const maxHeightValue = 300; + const expectedDataTypeValues = { + alias: "maxHeight", + value: maxHeightValue, + }; + + // Act + await umbracoUi.dataType.enterMaxHeightValue(maxHeightValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textstring.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textstring.spec.ts new file mode 100644 index 0000000000..8d7c51a68a --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textstring.spec.ts @@ -0,0 +1,38 @@ +import {test} from '@umbraco/playwright-testhelpers'; +import {expect} from "@playwright/test"; + +const dataTypeName = 'Textstring'; +test.describe(`${dataTypeName} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({umbracoUi, umbracoApi}) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem('Data Types'); + await umbracoUi.dataType.goToDataType(dataTypeName); + dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName); + }); + + test.afterEach(async ({umbracoApi}) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test('can update Maximum allowed characters value', async ({umbracoApi, umbracoUi}) => { + // Arrange + const maxCharsValue = 126; + const expectedDataTypeValues = { + alias: "maxChars", + value: maxCharsValue, + }; + + // Act + await umbracoUi.dataType.enterMaximumAllowedCharactersValue(maxCharsValue.toString()); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(dataTypeName); + expect(dataTypeData.values).toContainEqual(expectedDataTypeValues); + }); +}); diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Upload.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Upload.spec.ts new file mode 100644 index 0000000000..2b7821abe6 --- /dev/null +++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Upload.spec.ts @@ -0,0 +1,79 @@ +import { test } from "@umbraco/playwright-testhelpers"; +import { expect } from "@playwright/test"; + +const uploadTypes = ['Upload Article', 'Upload Audio', 'Upload File', 'Upload Vector Graphics', 'Upload Video']; +for (const uploadType of uploadTypes) { + test.describe(`${uploadType} tests`, () => { + let dataTypeDefaultData = null; + let dataTypeData = null; + + test.beforeEach(async ({ umbracoUi, umbracoApi }) => { + await umbracoUi.goToBackOffice(); + await umbracoUi.dataType.goToSettingsTreeItem("Data Types"); + dataTypeDefaultData = await umbracoApi.dataType.getByName(uploadType); + }); + + test.afterEach(async ({ umbracoApi }) => { + if (dataTypeDefaultData !== null) { + await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData); + } + }); + + test("can add accepted file extension", async ({ umbracoApi, umbracoUi }) => { + // Arrange + const fileExtensionValue = 'zip'; + const expectedDataTypeValues = [ + { + alias: "fileExtensions", + value: [ + { + "value": fileExtensionValue + }, + ], + }, + ]; + // Remove all existing accepted file extensions + dataTypeData = await umbracoApi.dataType.getByName(uploadType); + dataTypeData.values = []; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(uploadType); + + // Act + await umbracoUi.dataType.clickAddAcceptedFileExtensionsButton(); + await umbracoUi.dataType.enterAcceptedFileExtensions(fileExtensionValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(uploadType); + expect(dataTypeData.values).toEqual(expectedDataTypeValues); + }); + + test("can remove accepted file extension", async ({ umbracoApi, umbracoUi }) => { + // Arrange + const removedFileExtensionValue = "bat"; + const removedFileExtensionsValues = [ + { + alias: "fileExtensions", + value: [ + { + "value": removedFileExtensionValue + }, + ], + }, + ]; + // Remove all existing accepted file extensions and add an file extension to remove + dataTypeData = await umbracoApi.dataType.getByName(uploadType); + dataTypeData.values = removedFileExtensionsValues; + await umbracoApi.dataType.update(dataTypeData.id, dataTypeData); + await umbracoUi.dataType.goToDataType(uploadType); + + // Act + await umbracoUi.dataType.removeAcceptedFileExtensionsByValue(removedFileExtensionValue); + await umbracoUi.dataType.clickSaveButton(); + + // Assert + dataTypeData = await umbracoApi.dataType.getByName(uploadType); + expect(dataTypeData.values).toEqual([]); + }); + }); +}