yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

V15 Added acceptance tests for data type default configuration (#18740)

Browse Source 
* Added tests for Approved Color default configuration

* Updated tests for Approved Color configuration

* Added tests for ChecklboxList configuration

* Added tests for Data type default configuration - part 1

* Added tests for data type configuration and updated tests due to test helper changes

* Added more steps to verify the default configuration

* Added tests for the default configuration and refactoring code

* Added steps to verify the TinyMCE default configuration

* Bumped version

* Fixed tests due to test helper changes

* Make all Data Type tests run in the pipeline

* Updated assertion steps

* Fixed format

* Bumped version

* Bumped version

* Comment failing tests

* Reverted npm command
This commit is contained in:
Nhu Dinh
2025-03-27 10:42:13 +07:00
committed by GitHub
parent 9c88326681
commit 94f0add4d9
27 changed files with 1082 additions and 1253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
tests/Umbraco.Tests.AcceptanceTest/package-lock.json generated
View File

@@ -8,7 +8,7 @@
"hasInstallScript": true,
"dependencies": {
"@umbraco/json-models-builders": "^2.0.31",
"@umbraco/playwright-testhelpers": "^15.0.39",
"@umbraco/playwright-testhelpers": "^15.0.40",
"camelize": "^1.0.0",
"dotenv": "^16.3.1",
"node-fetch": "^2.6.7"
@@ -67,9 +67,9 @@
}
},
"node_modules/@umbraco/playwright-testhelpers": {
"version": "15.0.39",
"resolved": "https://registry.npmjs.org/@umbraco/playwright-testhelpers/-/playwright-testhelpers-15.0.39.tgz",
"integrity": "sha512-dNl+P5LOW4CZrlzt7TnXOKUDeHI3juN/BfG9b0P/selpiFPrseH1HrB0myJVmPfuq4KCa+490VTu46qXHGwGLw==",
"version": "15.0.40",
"resolved": "https://registry.npmjs.org/@umbraco/playwright-testhelpers/-/playwright-testhelpers-15.0.40.tgz",
"integrity": "sha512-dxXCCYeUH0rlASdHHNu8gQQrhK52gxGcwb/K1BlXFsr7Z7dz1U5eYMPUiVjDVg6LNCbqmQ/tmZqoAZLU5zDzIw==",
"dependencies": {
"@umbraco/json-models-builders": "2.0.31",
"node-fetch": "^2.6.7"

2
tests/Umbraco.Tests.AcceptanceTest/package.json
View File

@@ -21,7 +21,7 @@
},
"dependencies": {
"@umbraco/json-models-builders": "^2.0.31",
"@umbraco/playwright-testhelpers": "^15.0.39",
"@umbraco/playwright-testhelpers": "^15.0.40",
"camelize": "^1.0.0",
"dotenv": "^16.3.1",
"node-fetch": "^2.6.7"

2
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/ContentWithApprovedColor.spec.ts
View File

@@ -63,7 +63,7 @@ test('can create content with the custom approved color data type', async ({umbr
const customDataTypeName = 'CustomApprovedColor';
const colorValue = 'd73737';
const colorLabel = 'Test Label';
const customDataTypeId = await umbracoApi.dataType.createApprovedColorDataTypeWithOneItem(customDataTypeName, colorLabel, colorValue);
const customDataTypeId = await umbracoApi.dataType.createDefaultApprovedColorDataTypeWithOneItem(customDataTypeName, colorLabel, colorValue);
const documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, customDataTypeName, customDataTypeId);
await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
await umbracoUi.content.goToSection(ConstantHelper.sections.content);

98
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ApprovedColor.spec.ts
View File

@@ -1,102 +1,78 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Approved Color';
let dataTypeDefaultData = null;
let dataTypeData = null;
const colorValue = 'ffffff';
const colorLabel = '';
const customDataTypeName = 'Custom Approved Color';
const editorAlias = 'Umbraco.ColorPicker';
const editorUiAlias = 'Umb.PropertyEditorUi.ColorPicker';
const colorValue = '9c2121';
const colorLabel = 'red';
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
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);
await umbracoApi.dataType.createDefaultApprovedColorDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickIncludeLabelsToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'useLabel', true)).toBeTruthy();
});
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);
await umbracoApi.dataType.createDefaultApprovedColorDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.addColor(colorValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesApprovedColorHaveColor(customDataTypeName, colorValue)).toBeTruthy();
});
test('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);
await umbracoApi.dataType.createApprovedColorDataTypeWithOneItem(customDataTypeName, colorLabel, colorValue);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.removeColorByValue(colorValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesApprovedColorHaveColor(customDataTypeName, colorValue)).toBeFalsy();;
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.approvedColorSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.approvedColorSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'useLabel')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'items')).toBeFalsy();
});

86
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/CheckboxList.spec.ts
View File

@@ -1,36 +1,26 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Checkbox list';
let dataTypeDefaultData = null;
let dataTypeData = null;
const customDataTypeName = 'Custom Checkbox List';
const editorAlias = 'Umbraco.CheckBoxList';
const editorUiAlias = 'Umb.PropertyEditorUi.CheckBoxList';
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can add option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const optionName = 'Test option';
const expectedDataTypeValues = [
{
"alias": "items",
"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);
await umbracoApi.dataType.createCheckboxListDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickAddOptionButton();
@@ -38,61 +28,53 @@ test('can add option', async ({umbracoApi, umbracoUi}) => {
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'items', [optionName])).toBeTruthy();
});
test('can remove option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const removedOptionName = 'Removed Option';
const removedOptionValues = [
{
"alias": "items",
"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);
await umbracoApi.dataType.createCheckboxListDataType(customDataTypeName, [removedOptionName]);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.removeOptionByName(removedOptionName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
const customDataTypeData = await umbracoApi.dataType.getByName(customDataTypeName);
expect(customDataTypeData.values).toEqual([]);
});
test('can update option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const optionName = 'Test option';
const updatedOptionName = 'Updated option';
const optionValues = [
{
"alias": "items",
"value": [optionName]
}
];
const expectedOptionValues = [
{
"alias": "items",
"value": [updatedOptionName]
}
];
// Remove all existing options and add an option to update
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
dataTypeData.values = optionValues;
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoApi.dataType.createCheckboxListDataType(customDataTypeName, [optionName]);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterOptionName(updatedOptionName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedOptionValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'items', [updatedOptionName])).toBeTruthy();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.checkboxListSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.checkboxListSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName)
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'items')).toBeFalsy();
});

75
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ContentPicker.spec.ts
View File

@@ -1,37 +1,33 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Content Picker';
let dataTypeDefaultData = null;
let dataTypeData = null;
const customDataTypeName = 'Custom Content Picker';
const editorAlias = 'Umbraco.ContentPicker';
const editorUiAlias = 'Umb.PropertyEditorUi.DocumentPicker';
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "ignoreUserStartNodes",
"value": true
};
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoApi.dataType.createDefaultContentPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickIgnoreUserStartNodesToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'ignoreUserStartNodes', true)).toBeTruthy();
});
test('can add start node', async ({umbracoApi, umbracoUi}) => {
@@ -39,17 +35,12 @@ test('can add start node', async ({umbracoApi, umbracoUi}) => {
// Create content
const documentTypeName = 'TestDocumentType';
const contentName = 'TestStartNode';
await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
const documentTypeId = await umbracoApi.documentType.createDefaultDocumentTypeWithAllowAsRoot(documentTypeName);
await umbracoApi.document.ensureNameNotExists(contentName);
const contentId = await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
expect(await umbracoApi.document.doesExist(contentId)).toBeTruthy();
const expectedDataTypeValues = {
"alias": "startNodeId",
"value": contentId
};
await umbracoUi.dataType.goToDataType(dataTypeName);
// Create data type
await umbracoApi.dataType.createDefaultContentPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickChooseButton();
@@ -57,8 +48,8 @@ test('can add start node', async ({umbracoApi, umbracoUi}) => {
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'startNodeId', contentId)).toBeTruthy();
// Clean
await umbracoApi.document.ensureNameNotExists(contentName);
@@ -70,32 +61,38 @@ test('can remove start node', async ({umbracoApi, umbracoUi}) => {
// Create content
const documentTypeName = 'TestDocumentType';
const contentName = 'TestStartNode';
await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
const documentTypeId = await umbracoApi.documentType.createDefaultDocumentTypeWithAllowAsRoot(documentTypeName);
await umbracoApi.document.ensureNameNotExists(contentName);
const contentId = await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
expect(await umbracoApi.document.doesExist(contentId)).toBeTruthy();
const removedDataTypeValues = [{
"alias": "startNodeId",
"value": contentId
}];
// Remove all existing values and add a start node to remove
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
dataTypeData.values = removedDataTypeValues;
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoUi.dataType.goToDataType(dataTypeName);
// Create data type
await umbracoApi.dataType.createContentPickerDataTypeWithStartNode(customDataTypeName, contentId);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.removeContentStartNode(contentName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const customDataTypeData = await umbracoApi.dataType.getByName(customDataTypeName);
expect(customDataTypeData.values).toEqual([]);
// Clean
await umbracoApi.document.ensureNameNotExists(contentName);
await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.contentPickerSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.contentPickerSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
});

7
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DataType.spec.ts
View File

@@ -103,10 +103,6 @@ test('cannot create a data type without selecting the property editor', {tag: '@
test('can change settings', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
// Arrange
const maxCharsValue = 126;
const expectedDataTypeValues = {
"alias": "maxChars",
"value": maxCharsValue
};
await umbracoApi.dataType.createTextstringDataType(dataTypeName);
expect(await umbracoApi.dataType.doesNameExist(dataTypeName)).toBeTruthy();
@@ -117,6 +113,5 @@ test('can change settings', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) =>
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'maxChars', maxCharsValue)).toBeTruthy();
});

92
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/DatePicker.spec.ts
View File

@@ -1,75 +1,49 @@
import { test } from "@umbraco/playwright-testhelpers";
import { ConstantHelper, NotificationConstantHelper, 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;
const editorAlias = 'Umbraco.DateTime';
const editorUiAlias = 'Umb.PropertyEditorUi.DatePicker';
const datePickerTypes = [
{type: 'Date Picker', format: 'YYYY-MM-DD'},
{type: 'Date Picker with time', format: 'YYYY-MM-DD HH:mm:ss'}
];
const customDataTypeName = 'Custom DateTime';
test.beforeEach(async ({ umbracoUi, umbracoApi }) => {
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);
});
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({ umbracoApi }) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id,dataTypeDefaultData);
}
});
test.afterEach(async ({umbracoApi}) => {
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
// This test is out-of-date since currently it is impossible to update offset time in front-end
test.skip(`can update offset time`, async ({ umbracoApi, umbracoUi }) => {
test('can update date format', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues =
datePickerType === 'Date Picker'
? [
{
"alias": "format",
"value": "YYYY-MM-DD",
},
{
"alias": "offsetTime",
"value": true,
},
]
: [
{
"alias": "format",
"value": "YYYY-MM-DD HH:mm:ss",
},
{
"alias": "offsetTime",
"value": true,
}
];
const dateFormatValue = 'DD-MM-YYYY hh:mm:ss';
await umbracoApi.dataType.createDefaultDateTimeDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickOffsetTimeToggle();
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).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'format', dateFormatValue)).toBeTruthy();
});
for (const datePickerType of datePickerTypes) {
test(`the default configuration of ${datePickerType.type} is correct`, async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(datePickerType.type);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.datePickerSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.datePickerSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(datePickerType.type, 'format', datePickerType.format)).toBeTruthy();
});
}

85
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Dropdown.spec.ts
View File

@@ -1,57 +1,43 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Dropdown';
let dataTypeDefaultData = null;
let dataTypeData = null;
const customDataTypeName = 'Custom Dropdown';
const editorAlias = 'Umbraco.DropDown.Flexible';
const editorUiAlias = 'Umb.PropertyEditorUi.Dropdown';
const dropdowns = [
{type: 'Dropdown', multipleChoice: false},
{type: 'Dropdown multiple', multipleChoice: true}
];
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can enable multiple choice', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = [{
"alias": "multiple",
"value": true
}];
// Remove all existing options
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
dataTypeData.values = [];
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoApi.dataType.createDefaultDropdownDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickEnableMultipleChoiceToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'multiple', true)).toBeTruthy();
});
test('can add option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const optionName = 'Test option';
const expectedDataTypeValues = [
{
"alias": "items",
"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);
await umbracoApi.dataType.createDefaultDropdownDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickAddOptionButton();
@@ -59,30 +45,39 @@ test('can add option', async ({umbracoApi, umbracoUi}) => {
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'items', [optionName])).toBeTruthy();
});
test('can remove option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const removedOptionName = 'Removed Option';
const removedOptionValues = [
{
"alias": "items",
"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);
await umbracoApi.dataType.createDropdownDataType(customDataTypeName, false, [removedOptionName]);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.removeOptionByName(removedOptionName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'items', [removedOptionName])).toBeFalsy();
});
for (const dropdown of dropdowns) {
test(`the default configuration of ${dropdown.type} is correct`, async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dropdown.type);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.dropdownSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.dropdownSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dropdown.type);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dropdown.type, 'multiple', dropdown.multipleChoice)).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dropdown.type, 'items')).toBeFalsy();
});
}

120
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ImageCropper.spec.ts
View File

@@ -1,41 +1,26 @@
import {test} from '@umbraco/playwright-testhelpers';
import {AliasHelper, ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Image Cropper';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.ImageCropper';
const editorUiAlias = 'Umb.PropertyEditorUi.ImageCropper';
const customDataTypeName = 'Custom Image Cropper';
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can add crop', async ({umbracoApi, umbracoUi}) => {
// Arrange
const cropData = ['Test Label', 'Test Alias', 100, 50];
const expectedDataTypeValues = [{
"alias": "crops",
"value": [
{
"label": cropData[0],
"alias": cropData[1],
"width": cropData[2],
"height": cropData[3]
}
]
}];
// Remove all existing crops
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
dataTypeData.values = [];
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoApi.dataType.createDefaultImageCropperDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterCropValues(
@@ -48,79 +33,56 @@ test('can add crop', async ({umbracoApi, umbracoUi}) => {
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveCrops(customDataTypeName, cropData[0], cropData[1], cropData[2], cropData[3])).toBeTruthy();
});
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 Label', 'Updated Test Alias', 100, 50];
const expectedDataTypeValues = [{
"alias": "crops",
"value": [
{
"label": updatedCropData[0],
"alias": updatedCropData[1],
"width": updatedCropData[2],
"height": updatedCropData[3]
}
]
}];
// 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);
const cropData = ['Test Label', AliasHelper.toAlias('Test Label'), 100, 50];
const updatedCropData = ['Updated Label', AliasHelper.toAlias('Updated Label'), 80, 30];
await umbracoApi.dataType.createImageCropperDataTypeWithOneCrop(customDataTypeName, cropData[0], cropData[2], cropData[3]);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.editCropByAlias(wrongCropData[0].toString());
await umbracoUi.dataType.enterCropValues(updatedCropData[0].toString(), updatedCropData[1].toString(), updatedCropData[2].toString(), updatedCropData[3].toString());
await umbracoUi.dataType.editCropByAlias(cropData[0]);
await umbracoUi.dataType.enterCropValues(updatedCropData[0], updatedCropData[1], updatedCropData[2].toString(), updatedCropData[3].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);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveCrops(customDataTypeName, updatedCropData[0], updatedCropData[1], updatedCropData[2], updatedCropData[3])).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveCrops(customDataTypeName, cropData[0], cropData[1], cropData[2], cropData[3])).toBeFalsy();
});
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);
const cropData = ['Deleted Alias', AliasHelper.toAlias('Deleted Alias'), 50, 100];
await umbracoApi.dataType.createImageCropperDataTypeWithOneCrop(customDataTypeName, cropData[0], cropData[2], cropData[3]);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.removeCropByAlias(wrongCropData[0].toString());
await umbracoUi.dataType.removeCropByAlias(cropData[0].toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveCrops(customDataTypeName, cropData[0], cropData[1], cropData[2], cropData[3])).toBeFalsy();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.imageCropperSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.imageCropperSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'crops')).toBeFalsy();
});

63
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Label.spec.ts
View File

@@ -1,41 +1,52 @@
import { test } from "@umbraco/playwright-testhelpers";
import { ConstantHelper, NotificationConstantHelper, 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;
const labelTypes = [
{type: 'Label (bigint)', dataValueType: 'BIGINT'},
{type: 'Label (datetime)', dataValueType: 'DATETIME'},
{type: 'Label (decimal)', dataValueType: 'DECIMAL'},
{type: 'Label (integer)', dataValueType: 'INT'},
{type: 'Label (string)', dataValueType: 'STRING'},
{type: 'Label (time)', dataValueType: 'TIME'}
];
const editorAlias = 'Umbraco.Label';
const editorUiAlias = 'Umb.PropertyEditorUi.Label';
const customDataTypeName = 'Custom Label';
test.beforeEach(async ({ umbracoUi, umbracoApi }) => {
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);
});
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({ umbracoApi }) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id,dataTypeDefaultData);
}
});
test.afterEach(async ({umbracoApi}) => {
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can change value type', async ({ umbracoApi, umbracoUi }) => {
test('can change value type', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = [
{
"alias": "umbracoDataValueType",
"value": "TEXT",
}
];
await umbracoApi.dataType.createDefaultLabelDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.changeValueType("Long String");
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(labelType);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'umbracoDataValueType', 'TEXT')).toBeTruthy();
});
for (const label of labelTypes) {
test(`the default configuration of ${label.type} is correct`, async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(label.type);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.labelSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.labelSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(label.type, 'umbracoDataValueType', label.dataValueType)).toBeTruthy();
});
}

300
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/ListView.spec.ts
View File

@@ -1,292 +1,198 @@
import { test } from "@umbraco/playwright-testhelpers";
import { ConstantHelper, NotificationConstantHelper, test } from "@umbraco/playwright-testhelpers";
import { expect } from "@playwright/test";
const listViewTypes = ['List View - Content', 'List View - Media'];
for (const listViewType of listViewTypes) {
test.describe(`${listViewType} tests`, () => {
let dataTypeDefaultData = null;
let dataTypeData = null;
const listViewTypes = [
{type: 'List View - Content', collectionViewGird: 'Umb.CollectionView.Document.Grid', collectionViewList: 'Umb.CollectionView.Document.Table'},
{type: 'List View - Media', collectionViewGird: 'Umb.CollectionView.Media.Grid', collectionViewList: 'Umb.CollectionView.Media.Table'}
];
const editorAlias = 'Umbraco.ListView';
const editorUiAlias = 'Umb.PropertyEditorUi.Collection';
const customDataTypeName = 'Custom List View';
test.beforeEach(async ({ umbracoUi, umbracoApi }) => {
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(listViewType);
});
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({ umbracoApi }) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id,dataTypeDefaultData);
}
});
test.afterEach(async ({umbracoApi}) => {
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update page size', async ({umbracoApi, umbracoUi}) => {
test('can update page size', async ({umbracoApi, umbracoUi}) => {
// Arrange
const pageSizeValue = 5;
const expectedDataTypeValues = {
"alias": "pageSize",
"value": pageSizeValue
};
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.enterPageSizeValue(pageSizeValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'pageSize', pageSizeValue)).toBeTruthy();
});
test('can update order direction', async ({umbracoApi, umbracoUi}) => {
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
};
const orderDirectionValue = 'asc';
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.chooseOrderDirection(isAscending);
await umbracoUi.dataType.chooseOrderDirection(true);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'orderDirection', orderDirectionValue)).toBeTruthy();
});
test('can add column displayed', async ({umbracoApi, umbracoUi}) => {
test('can add column displayed', async ({umbracoApi, umbracoUi}) => {
// Arrange
let columnData: string[];
if (listViewType === 'List View - Media') {
columnData = ['Document Type', 'TestDocumentType', 'sortOrder', 'Sort'];
await umbracoApi.documentType.ensureNameNotExists(columnData[1]);
const columnData = ['Document Type', 'TestDocumentType', 'sortOrder', 'Sort'];
await umbracoApi.documentType.createDefaultDocumentTypeWithAllowAsRoot(columnData[1]);
} else {
columnData = ['Media Type', 'Audio', 'sortOrder', 'Sort'];
}
const expectedIncludePropertiesValues = {
"alias": columnData[2],
"header": columnData[3],
"isSystem": 1
};
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.addColumnDisplayed(columnData[0], columnData[1], columnData[2]);
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);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesListViewHaveProperty(customDataTypeName, columnData[3], columnData[2], 1)).toBeTruthy();
});
test('can remove column displayed', async ({umbracoApi, umbracoUi}) => {
test('can remove column displayed', async ({umbracoApi, umbracoUi}) => {
// Arrange
let columnData: string[];
if (listViewType === 'List View - Media') {
columnData = ['Document Type', 'TestDocumentType', 'owner', 'Created by'];
await umbracoApi.documentType.ensureNameNotExists(columnData[1]);
await umbracoApi.documentType.createDefaultDocumentTypeWithAllowAsRoot(columnData[1]);
} else {
columnData = ['Media Type', 'Audio', 'owner', 'Created by'];
}
const removedDataTypeValues = [{
"alias": "includeProperties",
"value": [{
"alias": columnData[2],
"header": columnData[3],
"isSystem": 1,
}]
}];
// Remove all existing values and add a column displayed to remove
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
dataTypeData.values = removedDataTypeValues;
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
expect(await umbracoApi.dataType.doesListViewHaveProperty(customDataTypeName, 'Last edited', 'updateDate')).toBeTruthy();
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.removeColumnDisplayed(columnData[2]);
await umbracoUi.dataType.removeColumnDisplayed('updateDate');
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toEqual([]);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesListViewHaveProperty(customDataTypeName, 'Last edited', 'updateDate')).toBeFalsy();
});
test('can add layouts', async ({umbracoApi, umbracoUi}) => {
test('can add layouts', async ({umbracoApi, umbracoUi}) => {
// Arrange
const layoutName = 'Extension Table Collection View';
const layoutCollectionView = 'Umb.CollectionView.Extension.Table';
const expectedIncludePropertiesValues = {
"icon": "icon-list",
"name": layoutName,
"collectionView": layoutCollectionView,
};
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.addLayouts(layoutName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
const includePropertiesData = dataTypeData.values.find(value => value.alias === "layouts");
expect(includePropertiesData.value).toContainEqual(expectedIncludePropertiesValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesListViewHaveLayout(customDataTypeName, layoutName, 'icon-list', layoutCollectionView)).toBeTruthy();
});
test('can remove layouts', async ({umbracoApi, umbracoUi}) => {
test('can remove layouts', async ({umbracoApi, umbracoUi}) => {
// Arrange
let layoutsData = 'Document Grid Collection View';
if (listViewType === 'List View - Media') {
layoutsData = 'Media Grid Collection View';
}
const removedDataTypeValues = [{
"alias": "layouts",
"value": [{
"icon": "icon-thumbnails-small",
"collectionView": layoutsData,
"isSystem": true,
"name": "Grid",
"selected": true
}]
}];
// Remove all existing values and add a layout to remove
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
dataTypeData.values = removedDataTypeValues;
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
const layoutName = 'List';
const layoutCollectionView = 'Umb.CollectionView.Document.Table';
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
expect(await umbracoApi.dataType.doesListViewHaveLayout(customDataTypeName, layoutName, 'icon-list', layoutCollectionView)).toBeTruthy();
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.removeLayouts(layoutsData);
await umbracoUi.dataType.removeLayouts(layoutCollectionView);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toEqual([]);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesListViewHaveLayout(customDataTypeName, layoutName, 'icon-list', layoutCollectionView)).toBeFalsy();
});
test('can update order by', async ({umbracoApi, umbracoUi}) => {
test('can update order by', async ({umbracoApi, umbracoUi}) => {
// Arrange
const orderByValue = 'Last edited';
const expectedDataTypeValues = {
"alias": "orderBy",
"value": "updateDate"
};
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.chooseOrderByValue(orderByValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'orderBy', 'updateDate')).toBeTruthy();
});
// Skip this test as currently there is no setting for bulk action permission
test.skip('can update bulk action permission', async ({umbracoApi, umbracoUi}) => {
// Arrange
const bulkActionPermissionValue = 'Allow bulk trash';
const expectedDataTypeValues = {
"alias": "bulkActionPermissions",
"value": {
"allowBulkCopy": false,
"allowBulkDelete": true,
"allowBulkMove": false,
"allowBulkPublish": false,
"allowBulkUnpublish": false
}
};
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.clickBulkActionPermissionsToggleByValue(bulkActionPermissionValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
test('can update workspace view icon', async ({umbracoApi, umbracoUi}) => {
test('can update workspace view icon', async ({umbracoApi, umbracoUi}) => {
// Arrange
const iconValue = 'icon-activity';
const expectedDataTypeValues = {
"alias": "icon",
"value": iconValue
};
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.clickSelectIconButton();
await umbracoUi.dataType.chooseWorkspaceViewIconByValue(iconValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'icon', iconValue)).toBeTruthy();
});
test('can update workspace view name', async ({umbracoApi, umbracoUi}) => {
test('can update workspace view name', async ({umbracoApi, umbracoUi}) => {
// Arrange
const WorkspaceViewName = 'Test Content Name';
const expectedDataTypeValues = {
"alias": "tabName",
"value": WorkspaceViewName
};
const workspaceViewName = 'Test Content Name';
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.enterWorkspaceViewName(WorkspaceViewName);
await umbracoUi.dataType.enterWorkspaceViewName(workspaceViewName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'tabName', workspaceViewName)).toBeTruthy();
});
test('can enable show content workspace view first', async ({umbracoApi, umbracoUi}) => {
test('can enable show content workspace view first', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "showContentFirst",
"value": true
};
await umbracoApi.dataType.createListViewContentDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.clickShowContentWorkspaceViewFirstToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
// Skip this test as there are no setting for infinite editor
test.skip('can enable edit in infinite editor', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "useInfiniteEditor",
"value": true
};
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'showContentFirst', true)).toBeTruthy();
});
for (const listView of listViewTypes) {
test(`the default configuration of ${listView.type} is correct`, async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(listViewType);
await umbracoUi.dataType.clickEditInInfiniteEditorToggle();
await umbracoUi.dataType.clickSaveButton();
await umbracoUi.dataType.goToDataType(listView.type);
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(listViewType);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.listViewSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.listViewSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(listView.type, 'pageSize', 100)).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(listView.type, 'orderBy', 'updateDate')).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(listView.type, 'orderDirection', 'desc')).toBeTruthy();
expect(await umbracoApi.dataType.doesListViewHaveLayout(listView.type, 'Grid', 'icon-thumbnails-small', listView.collectionViewGird)).toBeTruthy();
expect(await umbracoApi.dataType.doesListViewHaveLayout(listView.type, 'List', 'icon-list', listView.collectionViewList)).toBeTruthy();
expect(await umbracoApi.dataType.doesListViewHaveProperty(listView.type, 'Last edited', 'updateDate')).toBeTruthy();
expect(await umbracoApi.dataType.doesListViewHaveProperty(listView.type, 'Updated by', 'creator')).toBeTruthy();
// TODO: Uncomment this when the front-end is ready. Currently there is no default icon for workspace view icon
// expect(await umbracoApi.dataType.doesDataTypeHaveValue(listView.type, 'icon', 'icon-list')).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(listView.type, 'tabName')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(listView.type, 'showContentFirst')).toBeFalsy();
});
}

232
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/MediaPicker.spec.ts
View File

@@ -1,237 +1,203 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypes = ['Media Picker', 'Multiple Media Picker', 'Image Media Picker', 'Multiple Image Media Picker'];
for (const dataTypeName of dataTypes) {
test.describe(`${dataTypeName} tests`, () => {
let dataTypeDefaultData = null;
let dataTypeData = null;
const mediaPickerTypes = [
{type: 'Media Picker', isMultiple: false},
{type: 'Multiple Media Picker', isMultiple: true},
{type: 'Image Media Picker', isMultiple: false},
{type: 'Multiple Image Media Picker', isMultiple: true},
];
const editorAlias = 'Umbraco.MediaPicker3';
const editorUiAlias = 'Umb.PropertyEditorUi.MediaPicker';
const customDataTypeName = 'Custom Media Picker';
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
});
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
});
test.afterEach(async ({umbracoApi}) => {
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update pick multiple items', async ({umbracoApi, umbracoUi}) => {
test('can update pick multiple items', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "multiple",
"value": dataTypeName === 'Media Picker' || dataTypeName === 'Image Media Picker' ? true : false,
};
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.clickPickMultipleItemsToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'multiple', true)).toBeTruthy();
});
test('can update amount', async ({umbracoApi, umbracoUi}) => {
test('can update amount', async ({umbracoApi, umbracoUi}) => {
// Arrange
const lowValue = 5;
const highValue = 1000;
const expectedDataTypeValues = {
"alias": "validationLimit",
"value": {
"min": lowValue,
"max": highValue
}
};
const minValue = 5;
const maxValue = 1000;
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.enterAmountValue(lowValue.toString(), highValue.toString());
await umbracoUi.dataType.enterAmountValue(minValue.toString(), maxValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesMediaPickerHaveMinAndMaxAmount(customDataTypeName, minValue, maxValue)).toBeTruthy();
});
test('can update enable focal point', async ({umbracoApi, umbracoUi}) => {
test('can update enable focal point', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "enableLocalFocalPoint",
"value": true
};
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.clickEnableFocalPointToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'enableLocalFocalPoint', true)).toBeTruthy();
});
test('can add image crop', async ({umbracoApi, umbracoUi}) => {
test('can add image crop', async ({umbracoApi, umbracoUi}) => {
// Arrange
const cropData = ['Test Label', 'Test Alias', 100, 50];
const expectedDataTypeValues = {
"alias": "crops",
"value": [
{
"label": cropData[0],
"alias": cropData[1],
"width": cropData[2],
"height": cropData[3]
}
]
};
const cropData = ['Test Label', 'testAlias', 100, 50];
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.waitForTimeout(500);
await umbracoUi.dataType.enterCropValues(
cropData[0].toString(),
cropData[1].toString(),
cropData[2].toString(),
cropData[3].toString()
);
await umbracoUi.waitForTimeout(500);
await umbracoUi.dataType.clickAddCropButton();
await umbracoUi.dataType.clickSaveButton();
await umbracoUi.waitForTimeout(500);
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveCrops(customDataTypeName, cropData[0], cropData[1], cropData[2], cropData[3])).toBeTruthy();
});
test('can update ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
test('can update ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "ignoreUserStartNodes",
"value": true
};
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.clickIgnoreUserStartNodesToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'ignoreUserStartNodes', true)).toBeTruthy();
});
test('can add accepted types', async ({umbracoApi, umbracoUi}) => {
test('can add accepted types', async ({umbracoApi, umbracoUi}) => {
// Arrange
const mediaTypeName = 'Audio';
const mediaTypeData = await umbracoApi.mediaType.getByName(mediaTypeName);
const imageTypeData = await umbracoApi.mediaType.getByName('Image');
const expectedFilterValue =
dataTypeName === "Image Media Picker" ||
dataTypeName === "Multiple Image Media Picker"
? imageTypeData.id + "," + mediaTypeData.id
: mediaTypeData.id;
const expectedDataTypeValues = {
"alias": "filter",
"value": expectedFilterValue
};
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.addAcceptedType(mediaTypeName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'filter', mediaTypeData.id)).toBeTruthy();
});
test('can remove accepted types', async ({umbracoApi, umbracoUi}) => {
test('can remove accepted types', async ({umbracoApi, umbracoUi}) => {
// Arrange
const mediaTypeName = 'Audio';
const mediaTypeName = 'Image';
const mediaTypeData = await umbracoApi.mediaType.getByName(mediaTypeName);
const removedDataTypeValues = [{
"alias": "filter",
"value": mediaTypeData.id
}];
const expectedDataTypeValues = [];
// Remove all existing options and add an option to remove
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
dataTypeData.values = removedDataTypeValues;
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoApi.dataType.createImageMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.removeAcceptedType(mediaTypeName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
});
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'filter', mediaTypeData.id)).toBeFalsy();
});
test('can add start node', async ({umbracoApi, umbracoUi}) => {
test('can add start node', async ({umbracoApi, umbracoUi}) => {
// Arrange
// Create media
const mediaName = 'TestStartNode';
await umbracoApi.media.ensureNameNotExists(mediaName);
const mediaId = await umbracoApi.media.createDefaultMediaWithArticle(mediaName);
expect(await umbracoApi.media.doesNameExist(mediaName)).toBeTruthy();
const expectedDataTypeValues = {
"alias": "startNodeId",
"value": mediaId
};
await umbracoApi.dataType.createDefaultMediaPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.clickChooseStartNodeButton();
await umbracoUi.dataType.addMediaStartNode(mediaName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'startNodeId', mediaId)).toBeTruthy();
// Clean
await umbracoApi.media.ensureNameNotExists(mediaName);
});
});
test('can remove start node', async ({umbracoApi, umbracoUi}) => {
test('can remove start node', async ({umbracoApi, umbracoUi}) => {
// Arrange
// Create media
const mediaName = 'TestStartNode';
await umbracoApi.media.ensureNameNotExists(mediaName);
const mediaId = await umbracoApi.media.createDefaultMediaWithArticle(mediaName);
expect(await umbracoApi.media.doesNameExist(mediaName)).toBeTruthy();
const removedDataTypeValues = [{
"alias": "startNodeId",
"value": mediaId
}];
// Remove all existing values and add a start node to remove
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
dataTypeData.values = removedDataTypeValues;
await umbracoApi.dataType.update(dataTypeData.id, dataTypeData);
await umbracoApi.dataType.createImageMediaPickerDataTypeWithStartNodeId(customDataTypeName, mediaId);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
await umbracoUi.dataType.removeMediaStartNode(mediaName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'startNodeId', mediaId)).toBeFalsy();
// Clean
await umbracoApi.media.ensureNameNotExists(mediaName);
});
});
for (const mediaPicker of mediaPickerTypes) {
test(`the default configuration of ${mediaPicker.type} is correct`, async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(mediaPicker.type);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.mediaPickerSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.mediaPickerSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(mediaPicker.type, 'multiple', mediaPicker.isMultiple)).toBeTruthy();
if (mediaPicker.type.includes('Image')) {
const imageTypeData = await umbracoApi.mediaType.getByName('Image');
expect(await umbracoApi.dataType.doesDataTypeHaveValue(mediaPicker.type, 'filter', imageTypeData.id)).toBeTruthy();
}
if (!mediaPicker.type.includes('Multiple')) {
expect(await umbracoApi.dataType.doesMediaPickerHaveMinAndMaxAmount(mediaPicker.type, 0, 1)).toBeTruthy();
}
expect(await umbracoApi.dataType.doesDataTypeHaveValue(mediaPicker.type, 'startNodeId')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(mediaPicker.type, 'ignoreUserStartNodes')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(mediaPicker.type, 'crops')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(mediaPicker.type, 'enableLocalFocalPoint')).toBeFalsy();
});
}

22
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/MemberPicker.spec.ts Normal file
View File

@@ -0,0 +1,22 @@
import {test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Member Picker';
const editorAlias = 'Umbraco.MemberPicker';
const editorUiAlias = 'Umb.PropertyEditorUi.MemberPicker';
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingsContainText('There is no configuration for this property editor.');
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
});

88
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/MultiUrlPicker.spec.ts
View File

@@ -1,111 +1,101 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Multi URL Picker';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.MultiUrlPicker';
const editorUiAlias = 'Umb.PropertyEditorUi.MultiUrlPicker';
const customDataTypeName = 'Custom Multi URL Picker';
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);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update minimum number of items value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const minimumValue = 2;
const expectedDataTypeValues = {
"alias": "minNumber",
"value": minimumValue
};
await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMinimumNumberOfItemsValue(minimumValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'minNumber', minimumValue)).toBeTruthy();
});
test('can update maximum number of items value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const maximumValue = 2;
const expectedDataTypeValues = {
"alias": "maxNumber",
"value": maximumValue
};
await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMaximumNumberOfItemsValue(maximumValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'maxNumber', maximumValue)).toBeTruthy();
});
test('can enable ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "ignoreUserStartNodes",
"value": true
};
await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickIgnoreUserStartNodesToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'ignoreUserStartNodes', true)).toBeTruthy();
});
test('can update overlay size', async ({umbracoApi, umbracoUi}) => {
// Arrange
const overlaySizeValue = 'large';
const expectedDataTypeValues = {
"alias": "overlaySize",
"value": overlaySizeValue
};
await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.chooseOverlaySizeByValue(overlaySizeValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'overlaySize', overlaySizeValue)).toBeTruthy();
});
test('can update hide anchor/query string input', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "hideAnchor",
"value": true
};
await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickHideAnchorQueryStringInputToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'hideAnchor', true)).toBeTruthy();
});
// TODO: Remove skip when the front-end is ready. Currently you still can update the minimum greater than the maximum.
test.skip('cannot update the minimum number of items greater than the maximum', async ({umbracoUi}) => {
test.skip('cannot update the minimum number of items greater than the maximum', async ({umbracoApi, umbracoUi}) => {
// Arrange
const minimumValue = 5;
const maximumValue = 2;
await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMinimumNumberOfItemsValue(minimumValue.toString());
@@ -115,3 +105,23 @@ test.skip('cannot update the minimum number of items greater than the maximum',
// Assert
await umbracoUi.dataType.isErrorNotificationVisible();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.multiURLPickerSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.multiURLPickerSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'minNumber')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'maxNumber')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'ignoreUserStartNodes')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'overlaySize')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'hideAnchor')).toBeFalsy();
});

77
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Numeric.spec.ts
View File

@@ -1,95 +1,88 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Numeric';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.Integer';
const editorUiAlias = 'Umb.PropertyEditorUi.Integer';
const customDataTypeName = 'Custom Numeric';
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);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update minimum value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const minimumValue = -5;
const expectedDataTypeValues = {
"alias": "min",
"value": minimumValue
};
await umbracoApi.dataType.createDefaultNumericDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMinimumValue(minimumValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'min', minimumValue)).toBeTruthy();
});
test('can update Maximum value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const maximumValue = 1000000;
const expectedDataTypeValues = {
"alias": "max",
"value": maximumValue
};
await umbracoApi.dataType.createDefaultNumericDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMaximumValue(maximumValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'max', maximumValue)).toBeTruthy();
});
test('can update step size value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const stepSizeValue = 5;
const expectedDataTypeValues = {
"alias": "step",
"value": stepSizeValue
};
await umbracoApi.dataType.createDefaultNumericDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterStepSizeValue(stepSizeValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'step', stepSizeValue)).toBeTruthy();
});
// Skip this test as currently this setting is removed.
test.skip('can allow decimals', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "allowDecimals",
"value": true
};
await umbracoApi.dataType.createDefaultNumericDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickAllowDecimalsToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'allowDecimals', true)).toBeTruthy();
});
// TODO: Remove skip when the front-end is ready. Currently you still can update the minimum greater than the maximum.
test.skip('cannot update the minimum greater than the maximum', async ({umbracoUi}) => {
test.skip('cannot update the minimum greater than the maximum', async ({umbracoApi, umbracoUi}) => {
// Arrange
const minimumValue = 5;
const maximumValue = 2;
await umbracoApi.dataType.createDefaultNumericDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMinimumValue(minimumValue.toString());
@@ -99,3 +92,21 @@ test.skip('cannot update the minimum greater than the maximum', async ({umbracoU
// Assert
await umbracoUi.dataType.isErrorNotificationVisible();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.numericSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.numericSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'min')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'max')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'step')).toBeFalsy();
});

67
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Radiobox.spec.ts
View File

@@ -1,36 +1,26 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Radiobox';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.RadioButtonList';
const editorUiAlias = 'Umb.PropertyEditorUi.RadioButtonList';
const customDataTypeName = 'Custom Radiobox';
test.beforeEach(async ({umbracoUi, umbracoApi}) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can add option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const optionName = 'Test option';
const expectedDataTypeValues = [
{
"alias": "items",
"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);
await umbracoApi.dataType.createRadioboxDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickAddOptionButton();
@@ -38,30 +28,41 @@ test('can add option', async ({umbracoApi, umbracoUi}) => {
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'items', [optionName])).toBeTruthy();
});
test('can remove option', async ({umbracoApi, umbracoUi}) => {
// Arrange
const removedOptionName = 'Removed Option';
const removedOptionValues = [
{
"alias": "items",
"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);
const customDataType = 'Custom Radiobox';
await umbracoApi.dataType.createRadioboxDataType(customDataType, [removedOptionName]);
await umbracoUi.dataType.goToDataType(customDataType);
// Act
await umbracoUi.dataType.removeOptionByName(removedOptionName);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toEqual([]);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataType, 'items', [removedOptionName])).toBeFalsy();
// Clean
await umbracoApi.dataType.ensureNameNotExists(customDataType);
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.radioboxSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.radioboxSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'items')).toBeFalsy();
});

68
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/RichTextEditor.spec.ts
View File

@@ -1,12 +1,59 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Richtext editor';
const tipTapPropertyEditorName = 'Rich Text Editor [Tiptap] Property Editor UI';
const tipTapAlias = 'Umbraco.RichText';
const tipTapUiAlias = 'Umb.PropertyEditorUi.Tiptap';
const extensionsDefaultValue = [
"Umb.Tiptap.Embed",
"Umb.Tiptap.Link",
"Umb.Tiptap.Figure",
"Umb.Tiptap.Image",
"Umb.Tiptap.Subscript",
"Umb.Tiptap.Superscript",
"Umb.Tiptap.Table",
"Umb.Tiptap.Underline",
"Umb.Tiptap.TextAlign",
"Umb.Tiptap.MediaUpload"
];
const toolbarDefaultValue = [
[
[
"Umb.Tiptap.Toolbar.SourceEditor"
],
[
"Umb.Tiptap.Toolbar.Bold",
"Umb.Tiptap.Toolbar.Italic",
"Umb.Tiptap.Toolbar.Underline"
],
[
"Umb.Tiptap.Toolbar.TextAlignLeft",
"Umb.Tiptap.Toolbar.TextAlignCenter",
"Umb.Tiptap.Toolbar.TextAlignRight"
],
[
"Umb.Tiptap.Toolbar.BulletList",
"Umb.Tiptap.Toolbar.OrderedList"
],
[
"Umb.Tiptap.Toolbar.Blockquote",
"Umb.Tiptap.Toolbar.HorizontalRule"
],
[
"Umb.Tiptap.Toolbar.Link",
"Umb.Tiptap.Toolbar.Unlink"
],
[
"Umb.Tiptap.Toolbar.MediaPicker",
"Umb.Tiptap.Toolbar.EmbeddedMedia"
]
]
];
test('tiptap is the default property editor in rich text editor', async ({umbracoApi, umbracoUi}) => {
// Arrange
const dataTypeName = 'Richtext editor';
const tipTapPropertyEditorName = 'Rich Text Editor [Tiptap] Property Editor UI';
const tipTapAlias = 'Umbraco.RichText';
const tipTapUiAlias = 'Umb.PropertyEditorUi.Tiptap';
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
@@ -14,10 +61,17 @@ test('tiptap is the default property editor in rich text editor', async ({umbrac
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
//await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.tipTapSettings);
//await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.tipTapSettings);
await umbracoUi.dataType.doesPropertyEditorHaveName(tipTapPropertyEditorName);
await umbracoUi.dataType.doesPropertyEditorHaveSchemaAlias(tipTapAlias);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(tipTapUiAlias);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(tipTapAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(tipTapUiAlias);
const dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.editorAlias).toBe(tipTapAlias);
expect(dataTypeData.editorUiAlias).toBe(tipTapUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'maxImageSize', 500)).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'overlaySize', 'medium')).toBeTruthy();
expect(await umbracoApi.dataType.doesTiptapExtensionsItemsMatchCount(dataTypeName, extensionsDefaultValue.length)).toBeTruthy();
expect(await umbracoApi.dataType.doesTiptapExtensionsHaveItems(dataTypeName, extensionsDefaultValue)).toBeTruthy();
expect(await umbracoApi.dataType.doesTiptapToolbarHaveItems(dataTypeName, toolbarDefaultValue)).toBeTruthy();
});

50
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Tags.spec.ts
View File

@@ -1,53 +1,63 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Tags';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.Tags';
const editorUiAlias = 'Umb.PropertyEditorUi.Tags';
const customDataTypeName = 'Custom Tags';
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);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update define a tag group', async ({umbracoApi, umbracoUi}) => {
// Arrange
const tagGroup = 'testTagGroup';
const expectedDataTypeValues = {
"alias": "group",
"value": tagGroup
};
await umbracoApi.dataType.createDefaultTagsDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterDefineTagGroupValue(tagGroup);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'group', tagGroup)).toBeTruthy();
});
test('can select storage type', async ({umbracoApi, umbracoUi}) => {
// Arrange
const storageType = 'Csv';
const expectedDataTypeValues = {
"alias": "storageType",
"value": storageType
};
await umbracoApi.dataType.createDefaultTagsDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.selectStorageTypeOption(storageType);
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'storageType', storageType)).toBeTruthy();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.tagsSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.tagsSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'group', 'default', dataTypeDefaultData)).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'storageType', 'Json', dataTypeDefaultData)).toBeTruthy();
});

53
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textarea.spec.ts
View File

@@ -1,55 +1,64 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Textarea';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.TextArea';
const editorUiAlias = 'Umb.PropertyEditorUi.TextArea';
const customDataTypeName = 'Custom Textarea';
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);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update maximum allowed characters value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const maxCharsValue = 126;
const expectedDataTypeValues = {
"alias": "maxChars",
"value": maxCharsValue
};
await umbracoApi.dataType.createTextareaDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMaximumAllowedCharactersValue(maxCharsValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'maxChars', maxCharsValue)).toBeTruthy();
});
test('can update number of rows value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const numberOfRowsValue = 9;
const expectedDataTypeValues = {
"alias": "rows",
"value": numberOfRowsValue
};
await umbracoApi.dataType.createTextareaDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterNumberOfRowsValue(numberOfRowsValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'rows', numberOfRowsValue)).toBeTruthy();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.textareaSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.textareaSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'maxChars')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'rows')).toBeFalsy();
});

41
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Textstring.spec.ts
View File

@@ -1,36 +1,49 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'Textstring';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.TextBox';
const editorUiAlias = 'Umb.PropertyEditorUi.TextBox';
const customDataTypeName = 'Custom Textstring';
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);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update maximum allowed characters value', async ({umbracoApi, umbracoUi}) => {
// Arrange
const maxCharsValue = 126;
const expectedDataTypeValues = {
"alias": "maxChars",
"value": maxCharsValue
};
await umbracoApi.dataType.createTextstringDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterMaximumAllowedCharactersValue(maxCharsValue.toString());
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'maxChars', maxCharsValue)).toBeTruthy();
});
// Remove fixme when the front-end is ready. The "Input type" should be removed.
test.fixme('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.textstringSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.textstringSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'maxChars')).toBeFalsy();
});

100
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/TinyMCE.spec.ts
View File

@@ -1,4 +1,4 @@
import {NotificationConstantHelper, test} from "@umbraco/playwright-testhelpers";
import {ConstantHelper, NotificationConstantHelper, test} from "@umbraco/playwright-testhelpers";
import {expect} from "@playwright/test";
const tinyMCEName = 'TestTinyMCE';
@@ -19,6 +19,22 @@ test('can create a rich text editor with tinyMCE', {tag: '@smoke'}, async ({umbr
const tinyMCEFilterKeyword = 'Rich Text Editor';
const tinyMCEAlias = 'Umbraco.RichText';
const tinyMCEUiAlias = 'Umb.PropertyEditorUi.TinyMCE';
const toolbarValue = [
"styles",
"bold",
"italic",
"alignleft",
"aligncenter",
"alignright",
"bullist",
"numlist",
"outdent",
"indent",
"sourcecode",
"link",
"umbmediapicker",
"umbembeddialog"
];
// Act
await umbracoUi.dataType.clickActionsMenuAtRoot();
@@ -32,9 +48,17 @@ test('can create a rich text editor with tinyMCE', {tag: '@smoke'}, async ({umbr
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.created);
expect(await umbracoApi.dataType.doesNameExist(tinyMCEName)).toBeTruthy();
// Verify the default configuration
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.tinyMCESettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.tinyMCESettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(tinyMCEAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(tinyMCEUiAlias);
const dataTypeData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(dataTypeData.editorAlias).toBe(tinyMCEAlias);
expect(dataTypeData.editorUiAlias).toBe(tinyMCEUiAlias);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'maxImageSize', 500)).toBeTruthy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'mode', 'Classic')).toBeTruthy();
expect(await umbracoApi.dataType.doesTinyMCEToolbarHaveItems(tinyMCEName, toolbarValue)).toBeTruthy();
});
test('can rename a rich text editor with tinyMCE', async ({umbracoApi, umbracoUi}) => {
@@ -89,12 +113,7 @@ test('can enable toolbar options', async ({umbracoApi, umbracoUi}) => {
test('can add stylesheet', async ({umbracoApi, umbracoUi}) => {
// Arrange
const stylesheetName = 'StylesheetForDataType.css';
await umbracoApi.stylesheet.ensureNameNotExists(stylesheetName);
const stylesheetPath = await umbracoApi.stylesheet.createDefaultStylesheet(stylesheetName);
const expectedTinyMCEValues = {
"alias": "stylesheets",
"value": [stylesheetPath]
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -104,8 +123,7 @@ test('can add stylesheet', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'stylesheets', [stylesheetPath])).toBeTruthy();
// Clean
await umbracoApi.stylesheet.ensureNameNotExists(stylesheetName);
@@ -115,13 +133,6 @@ test('can add dimensions', async ({umbracoApi, umbracoUi}) => {
// Arrange
const width = 100;
const height = 10;
const expectedTinyMCEValues = {
"alias": "dimensions",
"value": {
"width": width,
"height": height
}
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -131,17 +142,12 @@ test('can add dimensions', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesRTEHaveDimensions(tinyMCEName, width, height)).toBeTruthy();
});
test('can update maximum size for inserted images', async ({umbracoApi, umbracoUi}) => {
// Arrange
const maximumSize = 300;
const expectedTinyMCEValues = {
"alias": "maxImageSize",
"value": maximumSize
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -151,17 +157,12 @@ test('can update maximum size for inserted images', async ({umbracoApi, umbracoU
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'maxImageSize', maximumSize)).toBeTruthy();
});
test('can enable inline editing mode', async ({umbracoApi, umbracoUi}) => {
// Arrange
const mode = 'Inline';
const expectedTinyMCEValues = {
"alias": "mode",
"value": mode
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -171,23 +172,14 @@ test('can enable inline editing mode', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'mode', mode)).toBeTruthy();
});
test('can add an available block', async ({umbracoApi, umbracoUi}) => {
// Arrange
const elementTypeName = 'TestElementType';
await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
const elementTypeId = await umbracoApi.documentType.createEmptyElementType(elementTypeName);
const expectedTinyMCEValues = {
alias: "blocks",
value: [
{
contentElementTypeKey: elementTypeId,
}
]
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -197,8 +189,7 @@ test('can add an available block', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesRTEContainBlocks(tinyMCEName, [elementTypeId])).toBeTruthy();
// Clean
await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
@@ -207,10 +198,6 @@ test('can add an available block', async ({umbracoApi, umbracoUi}) => {
test('can select overlay size', async ({umbracoApi, umbracoUi}) => {
// Arrange
const overlaySizeValue = 'large';
const expectedTinyMCEValues = {
"alias": "overlaySize",
"value": overlaySizeValue
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -220,16 +207,11 @@ test('can select overlay size', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'overlaySize', overlaySizeValue)).toBeTruthy();
});
test('can enable hide label', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedTinyMCEValues = {
"alias": "hideLabel",
"value": true
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -239,19 +221,13 @@ test('can enable hide label', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'hideLabel', true)).toBeTruthy();
});
test('can add image upload folder', async ({umbracoApi, umbracoUi}) => {
// Arrange
const mediaFolderName = 'TestMediaFolder';
await umbracoApi.media.ensureNameNotExists(mediaFolderName);
const mediaFolderId = await umbracoApi.media.createDefaultMediaFolder(mediaFolderName);
const expectedTinyMCEValues = {
"alias": "mediaParentId",
"value": mediaFolderId
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -261,8 +237,7 @@ test('can add image upload folder', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'mediaParentId', mediaFolderId)).toBeTruthy();
// Clean
await umbracoApi.media.ensureNameNotExists(mediaFolderName);
@@ -270,10 +245,6 @@ test('can add image upload folder', async ({umbracoApi, umbracoUi}) => {
test('can enable ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedTinyMCEValues = {
"alias": "ignoreUserStartNodes",
"value": true
};
await umbracoApi.dataType.createDefaultTinyMCEDataType(tinyMCEName);
await umbracoUi.dataType.goToDataType(tinyMCEName);
@@ -283,6 +254,5 @@ test('can enable ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tinyMCEData = await umbracoApi.dataType.getByName(tinyMCEName);
expect(tinyMCEData.values).toContainEqual(expectedTinyMCEValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tinyMCEName, 'ignoreUserStartNodes', true)).toBeTruthy();
});

51
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Tiptap.spec.ts
View File

@@ -71,13 +71,6 @@ test('can add dimensions', async ({umbracoApi, umbracoUi}) => {
// Arrange
const width = 100;
const height = 10;
const expectedTiptapValues = {
"alias": "dimensions",
"value": {
"width": width,
"height": height
}
};
await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
await umbracoUi.dataType.goToDataType(tipTapName);
@@ -87,17 +80,12 @@ test('can add dimensions', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tiptapData = await umbracoApi.dataType.getByName(tipTapName);
expect(tiptapData.values).toContainEqual(expectedTiptapValues);
expect(await umbracoApi.dataType.doesRTEHaveDimensions(tipTapName, width, height)).toBeTruthy();
});
test('can update maximum size for inserted images', async ({umbracoApi, umbracoUi}) => {
// Arrange
const maximumSize = 300;
const expectedTiptapValues = {
"alias": "maxImageSize",
"value": maximumSize
};
await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
await umbracoUi.dataType.goToDataType(tipTapName);
@@ -107,17 +95,12 @@ test('can update maximum size for inserted images', async ({umbracoApi, umbracoU
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tiptapData = await umbracoApi.dataType.getByName(tipTapName);
expect(tiptapData.values).toContainEqual(expectedTiptapValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tipTapName, 'maxImageSize', maximumSize)).toBeTruthy();
});
test('can select overlay size', async ({umbracoApi, umbracoUi}) => {
// Arrange
const overlaySizeValue = 'large';
const expectedTiptapValues = {
"alias": "overlaySize",
"value": overlaySizeValue
};
await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
await umbracoUi.dataType.goToDataType(tipTapName);
@@ -127,23 +110,13 @@ test('can select overlay size', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tiptapData = await umbracoApi.dataType.getByName(tipTapName);
expect(tiptapData.values).toContainEqual(expectedTiptapValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tipTapName, 'overlaySize', overlaySizeValue)).toBeTruthy();
});
test('can add an available block', async ({umbracoApi, umbracoUi}) => {
// Arrange
const elementTypeName = 'TestElementType';
await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
const elementTypeId = await umbracoApi.documentType.createEmptyElementType(elementTypeName);
const expectedTiptapValues = {
alias: "blocks",
value: [
{
contentElementTypeKey: elementTypeId,
}
]
};
await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
await umbracoUi.dataType.goToDataType(tipTapName);
@@ -153,8 +126,7 @@ test('can add an available block', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tiptapData = await umbracoApi.dataType.getByName(tipTapName);
expect(tiptapData.values).toContainEqual(expectedTiptapValues);
expect(await umbracoApi.dataType.doesRTEContainBlocks(tipTapName, [elementTypeId])).toBeTruthy();
// Clean
await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
@@ -163,12 +135,7 @@ test('can add an available block', async ({umbracoApi, umbracoUi}) => {
test('can add image upload folder', async ({umbracoApi, umbracoUi}) => {
// Arrange
const mediaFolderName = 'TestMediaFolder';
await umbracoApi.media.ensureNameNotExists(mediaFolderName);
const mediaFolderId = await umbracoApi.media.createDefaultMediaFolder(mediaFolderName);
const expectedTiptapValues = {
"alias": "mediaParentId",
"value": mediaFolderId
};
await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
await umbracoUi.dataType.goToDataType(tipTapName);
@@ -178,8 +145,7 @@ test('can add image upload folder', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tiptapData = await umbracoApi.dataType.getByName(tipTapName);
expect(tiptapData.values).toContainEqual(expectedTiptapValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tipTapName, 'mediaParentId', mediaFolderId)).toBeTruthy();
// Clean
await umbracoApi.media.ensureNameNotExists(mediaFolderName);
@@ -187,10 +153,6 @@ test('can add image upload folder', async ({umbracoApi, umbracoUi}) => {
test('can enable ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedTiptapValues = {
"alias": "ignoreUserStartNodes",
"value": true
};
await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
await umbracoUi.dataType.goToDataType(tipTapName);
@@ -200,8 +162,7 @@ test('can enable ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const tipTapData = await umbracoApi.dataType.getByName(tipTapName);
expect(tipTapData.values).toContainEqual(expectedTiptapValues);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(tipTapName, 'ignoreUserStartNodes', true)).toBeTruthy();
});
test('can delete toolbar group', async ({umbracoApi, umbracoUi}) => {

75
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/TrueFalse.spec.ts
View File

@@ -1,87 +1,94 @@
import {test} from '@umbraco/playwright-testhelpers';
import {ConstantHelper, NotificationConstantHelper, test} from '@umbraco/playwright-testhelpers';
import {expect} from "@playwright/test";
const dataTypeName = 'True/false';
let dataTypeDefaultData = null;
let dataTypeData = null;
const editorAlias = 'Umbraco.TrueFalse';
const editorUiAlias = 'Umb.PropertyEditorUi.Toggle';
const customDataTypeName = 'Custom TrueFalse';
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);
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test.afterEach(async ({umbracoApi}) => {
if (dataTypeDefaultData !== null) {
await umbracoApi.dataType.update(dataTypeDefaultData.id, dataTypeDefaultData);
}
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can update preset value state', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "default",
"value": true
};
await umbracoApi.dataType.createDefaultTrueFalseDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickPresetValueToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'default', true)).toBeTruthy();
});
test('can update show toggle labels', async ({umbracoApi, umbracoUi}) => {
// Arrange
const expectedDataTypeValues = {
"alias": "showLabels",
"value": true
};
await umbracoApi.dataType.createDefaultTrueFalseDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickShowToggleLabelsToggle();
await umbracoUi.dataType.clickSaveButton();
// Assert
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'showLabels', true)).toBeTruthy();
});
test('can update label on', async ({umbracoApi, umbracoUi}) => {
// Arrange
const labelOnValue = 'Test Label On';
const expectedDataTypeValues = {
"alias": "labelOn",
"value": labelOnValue
};
await umbracoApi.dataType.createDefaultTrueFalseDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterLabelOnValue(labelOnValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'labelOn', labelOnValue)).toBeTruthy();
});
test('can update label off', async ({umbracoApi, umbracoUi}) => {
// Arrange
const labelOffValue = 'Test Label Off';
const expectedDataTypeValues = {
"alias": "labelOff",
"value": labelOffValue
};
await umbracoApi.dataType.createDefaultTrueFalseDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.enterLabelOffValue(labelOffValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeData.values).toContainEqual(expectedDataTypeValues);
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'labelOff', labelOffValue)).toBeTruthy();
});
test('the default configuration is correct', async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(dataTypeName);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.trueFalseSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.trueFalseSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
const dataTypeDefaultData = await umbracoApi.dataType.getByName(dataTypeName);
expect(dataTypeDefaultData.editorAlias).toBe(editorAlias);
expect(dataTypeDefaultData.editorUiAlias).toBe(editorUiAlias);
expect(dataTypeDefaultData.values).toEqual([]);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'default')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'showLabels')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'labelOn')).toBeFalsy();
expect(await umbracoApi.dataType.doesDataTypeHaveValue(dataTypeName, 'labelOff')).toBeFalsy();
});

76
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Upload.spec.ts
View File

@@ -1,76 +0,0 @@
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": [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.waitForTimeout(500);
await umbracoUi.dataType.clickAddAcceptedFileExtensionsButton();
await umbracoUi.dataType.enterAcceptedFileExtensions(fileExtensionValue);
await umbracoUi.waitForTimeout(500);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.isSuccessNotificationVisible();
await umbracoUi.waitForTimeout(500);
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": [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
await umbracoUi.dataType.isSuccessNotificationVisible();
dataTypeData = await umbracoApi.dataType.getByName(uploadType);
expect(dataTypeData.values).toEqual([]);
});
});
}

73
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/UploadField.spec.ts Normal file
View File

@@ -0,0 +1,73 @@
import { ConstantHelper, NotificationConstantHelper, test } from "@umbraco/playwright-testhelpers";
import { expect } from "@playwright/test";
const uploadTypes = [
{type: 'Upload Article', fileExtensions: ['pdf', 'docx', 'doc']},
{type: 'Upload Audio', fileExtensions: ['mp3', 'weba', 'oga', 'opus']},
{type: 'Upload File', fileExtensions: []},
{type: 'Upload Vector Graphics', fileExtensions: ['svg']},
{type: 'Upload Video', fileExtensions: ['mp4', 'webm', 'ogv']}
];
const customDataTypeName = 'Custom Upload Field';
const editorAlias = 'Umbraco.UploadField';
const editorUiAlias = 'Umb.PropertyEditorUi.UploadField';
test.beforeEach(async ({ umbracoUi }) => {
await umbracoUi.goToBackOffice();
await umbracoUi.dataType.goToSettingsTreeItem('Data Types');
});
test.afterEach(async ({umbracoApi}) => {
await umbracoApi.dataType.ensureNameNotExists(customDataTypeName);
});
test('can add accepted file extension', async ({ umbracoApi, umbracoUi }) => {
// Arrange
const fileExtensionValue = 'zip';
await umbracoApi.dataType.createUploadDataType(customDataTypeName);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.clickAddAcceptedFileExtensionsButton();
await umbracoUi.dataType.enterAcceptedFileExtensions(fileExtensionValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
expect(await umbracoApi.dataType.doesDataTypeHaveValue(customDataTypeName, 'fileExtensions', [fileExtensionValue])).toBeTruthy();
});
test('can remove accepted file extension', async ({ umbracoApi, umbracoUi }) => {
// Arrange
const removedFileExtensionValue = "bat";
await umbracoApi.dataType.createUploadDataType(customDataTypeName, [removedFileExtensionValue]);
await umbracoUi.dataType.goToDataType(customDataTypeName);
// Act
await umbracoUi.dataType.removeAcceptedFileExtensionsByValue(removedFileExtensionValue);
await umbracoUi.dataType.clickSaveButton();
// Assert
await umbracoUi.dataType.doesSuccessNotificationHaveText(NotificationConstantHelper.success.saved);
const customDataTypeData = await umbracoApi.dataType.getByName(customDataTypeName);
expect(customDataTypeData.values).toEqual([]);
});
for (const uploadType of uploadTypes) {
test(`the default configuration of ${uploadType.type} is correct`, async ({umbracoApi, umbracoUi}) => {
// Act
await umbracoUi.dataType.goToDataType(uploadType.type);
// Assert
await umbracoUi.dataType.doesSettingHaveValue(ConstantHelper.uploadSettings);
await umbracoUi.dataType.doesSettingItemsHaveCount(ConstantHelper.uploadSettings);
await umbracoUi.dataType.doesPropertyEditorHaveAlias(editorAlias);
await umbracoUi.dataType.doesPropertyEditorHaveUiAlias(editorUiAlias);
if (uploadType.fileExtensions.length > 0) {
expect(await umbracoApi.dataType.doesDataTypeHaveValue(uploadType.type, 'fileExtensions', uploadType.fileExtensions)).toBeTruthy();
} else {
const dataTypeDefaultData = await umbracoApi.dataType.getByName(uploadType.type);
expect(dataTypeDefaultData.values).toEqual([]);
}
});
}

2
tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/RenderingContent/RenderingContentWithApprovedColor.spec.ts
View File

@@ -9,7 +9,7 @@ const colorValue = {label: "Test Label", value: "038c33"};
let dataTypeId = null;
test.beforeEach(async ({umbracoApi}) => {
dataTypeId = await umbracoApi.dataType.createApprovedColorDataTypeWithOneItem(customDataTypeName, colorValue.label, colorValue.value);
dataTypeId = await umbracoApi.dataType.createDefaultApprovedColorDataTypeWithOneItem(customDataTypeName, colorValue.label, colorValue.value);
});
test.afterEach(async ({umbracoApi}) => {