790c451df1
* Initial refactor (pending more tests) * Fix structural querying across changing publish states + add tests accordingly * Add tests to validate ancestor and descendant order * Remove axis querying from published status filtering --------- Co-authored-by: Nikolaj Geisle <70372949+Zeegaan@users.noreply.github.com>
328 lines
18 KiB
C#
328 lines
18 KiB
C#
using NUnit.Framework;
|
|
using Umbraco.Cms.Core;
|
|
using Umbraco.Cms.Core.Models;
|
|
using Umbraco.Cms.Core.Scoping;
|
|
using Umbraco.Cms.Tests.Common.Builders;
|
|
|
|
namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services;
|
|
|
|
public partial class DocumentNavigationServiceTests : DocumentNavigationServiceTestsBase
|
|
{
|
|
[SetUp]
|
|
public async Task Setup()
|
|
{
|
|
// Root
|
|
// - Child 1
|
|
// - Grandchild 1
|
|
// - Grandchild 2
|
|
// - Child 2
|
|
// - Grandchild 3
|
|
// - Great-grandchild 1
|
|
// - Child 3
|
|
// - Grandchild 4
|
|
|
|
// Doc Type
|
|
ContentType = ContentTypeBuilder.CreateSimpleContentType("page", "Page");
|
|
ContentType.Key = new Guid("DD72B8A6-2CE3-47F0-887E-B695A1A5D086");
|
|
ContentType.AllowedAsRoot = true;
|
|
ContentType.AllowedContentTypes = new[] { new ContentTypeSort(ContentType.Key, 0, ContentType.Alias) };
|
|
await ContentTypeService.CreateAsync(ContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Content
|
|
var rootModel = CreateContentCreateModel("Root", new Guid("E48DD82A-7059-418E-9B82-CDD5205796CF"));
|
|
var rootCreateAttempt = await ContentEditingService.CreateAsync(rootModel, Constants.Security.SuperUserKey);
|
|
Root = rootCreateAttempt.Result.Content!;
|
|
|
|
var child1Model = CreateContentCreateModel("Child 1", new Guid("C6173927-0C59-4778-825D-D7B9F45D8DDE"), parentKey: Root.Key);
|
|
var child1CreateAttempt = await ContentEditingService.CreateAsync(child1Model, Constants.Security.SuperUserKey);
|
|
Child1 = child1CreateAttempt.Result.Content!;
|
|
|
|
var grandchild1Model = CreateContentCreateModel("Grandchild 1", new Guid("E856AC03-C23E-4F63-9AA9-681B42A58573"), parentKey: Child1.Key);
|
|
var grandchild1CreateAttempt = await ContentEditingService.CreateAsync(grandchild1Model, Constants.Security.SuperUserKey);
|
|
Grandchild1 = grandchild1CreateAttempt.Result.Content!;
|
|
|
|
var grandchild2Model = CreateContentCreateModel("Grandchild 2", new Guid("A1B1B217-B02F-4307-862C-A5E22DB729EB"), parentKey: Child1.Key);
|
|
var grandchild2CreateAttempt = await ContentEditingService.CreateAsync(grandchild2Model, Constants.Security.SuperUserKey);
|
|
Grandchild2 = grandchild2CreateAttempt.Result.Content!;
|
|
|
|
var child2Model = CreateContentCreateModel("Child 2", new Guid("60E0E5C4-084E-4144-A560-7393BEAD2E96"), parentKey: Root.Key);
|
|
var child2CreateAttempt = await ContentEditingService.CreateAsync(child2Model, Constants.Security.SuperUserKey);
|
|
Child2 = child2CreateAttempt.Result.Content!;
|
|
|
|
var grandchild3Model = CreateContentCreateModel("Grandchild 3", new Guid("D63C1621-C74A-4106-8587-817DEE5FB732"), parentKey: Child2.Key);
|
|
var grandchild3CreateAttempt = await ContentEditingService.CreateAsync(grandchild3Model, Constants.Security.SuperUserKey);
|
|
Grandchild3 = grandchild3CreateAttempt.Result.Content!;
|
|
|
|
var greatGrandchild1Model = CreateContentCreateModel("Great-grandchild 1", new Guid("56E29EA9-E224-4210-A59F-7C2C5C0C5CC7"), parentKey: Grandchild3.Key);
|
|
var greatGrandchild1CreateAttempt = await ContentEditingService.CreateAsync(greatGrandchild1Model, Constants.Security.SuperUserKey);
|
|
GreatGrandchild1 = greatGrandchild1CreateAttempt.Result.Content!;
|
|
|
|
var child3Model = CreateContentCreateModel("Child 3", new Guid("B606E3FF-E070-4D46-8CB9-D31352029FDF"), parentKey: Root.Key);
|
|
var child3CreateAttempt = await ContentEditingService.CreateAsync(child3Model, Constants.Security.SuperUserKey);
|
|
Child3 = child3CreateAttempt.Result.Content!;
|
|
|
|
var grandchild4Model = CreateContentCreateModel("Grandchild 4", new Guid("F381906C-223C-4466-80F7-B63B4EE073F8"), parentKey: Child3.Key);
|
|
var grandchild4CreateAttempt = await ContentEditingService.CreateAsync(grandchild4Model, Constants.Security.SuperUserKey);
|
|
Grandchild4 = grandchild4CreateAttempt.Result.Content!;
|
|
}
|
|
|
|
[Test]
|
|
public async Task Structure_Does_Not_Update_When_Scope_Is_Not_Completed()
|
|
{
|
|
// Arrange
|
|
Guid notCreatedRootKey = new Guid("516927E5-8574-497B-B45B-E27EFAB47DE4");
|
|
|
|
// Create node at content root
|
|
var createModel = CreateContentCreateModel("Root 2", notCreatedRootKey);
|
|
|
|
using (ICoreScope scope = ScopeProvider.CreateCoreScope())
|
|
{
|
|
await ContentEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey);
|
|
}
|
|
|
|
// Act
|
|
var nodeExists = DocumentNavigationQueryService.TryGetParentKey(notCreatedRootKey, out _);
|
|
|
|
// Assert
|
|
Assert.IsFalse(nodeExists);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Can_Filter_Root_Items_By_Type()
|
|
{
|
|
// Arrange
|
|
DocumentNavigationQueryService.TryGetRootKeysOfType(ContentType.Alias, out IEnumerable<Guid> initialRootKeysOfType);
|
|
List<Guid> initialRootOfTypeList = initialRootKeysOfType.ToList();
|
|
|
|
// Doc Type
|
|
var anotherContentType = ContentTypeBuilder.CreateSimpleContentType("anotherPage", "Another page");
|
|
anotherContentType.Key = new Guid("58A2958E-B34F-4289-A225-E99EEC2456AB");
|
|
anotherContentType.AllowedContentTypes = new[] { new ContentTypeSort(anotherContentType.Key, 0, anotherContentType.Alias) };
|
|
anotherContentType.AllowedAsRoot = true;
|
|
await ContentTypeService.CreateAsync(anotherContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Update old doc type
|
|
ContentType.AllowedContentTypes = new[] { new ContentTypeSort(ContentType.Key, 0, ContentType.Alias), new ContentTypeSort(anotherContentType.Key, 1, anotherContentType.Alias) };
|
|
await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Content
|
|
var root2Model = CreateContentCreateModel("Root 2", new Guid("11233548-2E87-4D3E-8FC4-4400F9DBEF56"), anotherContentType.Key); // Using new doc type
|
|
await ContentEditingService.CreateAsync(root2Model, Constants.Security.SuperUserKey);
|
|
var root3Model = CreateContentCreateModel("Root 3", new Guid("6E10F212-CE7F-47B5-A796-345861AEE613"), anotherContentType.Key); // Using new doc type
|
|
await ContentEditingService.CreateAsync(root3Model, Constants.Security.SuperUserKey);
|
|
|
|
// Act
|
|
DocumentNavigationQueryService.TryGetRootKeysOfType(anotherContentType.Alias, out IEnumerable<Guid> filteredRootKeysOfType);
|
|
List<Guid> filteredRootList = filteredRootKeysOfType.ToList();
|
|
|
|
DocumentNavigationQueryService.TryGetRootKeys(out IEnumerable<Guid> allRootKeys);
|
|
List<Guid> allRootList = allRootKeys.ToList();
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(1, initialRootOfTypeList.Count); // Verify that loaded doc types can be used to filter
|
|
Assert.AreEqual(2, filteredRootList.Count); // Verify that new doc type can be used to filter
|
|
Assert.AreEqual(3, allRootList.Count);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task Can_Filter_Children_By_Type()
|
|
{
|
|
// Arrange
|
|
Guid parentKey = Root.Key;
|
|
DocumentNavigationQueryService.TryGetChildrenKeysOfType(parentKey, ContentType.Alias, out IEnumerable<Guid> initialChildrenKeysOfType);
|
|
List<Guid> initialChildrenOfTypeList = initialChildrenKeysOfType.ToList();
|
|
|
|
// Doc Type
|
|
var anotherContentType = ContentTypeBuilder.CreateSimpleContentType("anotherPage", "Another page");
|
|
anotherContentType.Key = new Guid("58A2958E-B34F-4289-A225-E99EEC2456AB");
|
|
anotherContentType.AllowedContentTypes = new[] { new ContentTypeSort(anotherContentType.Key, 0, anotherContentType.Alias) };
|
|
await ContentTypeService.CreateAsync(anotherContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Update old doc type
|
|
ContentType.AllowedContentTypes = new[] { new ContentTypeSort(ContentType.Key, 0, ContentType.Alias), new ContentTypeSort(anotherContentType.Key, 1, anotherContentType.Alias) };
|
|
await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Content
|
|
var child4Model = CreateContentCreateModel("Child 4", new Guid("11233548-2E87-4D3E-8FC4-4400F9DBEF56"), anotherContentType.Key, parentKey); // Using new doc type
|
|
await ContentEditingService.CreateAsync(child4Model, Constants.Security.SuperUserKey);
|
|
|
|
// Act
|
|
DocumentNavigationQueryService.TryGetChildrenKeysOfType(parentKey, anotherContentType.Alias, out IEnumerable<Guid> filteredChildrenKeysOfType);
|
|
List<Guid> filteredChildrenList = filteredChildrenKeysOfType.ToList();
|
|
|
|
DocumentNavigationQueryService.TryGetChildrenKeys(parentKey, out IEnumerable<Guid> allChildrenKeys);
|
|
List<Guid> allChildrenList = allChildrenKeys.ToList();
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(3, initialChildrenOfTypeList.Count); // Verify that loaded doc types can be used to filter
|
|
Assert.AreEqual(1, filteredChildrenList.Count); // Verify that new doc type can be used to filter
|
|
Assert.AreEqual(4, allChildrenList.Count);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task Can_Filter_Descendants_By_Type()
|
|
{
|
|
// Arrange
|
|
Guid parentKey = Child2.Key;
|
|
DocumentNavigationQueryService.TryGetDescendantsKeysOfType(parentKey, ContentType.Alias, out IEnumerable<Guid> initialDescendantsKeysOfType);
|
|
List<Guid> initialDescendantsOfTypeList = initialDescendantsKeysOfType.ToList();
|
|
|
|
// Doc Type
|
|
var anotherContentType = ContentTypeBuilder.CreateSimpleContentType("anotherPage", "Another page");
|
|
anotherContentType.Key = new Guid("58A2958E-B34F-4289-A225-E99EEC2456AB");
|
|
anotherContentType.AllowedContentTypes = new[] { new ContentTypeSort(anotherContentType.Key, 0, anotherContentType.Alias) };
|
|
await ContentTypeService.CreateAsync(anotherContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Update old doc type
|
|
ContentType.AllowedContentTypes = new[] { new ContentTypeSort(ContentType.Key, 0, ContentType.Alias), new ContentTypeSort(anotherContentType.Key, 1, anotherContentType.Alias) };
|
|
await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Content
|
|
var greatGreatGrandchild1Model = CreateContentCreateModel("Great-great-grandchild 1", new Guid("11233548-2E87-4D3E-8FC4-4400F9DBEF56"), anotherContentType.Key, GreatGrandchild1.Key); // Using new doc type
|
|
await ContentEditingService.CreateAsync(greatGreatGrandchild1Model, Constants.Security.SuperUserKey);
|
|
|
|
// Act
|
|
DocumentNavigationQueryService.TryGetDescendantsKeysOfType(parentKey, anotherContentType.Alias, out IEnumerable<Guid> filteredDescendantsKeysOfType);
|
|
List<Guid> filteredDescendantsList = filteredDescendantsKeysOfType.ToList();
|
|
|
|
DocumentNavigationQueryService.TryGetDescendantsKeys(parentKey, out IEnumerable<Guid> allDescendantsKeys);
|
|
List<Guid> allDescendantsList = allDescendantsKeys.ToList();
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(2, initialDescendantsOfTypeList.Count); // Verify that loaded doc types can be used to filter
|
|
Assert.AreEqual(1, filteredDescendantsList.Count); // Verify that new doc type can be used to filter
|
|
Assert.AreEqual(3, allDescendantsList.Count);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task Can_Filter_Ancestors_By_Type()
|
|
{
|
|
// Arrange
|
|
Guid childKey = new Guid("1802D6B4-4A3C-4EBA-AFA3-1AF82C2D6483");
|
|
|
|
// Doc Type
|
|
var anotherContentType = ContentTypeBuilder.CreateSimpleContentType("anotherPage", "Another page");
|
|
anotherContentType.Key = new Guid("58A2958E-B34F-4289-A225-E99EEC2456AB");
|
|
anotherContentType.AllowedContentTypes = new[] { new ContentTypeSort(anotherContentType.Key, 0, anotherContentType.Alias) };
|
|
await ContentTypeService.CreateAsync(anotherContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Update old doc type
|
|
ContentType.AllowedContentTypes = new[] { new ContentTypeSort(ContentType.Key, 0, ContentType.Alias), new ContentTypeSort(anotherContentType.Key, 1, anotherContentType.Alias) };
|
|
await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Content
|
|
var greatGrandchild2Model = CreateContentCreateModel("Great-grandchild 2", new Guid("11233548-2E87-4D3E-8FC4-4400F9DBEF56"), anotherContentType.Key, Grandchild4.Key); // Using new doc type
|
|
await ContentEditingService.CreateAsync(greatGrandchild2Model, Constants.Security.SuperUserKey);
|
|
var greatGreatGrandchild1Model = CreateContentCreateModel("Great-great-grandchild 1", childKey, anotherContentType.Key, greatGrandchild2Model.Key); // Using new doc type
|
|
await ContentEditingService.CreateAsync(greatGreatGrandchild1Model, Constants.Security.SuperUserKey);
|
|
|
|
// Act
|
|
DocumentNavigationQueryService.TryGetAncestorsKeysOfType(childKey, ContentType.Alias, out IEnumerable<Guid> ancestorsKeysOfOriginalType);
|
|
List<Guid> ancestorsKeysOfOriginalTypeList = ancestorsKeysOfOriginalType.ToList();
|
|
|
|
DocumentNavigationQueryService.TryGetAncestorsKeysOfType(childKey, anotherContentType.Alias, out IEnumerable<Guid> ancestorsKeysOfNewType);
|
|
List<Guid> ancestorsKeysOfNewTypeList = ancestorsKeysOfNewType.ToList();
|
|
|
|
DocumentNavigationQueryService.TryGetAncestorsKeys(childKey, out IEnumerable<Guid> allAncestorsKeys);
|
|
List<Guid> allAncestorsList = allAncestorsKeys.ToList();
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(3, ancestorsKeysOfOriginalTypeList.Count); // Verify that loaded doc types can be used to filter
|
|
Assert.AreEqual(1, ancestorsKeysOfNewTypeList.Count); // Verify that new doc type can be used to filter
|
|
Assert.AreEqual(4, allAncestorsList.Count);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public async Task Can_Filter_Siblings_By_Type()
|
|
{
|
|
// Arrange
|
|
Guid parentKey = Child3.Key;
|
|
DocumentNavigationQueryService.TryGetSiblingsKeysOfType(parentKey, ContentType.Alias, out IEnumerable<Guid> initialSiblingsKeysOfType);
|
|
List<Guid> initialSiblingsOfTypeList = initialSiblingsKeysOfType.ToList();
|
|
|
|
// Doc Type
|
|
var anotherContentType = ContentTypeBuilder.CreateSimpleContentType("anotherPage", "Another page");
|
|
anotherContentType.Key = new Guid("58A2958E-B34F-4289-A225-E99EEC2456AB");
|
|
anotherContentType.AllowedContentTypes = new[] { new ContentTypeSort(anotherContentType.Key, 0, anotherContentType.Alias) };
|
|
await ContentTypeService.CreateAsync(anotherContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Update old doc type
|
|
ContentType.AllowedContentTypes = new[] { new ContentTypeSort(ContentType.Key, 0, ContentType.Alias), new ContentTypeSort(anotherContentType.Key, 1, anotherContentType.Alias) };
|
|
await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);
|
|
|
|
// Content
|
|
var child4Model = CreateContentCreateModel("Child 4", new Guid("11233548-2E87-4D3E-8FC4-4400F9DBEF56"), anotherContentType.Key, Root.Key); // Using new doc type
|
|
await ContentEditingService.CreateAsync(child4Model, Constants.Security.SuperUserKey);
|
|
|
|
// Act
|
|
DocumentNavigationQueryService.TryGetSiblingsKeysOfType(parentKey, anotherContentType.Alias, out IEnumerable<Guid> filteredSiblingsKeysOfType);
|
|
List<Guid> filteredSiblingsList = filteredSiblingsKeysOfType.ToList();
|
|
|
|
DocumentNavigationQueryService.TryGetSiblingsKeys(parentKey, out IEnumerable<Guid> allSiblingsKeys);
|
|
List<Guid> allSiblingsList = allSiblingsKeys.ToList();
|
|
|
|
// Assert
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(2, initialSiblingsOfTypeList.Count); // Verify that loaded doc types can be used to filter
|
|
Assert.AreEqual(1, filteredSiblingsList.Count); // Verify that new doc type can be used to filter
|
|
Assert.AreEqual(3, allSiblingsList.Count);
|
|
});
|
|
}
|
|
|
|
// a lot of structural querying assumes a specific order of descendants, so let's ensure that.
|
|
[Test]
|
|
public void Descendants_Are_In_Top_Down_Order_Of_Structure()
|
|
{
|
|
var result = DocumentNavigationQueryService.TryGetDescendantsKeysOrSelfKeys(Root.Key, out IEnumerable<Guid> descendantsKeys);
|
|
Assert.IsTrue(result);
|
|
|
|
var descendantsKeysAsArray = descendantsKeys.ToArray();
|
|
Assert.AreEqual(9, descendantsKeysAsArray.Length);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(Root.Key, descendantsKeysAsArray[0]);
|
|
Assert.AreEqual(Child1.Key, descendantsKeysAsArray[1]);
|
|
Assert.AreEqual(Grandchild1.Key, descendantsKeysAsArray[2]);
|
|
Assert.AreEqual(Grandchild2.Key, descendantsKeysAsArray[3]);
|
|
Assert.AreEqual(Child2.Key, descendantsKeysAsArray[4]);
|
|
Assert.AreEqual(Grandchild3.Key, descendantsKeysAsArray[5]);
|
|
Assert.AreEqual(GreatGrandchild1.Key, descendantsKeysAsArray[6]);
|
|
Assert.AreEqual(Child3.Key, descendantsKeysAsArray[7]);
|
|
Assert.AreEqual(Grandchild4.Key, descendantsKeysAsArray[8]);
|
|
});
|
|
}
|
|
|
|
// a lot of structural querying assumes a specific order of ancestors, so let's ensure that.
|
|
[Test]
|
|
public void Ancestors_Are_In_Down_Top_Order()
|
|
{
|
|
var result = DocumentNavigationQueryService.TryGetAncestorsOrSelfKeys(GreatGrandchild1.Key, out IEnumerable<Guid> ancestorsKeys);
|
|
Assert.IsTrue(result);
|
|
|
|
var ancestorKeysAsArray = ancestorsKeys.ToArray();
|
|
Assert.AreEqual(4, ancestorKeysAsArray.Length);
|
|
|
|
Assert.Multiple(() =>
|
|
{
|
|
Assert.AreEqual(GreatGrandchild1.Key, ancestorKeysAsArray[0]);
|
|
Assert.AreEqual(Grandchild3.Key, ancestorKeysAsArray[1]);
|
|
Assert.AreEqual(Child2.Key, ancestorKeysAsArray[2]);
|
|
Assert.AreEqual(Root.Key, ancestorKeysAsArray[3]);
|
|
});
|
|
}
|
|
}
|