E2E: QA add acceptance tests published querying parity

tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ContentRenderUiHelper.ts

@@ -16,8 +16,10 @@ export class ContentRenderUiHelper extends UiBaseLocators {
     await this.page.goto(umbracoConfig.environment.baseUrl + contentURL);
   }
 
-  async doesContentRenderValueContainText(text: string, isEqual: boolean = false) {
-    if (isEqual) {
+  async doesContentRenderValueContainText(text: string, isEqual: boolean = false, isVisible: boolean = true) {
+    if (!isVisible) {
+      await expect(this.contentRenderValue).not.toContainText(text);
+    } else if (isEqual) {
       await this.hasText(this.contentRenderValue, text);
     } else {
       await this.containsText(this.contentRenderValue, text);

tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DocumentApiHelper.ts

@@ -1,4 +1,4 @@
 import {expect} from "@playwright/test";
 import {AliasHelper} from "./AliasHelper";
 import {ApiHelpers} from "./ApiHelpers";
 import {DocumentBuilder, DocumentDomainBuilder} from "../builders";
@@ -161,13 +161,34 @@
     return response.status();
   }
 
+  async publishWithCultures(id: string, cultures: string[]) {
+    const publishSchedulesData = {publishSchedules: cultures.map(culture => ({culture}))};
+    return await this.publish(id, publishSchedulesData);
+  }
+
+  async unpublish(id: string, cultures: string[] | null = null) {
+    if (id == null) {
+      return;
+    }
+    const response = await this.api.put(this.api.baseUrl + '/umbraco/management/api/v1/document/' + id + '/unpublish', {cultures});
+    return response.status();
+  }
+
   async getDocumentUrl(id: string) {
     const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/document/urls?id=' + id);
     const urls = await response.json();
 
     return urls[0].urlInfos[0].url;
   }
 
+  async getDocumentUrlByCulture(id: string, culture: string) {
+    const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/document/urls?id=' + id);
+    const urls = await response.json();
+    const urlInfo = urls[0].urlInfos.find(info => info.culture === culture);
+
+    return urlInfo ? urlInfo.url : null;
+  }
+
   async moveToRecycleBin(id: string) {
     if (id == null) {
       return;
@@ -1509,6 +1530,22 @@
     return await this.publish(id, publishScheduleData);
   }
 
+  async createVariantDocumentWithParent(documentTypeId: string, templateId: string, name: string, cultures: string[], parentId?: string) {
+    const documentBuilder = new DocumentBuilder()
+      .withDocumentTypeId(documentTypeId)
+      .withTemplateId(templateId);
+
+    if (parentId) {
+      documentBuilder.withParentId(parentId);
+    }
+
+    for (const culture of cultures) {
+      documentBuilder.addVariant().withName(name).withCulture(culture).done();
+    }
+
+    return await this.create(documentBuilder.build());
+  }
+
   async createDocumentWithTextContentAndParent(documentName: string, documentTypeId: string, textContent: string, dataTypeName: string, parentId: string) {
     await this.ensureNameNotExists(documentName);
 

tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DocumentTypeApiHelper.ts

@@ -1,4 +1,4 @@
 import {ApiHelpers} from "./ApiHelpers";
 import {DocumentTypeBuilder} from "../builders";
 import {AliasHelper} from "./AliasHelper";
 
@@ -434,6 +434,29 @@
   }
 
 
+  async createVariantDocumentTypeWithTemplateAndAllowedChildNode(documentTypeName: string, templateId: string, isAllowedAsRoot: boolean = false, allowedChildNodeId?: string) {
+    await this.ensureNameNotExists(documentTypeName);
+
+    const documentTypeBuilder = new DocumentTypeBuilder()
+      .withName(documentTypeName)
+      .withAlias(AliasHelper.toAlias(documentTypeName))
+      .withAllowedAsRoot(isAllowedAsRoot)
+      .withVariesByCulture(true)
+      .addAllowedTemplateId()
+        .withId(templateId)
+        .done()
+      .withDefaultTemplateId(templateId);
+
+    if (allowedChildNodeId !== undefined) {
+      documentTypeBuilder
+        .addAllowedDocumentType()
+          .withId(allowedChildNodeId)
+          .done();
+    }
+
+    return await this.create(documentTypeBuilder.build());
+  }
+
   async createDocumentTypeWithAllowedTemplate(documentTypeName: string, allowedTemplateId: string, isAllowedAsRoot:boolean = false) {
     await this.ensureNameNotExists(documentTypeName);
 

tests/Umbraco.Tests.AcceptanceTest/package.json

@@ -23,7 +23,8 @@
     "testSqlite": "npm run build && npx playwright test DefaultConfig --grep-invert \"Users\"",
     "all": "npm run build && npx playwright test",
     "createTest": "node createTest.js",
-    "smokeTest": "npm run build && npx playwright test DefaultConfig --grep \"@smoke\"",
+    "smokeTest": "npm run build && npx playwright test RenderingContentWIthCulturePublishStatus",
+    "smokeTester": "npm run build && npx playwright test DefaultConfig --grep \"@smoke\"",
     "smokeTestSqlite": "npm run build && npx playwright test DefaultConfig --grep \"@smoke\" --grep-invert \"Users\"",
     "releaseTest": "npm run build && npx playwright test DefaultConfig --grep \"@release\"",
     "testWindows": "npm run build && npx playwright test DefaultConfig --grep-invert \"RelationType\""

tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/RenderingContent/RenderingContentWithCulturePublishStatus.spec.ts

@@ -0,0 +1,82 @@
+import {test} from '@umbraco/acceptance-test-helpers';
+
+// Languages
+const englishIsoCode = 'en-US';
+const danishIsoCode = 'da';
+const cultures = [englishIsoCode, danishIsoCode];
+
+// Document Types
+const rootDocumentTypeName = 'RootDocumentType';
+const childDocumentTypeName = 'ChildDocumentType';
+const grandchildDocumentTypeName = 'GrandchildDocumentType';
+
+// Content
+const rootContentName = 'RootContent';
+const publishedChildName = 'PublishedChild';
+const unpublishedChildName = 'UnpublishedChild';
+const grandchildContentName = 'Grandchild';
+
+// Template
+const renderTemplateName = 'RenderDescendantsTemplate';
+
+let renderTemplateId = '';
+let rootContentId = '';
+let unpublishedChildId = '';
+
+test.beforeEach(async ({umbracoApi}) => {
+  await umbracoApi.document.ensureNameNotExists(rootContentName);
+  await umbracoApi.language.ensureIsoCodeNotExists(danishIsoCode);
+  await umbracoApi.language.createDanishLanguage();
+  renderTemplateId = await umbracoApi.template.createTemplateWithDisplayingValue(renderTemplateName, '\n@foreach (var content in Model.Descendants())\n{\n\t<li>@content.Name</li>\n}');
+  const grandchildDocumentTypeId = await umbracoApi.documentType.createVariantDocumentTypeWithTemplateAndAllowedChildNode(grandchildDocumentTypeName, renderTemplateId);
+  const childDocumentTypeId = await umbracoApi.documentType.createVariantDocumentTypeWithTemplateAndAllowedChildNode(childDocumentTypeName, renderTemplateId, false, grandchildDocumentTypeId);
+  const rootDocumentTypeId = await umbracoApi.documentType.createVariantDocumentTypeWithTemplateAndAllowedChildNode(rootDocumentTypeName, renderTemplateId, true, childDocumentTypeId);
+
+  rootContentId = await umbracoApi.document.createVariantDocumentWithParent(rootDocumentTypeId, renderTemplateId, rootContentName, cultures);
+  await umbracoApi.document.publishWithCultures(rootContentId, cultures);
+  const publishedChildId = await umbracoApi.document.createVariantDocumentWithParent(childDocumentTypeId, renderTemplateId, publishedChildName, cultures, rootContentId);
+  await umbracoApi.document.publishWithCultures(publishedChildId, cultures);
+  unpublishedChildId = await umbracoApi.document.createVariantDocumentWithParent(childDocumentTypeId, renderTemplateId, unpublishedChildName, cultures, rootContentId);
+  await umbracoApi.document.publishWithCultures(unpublishedChildId, cultures);
+  const grandchildId = await umbracoApi.document.createVariantDocumentWithParent(grandchildDocumentTypeId, renderTemplateId, grandchildContentName, cultures, unpublishedChildId);
+  await umbracoApi.document.publishWithCultures(grandchildId, cultures);
+
+  const domainsData = await umbracoApi.document.getDomains(rootContentId);
+  domainsData.domains = [
+    {domainName: '/en', isoCode: englishIsoCode},
+    {domainName: '/da', isoCode: danishIsoCode}
+  ];
+  await umbracoApi.document.updateDomains(rootContentId, domainsData);
+});
+
+test.afterEach(async ({umbracoApi}) => {
+  await umbracoApi.document.ensureNameNotExists(rootContentName);
+  await umbracoApi.documentType.ensureNameNotExists(rootDocumentTypeName);
+  await umbracoApi.documentType.ensureNameNotExists(childDocumentTypeName);
+  await umbracoApi.documentType.ensureNameNotExists(grandchildDocumentTypeName);
+  await umbracoApi.template.ensureNameNotExists(renderTemplateName);
+  await umbracoApi.language.ensureIsoCodeNotExists(danishIsoCode);
+});
+
+test('can see a descendant is rendered when its ancestor is published in the requested culture', async ({umbracoApi, umbracoUi}) => {
+  // Act
+  const rootDanishUrl = await umbracoApi.document.getDocumentUrlByCulture(rootContentId, danishIsoCode);
+  await umbracoUi.contentRender.navigateToRenderedContentPage(rootDanishUrl);
+
+  // Assert
+  await umbracoUi.contentRender.doesContentRenderValueContainText(grandchildContentName);
+});
+
+test('a descendant is not rendered when its ancestor is unpublished in the requested culture', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.unpublish(unpublishedChildId, [englishIsoCode]);
+
+  // Act
+  const rootEnglishUrl = await umbracoApi.document.getDocumentUrlByCulture(rootContentId, englishIsoCode);
+  await umbracoUi.contentRender.navigateToRenderedContentPage(rootEnglishUrl);
+
+  // Assert
+  // In English the published child is a descendant, but the grandchild is excluded because its ancestor is unpublished in English
+  await umbracoUi.contentRender.doesContentRenderValueContainText(publishedChildName);
+  await umbracoUi.contentRender.doesContentRenderValueContainText(grandchildContentName, false, false);
+});