@umbraco/playwright-testhelpers 2.0.0-beta.64 → 2.0.0-beta.66

package/dist/lib/helpers/DataTypeApiHelper.js

@@ -184,6 +184,489 @@ class DataTypeApiHelper {
             .build();
         return await this.save(dataType);
     }
+    async createCheckboxListDataType(name, options) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.CheckboxListDataTypeBuilder()
+            .withName(name)
+            .withItems(options)
+            .build();
+        return await this.save(dataType);
+    }
+    async createContentPickerDataTypeWithStartNode(name, startNodeId) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ContentPickerDataTypeBuilder()
+            .withName(name)
+            .withStartNodeId(startNodeId)
+            .build();
+        return await this.save(dataType);
+    }
+    async createContentPickerDataTypeWithShowOpenButton(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ContentPickerDataTypeBuilder()
+            .withName(name)
+            .withShowOpenButton(true)
+            .build();
+        return await this.save(dataType);
+    }
+    async createContentPickerDataTypeWithIgnoreUserStartNodes(name, startNodeId) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ContentPickerDataTypeBuilder()
+            .withName(name)
+            .withStartNodeId(startNodeId)
+            .withIgnoreUserStartNodes(true)
+            .build();
+        return await this.save(dataType);
+    }
+    async createDatePickerDataType(name, dateFormat) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.DatePickerDataTypeBuilder()
+            .withName(name)
+            .withFormat(dateFormat)
+            .build();
+        return await this.save(dataType);
+    }
+    async createDropdownDataType(name, isMultiple, options) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.DropdownDataTypeBuilder()
+            .withName(name)
+            .withMultiple(isMultiple)
+            .withItems(options)
+            .build();
+        return await this.save(dataType);
+    }
+    // BlockListEditor
+    async createEmptyBlockListDataType(name) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithABlock(name, contentElementTypeId) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithContentAndSettingsElementType(name, contentElementTypeId, settingsElementTypeId) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withSettingsElementTypeKey(settingsElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithMinAndMaxAmount(name, minAmount = 0, maxAmount = 0) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withMinValue(minAmount)
+            .withMaxValue(maxAmount)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithSingleBlockMode(name, enabled) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withSingleBlockMode(enabled)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithLiveEditingMode(name, enabled) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withLiveEditing(enabled)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithInlineEditingMode(name, enabled) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withInlineEditingAsDefault(enabled)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithPropertyEditorWidth(name, width) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withMaxPropertyWidth(width)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListWithBlockWithEditorAppearance(name, elementTypeId, label = '', overlaySize = 'small') {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(elementTypeId)
+            .withLabel(label)
+            .withEditorSize(overlaySize)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListWithBlockWithCatalogueAppearance(name, elementTypeId, backgroundColor = '', iconColor = '', customStylesheet = '') {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(elementTypeId)
+            .withBackgroundColor(backgroundColor)
+            .withIconColor(iconColor)
+            .withStylesheet(customStylesheet)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListWithBlockWithHideContentEditor(name, elementTypeId, hideContentEditor) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(elementTypeId)
+            .withHideContentEditor(hideContentEditor)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async isSingleBlockModeEnabledForBlockList(blockListName, enabled) {
+        const blockList = await this.getByName(blockListName);
+        const singleBlockModeValue = blockList.values.find(value => value.alias === 'useSingleBlockMode');
+        return singleBlockModeValue?.value === enabled;
+    }
+    async isInlineEditingModeEnabledForBlockList(blockListName, enabled) {
+        const blockList = await this.getByName(blockListName);
+        const inlineEditingModeValue = blockList.values.find(value => value.alias === 'useInlineEditingAsDefault');
+        return inlineEditingModeValue?.value === enabled;
+    }
+    // Block Grid
+    async createEmptyBlockGrid(blockGridName) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithABlock(blockGridName, contentElementTypeId) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithABlockInAGroup(blockGridName, contentElementTypeId, groupName) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlockGroup()
+            .withName(groupName)
+            .done()
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withGroupName(groupName)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithMinAndMaxAmount(blockGridName, minAmount = 0, maxAmount = 0) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withMinValue(minAmount)
+            .withMaxValue(maxAmount)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithLiveEditingMode(blockGridName, enabled) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withLiveEditing(enabled)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithPropertyEditorWidth(blockGridName, width) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withMaxPropertyWidth(width)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithCreateButtonLabel(blockGridName, label = '') {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withCreateLabel(label)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithGridColumns(blockGridName, columns = 12) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withGridColumns(columns)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithLayoutStylesheet(blockGridName, stylesheet = ['']) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withLayoutStylesheet(stylesheet)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithAnAreaInABlock(blockGridName, contentElementTypeId, areaAlias = 'area', createButtonLabel = '', columnSpan = 6, rowSpan = 1, minAllowed = 0, maxAllowed = 2) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .addArea()
+            .withAlias(areaAlias)
+            .withCreateLabel(createButtonLabel)
+            .withColumnSpan(columnSpan)
+            .withRowSpan(rowSpan)
+            .withMinAllowed(minAllowed)
+            .withMaxAllowed(maxAllowed)
+            .done()
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithAdvancedSettingsInBlock(blockGridName, contentElementTypeId, customViewPath = '', customStylesheetPath = '', overlaySize = 'small', inlineEditing = false, hideContentEditor = false) {
+        await this.ensureNameNotExists(blockGridName);
+        const encodedViewPath = await this.api.stylesheet.encodeStylesheetPath(customViewPath);
+        const encodedStylesheetPath = await this.api.stylesheet.encodeStylesheetPath(customStylesheetPath);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withView(encodedViewPath)
+            .withStylesheet(encodedStylesheetPath)
+            .withEditorSize(overlaySize)
+            .withInlineEditing(inlineEditing)
+            .withHideContentEditor(hideContentEditor)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithCatalogueAppearanceInBlock(blockGridName, contentElementTypeId, backgroundColor = '', iconColor = '', thumbnail = '') {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withBackgroundColor(backgroundColor)
+            .withIconColor(iconColor)
+            .withThumbnail(thumbnail)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithContentAndSettingsElementType(blockGridName, contentElementTypeId, settingsElementTypeId) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withSettingsElementTypeKey(settingsElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithLabel(blockGridName, contentElementTypeId, label) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withLabel(label)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithPermissions(blockGridName, contentElementTypeId, toAllowInRoot = false, toAllowInAreas = false) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withAllowAtRoot(toAllowInRoot)
+            .withAllowInAreas(toAllowInAreas)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithSizeOptions(blockGridName, contentElementTypeId, columnSpans = 0, minRowSpan = 0, maxRowSpan = 12) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .addColumnSpanOptions(columnSpans)
+            .withMinRowSpan(minRowSpan)
+            .withMaxRowSpan(maxRowSpan)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async doesBlockEditorContainBlocksWithContentTypeIds(blockEditorName, elementTypeIds) {
+        if (!elementTypeIds || elementTypeIds.length === 0) {
+            return false;
+        }
+        const blockEditor = await this.getByName(blockEditorName);
+        const blocksValue = blockEditor.values.find(value => value.alias === 'blocks');
+        if (!blocksValue || blocksValue.value.length === 0) {
+            return false;
+        }
+        const contentElementTypeKeys = blocksValue.value.map(block => block.contentElementTypeKey);
+        return elementTypeIds.every(id => contentElementTypeKeys.includes(id));
+    }
+    async doesBlockEditorContainBlocksWithSettingsTypeIds(blockEditorName, elementTypeIds) {
+        if (!elementTypeIds || elementTypeIds.length === 0) {
+            return false;
+        }
+        const blockEditor = await this.getByName(blockEditorName);
+        const blocksValue = blockEditor.values.find(value => value.alias === 'blocks');
+        if (!blocksValue || blocksValue.value.length === 0) {
+            return false;
+        }
+        const settingsElementTypeKeys = blocksValue.value.map(block => block.settingsElementTypeKey);
+        return elementTypeIds.every(id => settingsElementTypeKeys.includes(id));
+    }
+    async isLiveEditingModeEnabledForBlockEditor(blockEditorName, enabled) {
+        const blockEditor = await this.getByName(blockEditorName);
+        const liveEditingModeValue = blockEditor.values.find(value => value.alias === 'useLiveEditing');
+        return liveEditingModeValue?.value === enabled;
+    }
+    async doesMaxPropertyContainWidthForBlockEditor(blockEditorName, width) {
+        const blockEditor = await this.getByName(blockEditorName);
+        const maxPropertyWidthValue = blockEditor.values.find(value => value.alias === 'maxPropertyWidth');
+        return maxPropertyWidthValue?.value === width;
+    }
+    async doesBlockEditorBlockContainLabel(blockName, elementTypeKey, label) {
+        const block = await this.getBlockWithContentElementTypeId(blockName, elementTypeKey);
+        return block.label === label;
+    }
+    async doesBlockGridGroupContainCorrectBlocks(blockGridName, groupName, elementTypeIds) {
+        if (!elementTypeIds || elementTypeIds.length === 0) {
+            return false;
+        }
+        const blockEditor = await this.getByName(blockGridName);
+        // We need to get the GroupKey, so we can use it to find the blocks that use the Key.
+        const blockGroupsValue = blockEditor.values.find(value => value.alias === 'blockGroups');
+        if (!blockGroupsValue || blockGroupsValue.value.length === 0) {
+            return false;
+        }
+        const blockGroupKey = blockGroupsValue.value.find(blockGroup => blockGroup.name === groupName).key;
+        const blocksValue = blockEditor.values.find(value => value.alias === 'blocks');
+        if (!blocksValue || blocksValue.value.length === 0) {
+            return false;
+        }
+        const blocksWithGroupKey = blocksValue.value.filter(block => block.groupKey === blockGroupKey);
+        return elementTypeIds.every(id => blocksWithGroupKey.some(block => block.contentElementTypeKey === id));
+    }
+    async doesBlockGridContainCreateButtonLabel(blockGridName, label) {
+        const blockEditor = await this.getByName(blockGridName);
+        const createLabelValue = blockEditor.values.find(value => value.alias === 'createLabel');
+        return createLabelValue?.value === label;
+    }
+    async doesBlockGridContainGridColumns(blockGridName, columns) {
+        const blockEditor = await this.getByName(blockGridName);
+        const gridColumnsValue = blockEditor.values.find(value => value.alias === 'gridColumns');
+        return gridColumnsValue?.value === columns;
+    }
+    async doesBlockEditorBlockHaveAllowInRootEnabled(blockGridName, elementTypeKey) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.allowAtRoot;
+    }
+    async doesBlockEditorBlockHaveAllowInAreasEnabled(blockGridName, elementTypeKey) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.allowInAreas;
+    }
+    async doesBlockEditorBlockContainColumnSpanOptions(blockGridName, elementTypeKey, expectedColumnSpans) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        // If the block does not have any columnSpanOptions, and we are not expecting any, return true
+        if (block.columnSpanOptions.length === 0 && expectedColumnSpans.length === 0) {
+            return true;
+        }
+        const columnSpans = block.columnSpanOptions.map(option => option.columnSpan);
+        return expectedColumnSpans.every(span => columnSpans.includes(span)) && columnSpans.every(span => expectedColumnSpans.includes(span));
+    }
+    async doesBlockEditorBlockContainRowSpanOptions(blockGridName, elementTypeKey, minRowSpan, maxRowSpan) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.rowMinSpan === minRowSpan && block.rowMaxSpan === maxRowSpan;
+    }
+    async doesBlockEditorBlockContainAreaGridColumns(blockGridName, elementTypeKey, areaGridColumns) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areaGridColumns === areaGridColumns;
+    }
+    async doesBlockEditorBlockContainAreaWithAlias(blockGridName, elementTypeKey, areaAlias = 'area') {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainAreaWithCreateButtonLabel(blockGridName, elementTypeKey, areaAlias = 'area', createButtonLabel) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.createLabel === createButtonLabel && area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainAreaWithMinAllowed(blockGridName, elementTypeKey, areaAlias = 'area', minAllowed) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.minAllowed === minAllowed && area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainAreaWithMaxAllowed(blockGridName, elementTypeKey, areaAlias = 'area', maxAllowed) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.maxAllowed === maxAllowed && area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainStylesheet(blockGridName, elementTypeKey, stylesheetPath) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        const encodedSecondStylesheetPath = await this.api.stylesheet.encodeStylesheetPath(stylesheetPath);
+        return block.stylesheet[0] === encodedSecondStylesheetPath;
+    }
+    async doesBlockEditorBlockContainOverlaySize(blockGridName, elementTypeKey, overlaySize) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.editorSize === overlaySize;
+    }
+    async doesBlockEditorBlockContainInlineEditing(blockGridName, elementTypeKey, inlineEditing) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.inlineEditing === inlineEditing;
+    }
+    async doesBlockEditorBlockContainHideContentEditor(blockGridName, elementTypeKey, hideContentEditor) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.hideContentEditor === hideContentEditor;
+    }
+    async doesBlockEditorBlockContainBackgroundColor(blockGridName, elementTypeKey, backgroundColor) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.backgroundColor === backgroundColor;
+    }
+    async doesBlockEditorBlockContainIconColor(blockGridName, elementTypeKey, iconColor) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.iconColor === iconColor;
+    }
+    async doesBlockEditorBlockContainThumbnail(blockGridName, elementTypeKey, thumbnail) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.thumbnail === thumbnail;
+    }
+    async getBlockWithContentElementTypeId(blockGridName, contentElementTypeKey) {
+        const blockEditor = await this.getByName(blockGridName);
+        const blocks = blockEditor.values.find(value => value.alias === 'blocks');
+        return blocks.value.find(block => block.contentElementTypeKey === contentElementTypeKey);
+    }
 }
 exports.DataTypeApiHelper = DataTypeApiHelper;
 //# sourceMappingURL=DataTypeApiHelper.js.map