V15: Cache Seeding (#17102)

* Update to dotnet 9 and update nuget packages * Update umbraco code version * Update Directory.Build.props Co-authored-by: Elitsa Marinovska <21998037+elit0451@users.noreply.github.com> * Include preview version in pipeline * update template projects * update global json with specific version * Update version.json to v15 * Rename TrimStart and TrimEnd to string specific * Rename to Exact * Update global.json Co-authored-by: Ronald Barendse <ronald@barend.se> * Remove includePreviewVersion * Rename to trim exact * Add new Hybridcache project * Add tests * Start implementing PublishedContent.cs * Implement repository for content * Refactor to use async everywhere * Add cache refresher * make public as needed for serialization * Use content type cache to get content type out * Refactor to use ContentCacheNode model, that goes in the memory cache * Remove content node kit as its not needed * Implement tests for ensuring caching * Implement better asserts * Implement published property * Refactor to use mapping * Rename to document tests * Update to test properties * Create more tests * Refactor mock tests into own file * Update property test * Fix published version of content * Change default cache level to elements * Refactor to always have draft * Refactor to not use PublishedModelFactory * Added tests * Added and updated tests * Fixed tests * Don't return empty object with id * More tests * Added key * Another key * Refactor CacheService to be responsible for using the hybrid cache * Use notification handler to remove deleted content from cache * Add more tests for missing functions * Implement missing methods * Remove HasContent as it pertains to routing * Fik up test * formatting * refactor variable names * Implement variant tests * Map all the published content properties * Get item out of cache first, to assert updated * Implement member cache * Add member test * Implement media cache * Implement property tests for media tests * Refactor tests to use extension method * Add more media tests * Refactor properties to no longer have element caching * Don't use property cache level * Start implementing seeding * Only seed when main * Add Immutable for performance * Implement permanent seeding of content * Implement cache settings * Implement tests for seeding * Update package version * start refactoring nurepo * Refactor so draft & published nodes are cached individually * Refactor RefreshContent to take node instead of IContent * Refactor media to also use cache nodes * Remove member from repo as it isn't cached * Refactor media to not include preview, as media has no draft * create new benchmark project * POC Integration benchmarks with custom api controllers * Start implementing content picker tests * Implement domain cache * Rework content cache to implement interface * Start implementing elements cache * Implement published snapshot service * Publish snapshot tests * Use snapshot for elements cache * Create test proving we don't clear cache when updating content picker * Clear entire elements cache * Remove properties from element cache, when content gets updated. * Rename methods to async * Refactor to use old cache interfaces instead of new ones * Remove snapshot, as it is no longer needed * Fix tests building * Refactor domaincache to not have snapshots * Delete benchmarks * Delete benchmarks * Add HybridCacheProject to Umbraco * Add comment to route value transformer * Implement is draft * remove snapshot from property * V15 updated the hybrid caching integration tests to use ContentEditingService (#16947) * Added builder extension withParentKey * Created builder with ContentEditingService * Added usage of the ContentEditingService to SETUP * Started using ContentEditingService builder in tests * Updated builder extensions * Fixed builder * Clean up * Clean up, not done * Added Ids * Remove entries from cache on delete * Fix up seeding logic * Don't register hybrid cache twice * Change seeded entry options * Update hybrid cache package * Fix up published property to work with delivery api again * Fix dependency injection to work with tests * Fix naming * Dont make caches nullable * Make content node sealed * Remove path and other unused from content node * Remove hacky 2 phase ctor * Refactor to actually set content templates * Remove umbraco context * Remove "HasBy" methods * rename property data * Delete obsolete legacy stuff * Add todo for making expiration configurable * Add todo in UmbracoContext * Add clarifying comment in content factory * Remove xml stuff from published property * Fix according to review * Make content type cache injectible * Make content type cache injectible * Rename to database cache repository * Rename to document cache * Add TODO * Refactor to async * Rename to async * Make everything async * Remove duplicate line from json schema * Move Hybrid cache project * Remove leftover file * Refactor to use keys * Refactor published content to no longer have content data, as it is on the node itself * Refactor to member to use proper content node ctor * Move tests to own folder * Add immutable objects to property and content data for performance * Make property data public * Fix member caching to be singleton * Obsolete GetContentType * Remove todo * Fix naming * Fix lots of exposed errors due to scope test * Add final scope tests * Rename to document cache service * Rename test files * Create new doc type tests * Add ignore to tests * Start implementing refresh for content type save * Clear contenttype cache when contenttype is updated * Fix test Teh contenttype is not upated unless the property is dirty * Updated tests * Added tests * Use init for ContentSourceDto * Startup of setup * Fix get by key in PublishedContentTypeCache * Remove ContentType from PublishedContentTypeCache when contenttype is deleted * Created interfaces for the builder with the necessary properties * Created builder for PropertyTypeContainer * Created builder for PropertyTypeEditing * Created builder for PropertyTypeValidationEditing * Made adjustments to the builder * Updated name of usage * Commented out to test * Cleaned up builders * Updated integration test setup * Moved tests * Added interface * Add IDocumentSeedKeyProvider and migrate existing logic to seed key provider * Added functionality to the INavigationQueryService to get root keys * Fixed issue with navigation * Created helper to Convert a IContentType to ContentTypeUpdateModel * Added interfaces * Added builder * Cleaned up builders and added fixes * Added tests for PublishedContentTypeCache * Applied changes in builder * Add BreadthFirstKeyProvider * Use ISet for seedkey providers * Implement GetContentSource by key * Seed the cache with keys provided by seed key providers * Builder updates * Test setup updates * Updated tests * Dont require contenttype keys for seeding * Fix cache settings * Don't inject cache settings into SeedingNotificationHandler * Fix tests * Use enlistment for setting updated cache item * Pin seeded nodes for longer * Fix BreadthFirstKeyProvider * Fix ContentTypeSeedKeyProvider * Fix tests * Only seed published documents * Only cache published if contentCacheNode is not draft * Fix incorrect templateId * Removed unnecessary setup * initialized value * Fixed template test * Removed test * Updated tests * Removed code that was not used * Removed unused cacheSettings * Re-organize to support media cache seeding * Add MediaBreadthFirstKeyProvider * Seed media * Don't use IdKeyMap when removing content from cache * Don't clear IdKeyMap in DocumentCacheService * Add unit tests * Don't use IdKeyMap when deleting media * Add default value to timespan * Use cancellation tokens when doing loop * Fixed Models Builder error --------- Co-authored-by: Zeegaan <skrivdetud@gmail.com> Co-authored-by: Nikolaj Geisle <70372949+Zeegaan@users.noreply.github.com> Co-authored-by: Elitsa Marinovska <21998037+elit0451@users.noreply.github.com> Co-authored-by: Ronald Barendse <ronald@barend.se> Co-authored-by: Andreas Zerbst <andr317c@live.dk> Co-authored-by: Sven Geusens <sge@umbraco.dk> Co-authored-by: Andreas Zerbst <73799582+andr317c@users.noreply.github.com> Co-authored-by: Bjarke Berg <mail@bergmania.dk>
2024-09-24 09:39:23 +02:00
parent d2504e3688
commit e342e795dd
51 changed files with 1769 additions and 413 deletions
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheDocumentTypeTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheDocumentTypeTests.cs
@@ -1,7 +1,7 @@
 using NUnit.Framework;
 using Umbraco.Cms.Core;
-using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.PublishedCache;
+using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;

@@ -16,16 +16,16 @@ public class DocumentHybridCacheDocumentTypeTests : UmbracoIntegrationTestWithCo

    private IPublishedContentCache PublishedContentHybridCache => GetRequiredService<IPublishedContentCache>();

-    private IPublishedContentTypeCache PublishedContentTypeCache => GetRequiredService<IPublishedContentTypeCache>();
+    private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();

    [Test]
    public async Task Can_Get_Draft_Content_By_Id()
    {
        //Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
+        await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);

        ContentType.RemovePropertyType("title");
-        ContentTypeService.Save(ContentType);
+        await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);

        // Assert
        var newTextPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
@@ -36,10 +36,10 @@ public class DocumentHybridCacheDocumentTypeTests : UmbracoIntegrationTestWithCo
    public async Task Can_Get_Draft_Content_By_Key()
    {
        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
+        await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);

        ContentType.RemovePropertyType("title");
-        ContentTypeService.Save(ContentType);
+        await ContentTypeService.UpdateAsync(ContentType, Constants.Security.SuperUserKey);
        //Assert
        var newTextPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
        Assert.IsNull(newTextPage.Value("title"));
@@ -57,26 +57,4 @@ public class DocumentHybridCacheDocumentTypeTests : UmbracoIntegrationTestWithCo
        var textpageAgain = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview: true);
        Assert.IsNull(textpageAgain);
    }
-
-
-    // TODO: Copy this into PublishedContentTypeCache
-    [Test]
-    public async Task Can_Get_Published_DocumentType_By_Key()
-    {
-        var contentType = PublishedContentTypeCache.Get(PublishedItemType.Content, Textpage.ContentTypeKey);
-        Assert.IsNotNull(contentType);
-        var contentTypeAgain = PublishedContentTypeCache.Get(PublishedItemType.Content, Textpage.ContentTypeKey);
-        Assert.IsNotNull(contentType);
-    }
-
-    [Test]
-    public async Task Published_DocumentType_Gets_Deleted()
-    {
-        var contentType = PublishedContentTypeCache.Get(PublishedItemType.Content, Textpage.ContentTypeKey);
-        Assert.IsNotNull(contentType);
-
-        await ContentTypeService.DeleteAsync(contentType.Key, Constants.Security.SuperUserKey);
-        // PublishedContentTypeCache just explodes if it doesn't exist
-        Assert.Catch(() => PublishedContentTypeCache.Get(PublishedItemType.Content, Textpage.ContentTypeKey));
-    }
 }
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheMockTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheMockTests.cs
@@ -1,4 +1,5 @@
-using Moq;
+using Microsoft.Extensions.Options;
+using Moq;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
@@ -7,9 +8,11 @@ using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Scoping;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.Navigation;
 using Umbraco.Cms.Infrastructure.HybridCache;
 using Umbraco.Cms.Infrastructure.HybridCache.Factories;
 using Umbraco.Cms.Infrastructure.HybridCache.Persistence;
+using Umbraco.Cms.Infrastructure.HybridCache.SeedKeyProviders.Document;
 using Umbraco.Cms.Infrastructure.HybridCache.Services;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
@@ -29,6 +32,8 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent

    private IContentPublishingService ContentPublishingService => GetRequiredService<IContentPublishingService>();

+    private CacheSettings _cacheSettings;
+
    [SetUp]
    public void SetUp()
    {
@@ -44,33 +49,48 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
            false,
            new Dictionary<string, PropertyData[]>(),
            null);
-        _mockedNucacheRepository.Setup(r => r.GetContentSourceAsync(It.IsAny<int>(), It.IsAny<bool>())).ReturnsAsync(
-            new ContentCacheNode()
-            {
-                ContentTypeId = Textpage.ContentTypeId,
-                CreatorId = Textpage.CreatorId,
-                CreateDate = Textpage.CreateDate,
-                Id = Textpage.Id,
-                Key = Textpage.Key,
-                SortOrder = 0,
-                Data = contentData,
-                IsDraft = true,
-            });
+
+
+        var draftTestCacheNode = new ContentCacheNode()
+        {
+            ContentTypeId = Textpage.ContentTypeId,
+            CreatorId = Textpage.CreatorId,
+            CreateDate = Textpage.CreateDate,
+            Id = Textpage.Id,
+            Key = Textpage.Key,
+            SortOrder = 0,
+            Data = contentData,
+            IsDraft = true,
+        };
+
+        var publishedTestCacheNode = new ContentCacheNode()
+        {
+            ContentTypeId = Textpage.ContentTypeId,
+            CreatorId = Textpage.CreatorId,
+            CreateDate = Textpage.CreateDate,
+            Id = Textpage.Id,
+            Key = Textpage.Key,
+            SortOrder = 0,
+            Data = contentData,
+            IsDraft = false,
+        };
+
+        _mockedNucacheRepository.Setup(r => r.GetContentSourceAsync(It.IsAny<int>(), true))
+            .ReturnsAsync(draftTestCacheNode);
+
+        _mockedNucacheRepository.Setup(r => r.GetContentSourceAsync(It.IsAny<int>(), false))
+            .ReturnsAsync(publishedTestCacheNode);
+
+        _mockedNucacheRepository.Setup(r => r.GetContentSourceAsync(It.IsAny<Guid>(), true))
+            .ReturnsAsync(draftTestCacheNode);
+
+        _mockedNucacheRepository.Setup(r => r.GetContentSourceAsync(It.IsAny<Guid>(), false))
+            .ReturnsAsync(publishedTestCacheNode);

        _mockedNucacheRepository.Setup(r => r.GetContentByContentTypeKey(It.IsAny<IReadOnlyCollection<Guid>>())).Returns(
            new List<ContentCacheNode>()
            {
-                new()
-                {
-                    ContentTypeId = Textpage.ContentTypeId,
-                    CreatorId = Textpage.CreatorId,
-                    CreateDate = Textpage.CreateDate,
-                    Id = Textpage.Id,
-                    Key = Textpage.Key,
-                    SortOrder = 0,
-                    Data = contentData,
-                    IsDraft = false,
-                },
+                draftTestCacheNode,
            });

        _mockedNucacheRepository.Setup(r => r.DeleteContentItemAsync(It.IsAny<int>()));
@@ -81,11 +101,30 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
            GetRequiredService<ICoreScopeProvider>(),
            GetRequiredService<Microsoft.Extensions.Caching.Hybrid.HybridCache>(),
            GetRequiredService<IPublishedContentFactory>(),
-            GetRequiredService<ICacheNodeFactory>());
+            GetRequiredService<ICacheNodeFactory>(),
+            GetSeedProviders(),
+            Options.Create(new CacheSettings()));

        _mockedCache = new DocumentCache(_mockDocumentCacheService, GetRequiredService<IPublishedContentTypeCache>());
    }

+    // We want to be able to alter the settings for the providers AFTER the test has started
+    // So we'll manually create them with a magic options mock.
+    private IEnumerable<IDocumentSeedKeyProvider> GetSeedProviders()
+    {
+        _cacheSettings = new CacheSettings();
+        _cacheSettings.DocumentBreadthFirstSeedCount = 0;
+
+        var mock = new Mock<IOptions<CacheSettings>>();
+        mock.Setup(m => m.Value).Returns(() => _cacheSettings);
+
+        return new List<IDocumentSeedKeyProvider>
+        {
+            new ContentTypeSeedKeyProvider(GetRequiredService<ICoreScopeProvider>(), GetRequiredService<IDatabaseCacheRepository>(), mock.Object),
+            new DocumentBreadthFirstKeyProvider(GetRequiredService<IDocumentNavigationQueryService>(), mock.Object),
+        };
+    }
+
    [Test]
    public async Task Content_Is_Cached_By_Key()
    {
@@ -95,7 +134,7 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
        var textPage2 = await _mockedCache.GetByIdAsync(Textpage.Key, true);
        AssertTextPage(textPage);
        AssertTextPage(textPage2);
-        _mockedNucacheRepository.Verify(x => x.GetContentSourceAsync(It.IsAny<int>(), It.IsAny<bool>()), Times.Exactly(1));
+        _mockedNucacheRepository.Verify(x => x.GetContentSourceAsync(It.IsAny<Guid>(), It.IsAny<bool>()), Times.Exactly(1));
    }

    [Test]
@@ -121,9 +160,10 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
        var publishResult = await ContentPublishingService.PublishAsync(Textpage.Key, schedule, Constants.Security.SuperUserKey);
        Assert.IsTrue(publishResult.Success);
        Textpage.Published = true;
-        await _mockDocumentCacheService.DeleteItemAsync(Textpage.Id);
+        await _mockDocumentCacheService.DeleteItemAsync(Textpage);

-        await _mockDocumentCacheService.SeedAsync(new [] {Textpage.ContentType.Key});
+        _cacheSettings.ContentTypeKeys = [ Textpage.ContentType.Key ];
+        await _mockDocumentCacheService.SeedAsync();
        var textPage = await _mockedCache.GetByIdAsync(Textpage.Id);
        AssertTextPage(textPage);

@@ -141,9 +181,10 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
        var publishResult = await ContentPublishingService.PublishAsync(Textpage.Key, schedule, Constants.Security.SuperUserKey);
        Assert.IsTrue(publishResult.Success);
        Textpage.Published = true;
-        await _mockDocumentCacheService.DeleteItemAsync(Textpage.Id);
+        await _mockDocumentCacheService.DeleteItemAsync(Textpage);

-        await _mockDocumentCacheService.SeedAsync(new [] {Textpage.ContentType.Key});
+        _cacheSettings.ContentTypeKeys = [ Textpage.ContentType.Key ];
+        await _mockDocumentCacheService.SeedAsync();
        var textPage = await _mockedCache.GetByIdAsync(Textpage.Key);
        AssertTextPage(textPage);

@@ -151,12 +192,13 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
    }

    [Test]
-    public async Task Content_Is_Not_Seeded_If_Unpublished_By_Id()
+    public async Task Content_Is_Not_Seeded_If_Unpblished_By_Id()
    {

-        await _mockDocumentCacheService.DeleteItemAsync(Textpage.Id);
+        await _mockDocumentCacheService.DeleteItemAsync(Textpage);

-        await _mockDocumentCacheService.SeedAsync(new [] {Textpage.ContentType.Key});
+        _cacheSettings.ContentTypeKeys = [ Textpage.ContentType.Key ];
+        await _mockDocumentCacheService.SeedAsync();
        var textPage = await _mockedCache.GetByIdAsync(Textpage.Id, true);
        AssertTextPage(textPage);

@@ -166,13 +208,14 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
    [Test]
    public async Task Content_Is_Not_Seeded_If_Unpublished_By_Key()
    {
-        await _mockDocumentCacheService.DeleteItemAsync(Textpage.Id);
+        _cacheSettings.ContentTypeKeys = [ Textpage.ContentType.Key ];
+        await _mockDocumentCacheService.DeleteItemAsync(Textpage);

-        await _mockDocumentCacheService.SeedAsync(new [] {Textpage.ContentType.Key});
+        await _mockDocumentCacheService.SeedAsync();
        var textPage = await _mockedCache.GetByIdAsync(Textpage.Key, true);
        AssertTextPage(textPage);

-        _mockedNucacheRepository.Verify(x => x.GetContentSourceAsync(It.IsAny<int>(), It.IsAny<bool>()), Times.Exactly(1));
+        _mockedNucacheRepository.Verify(x => x.GetContentSourceAsync(It.IsAny<Guid>(), It.IsAny<bool>()), Times.Exactly(1));
    }

    private void AssertTextPage(IPublishedContent textPage)
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCachePropertyTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCachePropertyTest.cs
@@ -6,6 +6,7 @@ using Umbraco.Cms.Core.Models.ContentPublishing;
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.ContentTypeEditing;
 using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Cms.Tests.Common.Builders;
 using Umbraco.Cms.Tests.Common.Builders.Extensions;
@@ -25,23 +26,25 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest

    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();

-    private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
-
    private IContentEditingService ContentEditingService => GetRequiredService<IContentEditingService>();

-    private IContentPublishingService ContentPublishingService => GetRequiredService<IContentPublishingService>();
+    private IContentTypeEditingService ContentTypeEditingService => GetRequiredService<IContentTypeEditingService>();

+    private IContentPublishingService ContentPublishingService => GetRequiredService<IContentPublishingService>();

    [Test]
    public async Task Can_Get_Value_From_ContentPicker()
    {
+        // Arrange
        var template = TemplateBuilder.CreateTextPageTemplate();
        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
-        var textPage = await CreateTextPageDocument(template.Id);
-        var contentPickerDocument = await CreateContentPickerDocument(template.Id, textPage.Key);
+        var textPage = await CreateTextPageDocument(template.Key);
+        var contentPickerDocument = await CreateContentPickerDocument(template.Key, textPage.Key);

+        // Act
        var contentPickerPage = await CacheManager.Content.GetByIdAsync(contentPickerDocument.Id);

+        // Assert
        IPublishedContent contentPickerValue = (IPublishedContent)contentPickerPage.Value("contentPicker");
        Assert.AreEqual(textPage.Key, contentPickerValue.Key);
        Assert.AreEqual(textPage.Id, contentPickerValue.Id);
@@ -52,10 +55,11 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest
    [Test]
    public async Task Can_Get_Value_From_Updated_ContentPicker()
    {
+        // Arrange
        var template = TemplateBuilder.CreateTextPageTemplate();
        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
-        var textPage = await CreateTextPageDocument(template.Id);
-        var contentPickerDocument = await CreateContentPickerDocument(template.Id, textPage.Key);
+        var textPage = await CreateTextPageDocument(template.Key);
+        var contentPickerDocument = await CreateContentPickerDocument(template.Key, textPage.Key);

        // Get for caching
        var notUpdatedContent = await CacheManager.Content.GetByIdAsync(contentPickerDocument.Id);
@@ -88,46 +92,42 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest

        Assert.IsTrue(publishResult);

+        // Act
        var contentPickerPage = await CacheManager.Content.GetByIdAsync(contentPickerDocument.Id);
+
+        // Assert
        IPublishedContent updatedPickerValue = (IPublishedContent)contentPickerPage.Value("contentPicker");
-
-
        Assert.AreEqual(textPage.Key, updatedPickerValue.Key);
        Assert.AreEqual(textPage.Id, updatedPickerValue.Id);
        Assert.AreEqual(textPage.Name, updatedPickerValue.Name);
        Assert.AreEqual("Updated title", updatedPickerValue.Properties.First(x => x.Alias == "title").GetValue());
    }

-    private async Task<IContent> CreateContentPickerDocument(int templateId, Guid textPageKey)
+    private async Task<IContent> CreateContentPickerDocument(Guid templateKey, Guid textPageKey)
    {
-        var builder = new ContentTypeBuilder();
-        var pickerContentType = (ContentType)builder
+        var builder = new ContentTypeEditingBuilder();
+        var pickerContentType = builder
            .WithAlias("test")
            .WithName("TestName")
-            .AddAllowedTemplate()
-            .WithId(templateId)
-            .Done()
+            .WithAllowAtRoot(true)
+            .AddAllowedTemplateKeys([templateKey])
            .AddPropertyGroup()
-            .WithName("Content")
-            .WithSupportsPublishing(true)
+                .WithName("Content")
+                .Done()
            .AddPropertyType()
-            .WithAlias("contentPicker")
-            .WithName("Content Picker")
-            .WithDataTypeId(1046)
-            .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.ContentPicker)
-            .WithValueStorageType(ValueStorageType.Integer)
-            .WithSortOrder(16)
-            .Done()
-            .Done()
+                .WithAlias("contentPicker")
+                .WithName("Content Picker")
+                .WithDataTypeKey(Constants.DataTypes.Guids.ContentPickerGuid)
+                .WithSortOrder(16)
+                .Done()
            .Build();

-        pickerContentType.AllowedAsRoot = true;
-        ContentTypeService.Save(pickerContentType);
+        await ContentTypeEditingService.CreateAsync(pickerContentType, Constants.Security.SuperUserKey);


        var createOtherModel = new ContentCreateModel
        {
-            ContentTypeKey = pickerContentType.Key,
+            ContentTypeKey = pickerContentType.Key.Value,
            ParentKey = Constants.System.RootKey,
            InvariantName = "Test Create",
            InvariantProperties = new[] { new PropertyValueModel { Alias = "contentPicker", Value = textPageKey }, },
@@ -149,15 +149,14 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest
        return result.Result.Content;
    }

-    private async Task<IContent> CreateTextPageDocument(int templateId)
+    private async Task<IContent> CreateTextPageDocument(Guid templateKey)
    {
-        var textContentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: templateId);
-        textContentType.AllowedAsRoot = true;
-        ContentTypeService.Save(textContentType);
+        var textContentType = ContentTypeEditingBuilder.CreateTextPageContentType(defaultTemplateKey: templateKey);
+        await ContentTypeEditingService.CreateAsync(textContentType, Constants.Security.SuperUserKey);

        var createModel = new ContentCreateModel
        {
-            ContentTypeKey = textContentType.Key,
+            ContentTypeKey = textContentType.Key.Value,
            ParentKey = Constants.System.RootKey,
            InvariantName = "Root Create",
            InvariantProperties = new[]
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheTemplateTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheTemplateTests.cs
@@ -0,0 +1,44 @@
+using NUnit.Framework;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.PublishedCache;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Tests.Common.Testing;
+using Umbraco.Cms.Tests.Integration.Testing;
+
+namespace Umbraco.Cms.Tests.Integration.Umbraco.PublishedCache.HybridCache;
+
+[TestFixture]
+[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
+[Platform("Linux", Reason = "This uses too much memory when running both caches, should be removed when nuchache is removed")]
+public class DocumentHybridCacheTemplateTests : UmbracoIntegrationTestWithContentEditing
+{
+    protected override void CustomTestSetup(IUmbracoBuilder builder) => builder.AddUmbracoHybridCache();
+
+    private IPublishedContentCache PublishedContentHybridCache => GetRequiredService<IPublishedContentCache>();
+
+    private IContentEditingService ContentEditingService => GetRequiredService<IContentEditingService>();
+
+    [Test]
+    public async Task Can_Get_Document_After_Removing_Template()
+    {
+        // Arrange
+        var textPageBefore = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
+        Assert.AreEqual(textPageBefore.TemplateId, TemplateId);
+        var updateModel = new ContentUpdateModel();
+        {
+            updateModel.TemplateKey = null;
+            updateModel.InvariantName = textPageBefore.Name;
+        }
+
+        // Act
+        var updateContentResult = await ContentEditingService.UpdateAsync(textPageBefore.Key, updateModel, Constants.Security.SuperUserKey);
+
+        // Assert
+        Assert.AreEqual(updateContentResult.Status, ContentEditingOperationStatus.Success);
+        var textPageAfter = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
+        // Should this not be null?
+        Assert.AreEqual(textPageAfter.TemplateId, null);
+    }
+}
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheTests.cs
@@ -25,16 +25,13 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    private const string NewName = "New Name";
    private const string NewTitle = "New Title";

-
-    // Create CRUD Tests for Content, Also cultures.
-
    [Test]
    public async Task Can_Get_Draft_Content_By_Id()
    {
-        //Act
+        // Act
        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);

-        //Assert
+        // Assert
        AssertTextPage(textPage);
    }

@@ -51,54 +48,42 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    [Test]
    public async Task Can_Get_Published_Content_By_Id()
    {
-        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-
        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId);

        // Assert
-        AssertTextPage(textPage);
+        AssertPublishedTextPage(textPage);
    }

    [Test]
    public async Task Can_Get_Published_Content_By_Key()
    {
-        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-
        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value);

        // Assert
-        AssertTextPage(textPage);
+        AssertPublishedTextPage(textPage);
    }

    [Test]
    public async Task Can_Get_Draft_Of_Published_Content_By_Id()
    {
-        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-
        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId, true);

        // Assert
-        AssertTextPage(textPage);
+        AssertPublishedTextPage(textPage);
        Assert.IsFalse(textPage.IsPublished());
    }

    [Test]
    public async Task Can_Get_Draft_Of_Published_Content_By_Key()
    {
-        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-
        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, true);

        // Assert
-        AssertTextPage(textPage);
+        AssertPublishedTextPage(textPage);
        Assert.IsFalse(textPage.IsPublished());
    }

@@ -151,19 +136,18 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Updated_Draft_Published_Content_By_Id(bool preview, bool result)
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        Textpage.InvariantName = NewName;
+        PublishedTextPage.InvariantName = NewName;
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
            InvariantName = NewName,
-            InvariantProperties = Textpage.InvariantProperties,
-            Variants = Textpage.Variants,
-            TemplateKey = Textpage.TemplateKey,
+            InvariantProperties = PublishedTextPage.InvariantProperties,
+            Variants = PublishedTextPage.Variants,
+            TemplateKey = PublishedTextPage.TemplateKey,
        };
-        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);
+        await ContentEditingService.UpdateAsync(PublishedTextPage.Key.Value, updateModel, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, preview);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId, preview);

        // Assert
        Assert.AreEqual(result, NewName.Equals(textPage.Name));
@@ -176,22 +160,18 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Updated_Draft_Published_Content_By_Key(bool preview, bool result)
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-
-        Textpage.InvariantName = NewName;
-
+        PublishedTextPage.InvariantName = NewName;
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
            InvariantName = NewName,
-            InvariantProperties = Textpage.InvariantProperties,
-            Variants = Textpage.Variants,
-            TemplateKey = Textpage.TemplateKey,
+            InvariantProperties = PublishedTextPage.InvariantProperties,
+            Variants = PublishedTextPage.Variants,
+            TemplateKey = PublishedTextPage.TemplateKey,
        };
-
-        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);
+        await ContentEditingService.UpdateAsync(PublishedTextPage.Key.Value, updateModel, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, preview);

        // Assert
        Assert.AreEqual(result, NewName.Equals(textPage.Name));
@@ -227,11 +207,10 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Published_Content_Property_By_Id()
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        var titleValue = Textpage.InvariantProperties.First(x => x.Alias == "title").Value;
+        var titleValue = PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value;

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId, true);

        // Assert
        Assert.AreEqual(titleValue, textPage.Value("title"));
@@ -241,11 +220,10 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Published_Content_Property_By_Key()
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        var titleValue = Textpage.InvariantProperties.First(x => x.Alias == "title").Value;
+        var titleValue = PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value;

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, true);

        // Assert
        Assert.AreEqual(titleValue, textPage.Value("title"));
@@ -255,11 +233,10 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Draft_Of_Published_Content_Property_By_Id()
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        var titleValue = Textpage.InvariantProperties.First(x => x.Alias == "title").Value;
+        var titleValue = PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value;

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId, true);

        // Assert
        Assert.AreEqual(titleValue, textPage.Value("title"));
@@ -269,11 +246,10 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Draft_Of_Published_Content_Property_By_Key()
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        var titleValue = Textpage.InvariantProperties.First(x => x.Alias == "title").Value;
+        var titleValue = PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value;

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, true);

        // Assert
        Assert.AreEqual(titleValue, textPage.Value("title"));
@@ -284,7 +260,6 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    {
        // Arrange
        Textpage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
-
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
            InvariantName = Textpage.InvariantName,
@@ -292,7 +267,6 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
            Variants = Textpage.Variants,
            TemplateKey = Textpage.TemplateKey,
        };
-
        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);

        // Act
@@ -307,7 +281,6 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    {
        // Arrange
        Textpage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
-
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
            InvariantName = Textpage.InvariantName,
@@ -315,7 +288,6 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
            Variants = Textpage.Variants,
            TemplateKey = Textpage.TemplateKey,
        };
-
        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);

        // Act
@@ -329,21 +301,19 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Updated_Published_Content_Property_By_Id()
    {
        // Arrange
-        Textpage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
-
+        PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
-            InvariantName = Textpage.InvariantName,
-            InvariantProperties = Textpage.InvariantProperties,
-            Variants = Textpage.Variants,
-            TemplateKey = Textpage.TemplateKey,
+            InvariantName = PublishedTextPage.InvariantName,
+            InvariantProperties = PublishedTextPage.InvariantProperties,
+            Variants = PublishedTextPage.Variants,
+            TemplateKey = PublishedTextPage.TemplateKey,
        };
-
-        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
+        await ContentEditingService.UpdateAsync(PublishedTextPage.Key.Value, updateModel, Constants.Security.SuperUserKey);
+        await ContentPublishingService.PublishAsync(PublishedTextPage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, true);

        // Assert
        Assert.AreEqual(NewTitle, textPage.Value("title"));
@@ -353,21 +323,19 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Updated_Published_Content_Property_By_Key()
    {
        // Arrange
-        Textpage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
-
+        PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
-            InvariantName = Textpage.InvariantName,
-            InvariantProperties = Textpage.InvariantProperties,
-            Variants = Textpage.Variants,
-            TemplateKey = Textpage.TemplateKey,
+            InvariantName = PublishedTextPage.InvariantName,
+            InvariantProperties = PublishedTextPage.InvariantProperties,
+            Variants = PublishedTextPage.Variants,
+            TemplateKey = PublishedTextPage.TemplateKey,
        };
-
-        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
+        await ContentEditingService.UpdateAsync(PublishedTextPage.Key.Value, updateModel, Constants.Security.SuperUserKey);
+        await ContentPublishingService.PublishAsync(PublishedTextPage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value);

        // Assert
        Assert.AreEqual(NewTitle, textPage.Value("title"));
@@ -379,21 +347,18 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Updated_Draft_Of_Published_Content_Property_By_Id(bool preview, string titleName)
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        Textpage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
-
+        PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value = NewTitle;
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
-            InvariantName = Textpage.InvariantName,
-            InvariantProperties = Textpage.InvariantProperties,
-            Variants = Textpage.Variants,
-            TemplateKey = Textpage.TemplateKey,
+            InvariantName = PublishedTextPage.InvariantName,
+            InvariantProperties = PublishedTextPage.InvariantProperties,
+            Variants = PublishedTextPage.Variants,
+            TemplateKey = PublishedTextPage.TemplateKey,
        };
-
-        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);
+        await ContentEditingService.UpdateAsync(PublishedTextPage.Key.Value, updateModel, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, preview);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId, preview);

        // Assert
        Assert.AreEqual(titleName, textPage.Value("title"));
@@ -405,21 +370,18 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Get_Updated_Draft_Of_Published_Content_Property_By_Key(bool preview, string titleName)
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        Textpage.InvariantProperties.First(x => x.Alias == "title").Value = titleName;
-
+        PublishedTextPage.InvariantProperties.First(x => x.Alias == "title").Value = titleName;
        ContentUpdateModel updateModel = new ContentUpdateModel
        {
-            InvariantName = Textpage.InvariantName,
-            InvariantProperties = Textpage.InvariantProperties,
-            Variants = Textpage.Variants,
-            TemplateKey = Textpage.TemplateKey,
+            InvariantName = PublishedTextPage.InvariantName,
+            InvariantProperties = PublishedTextPage.InvariantProperties,
+            Variants = PublishedTextPage.Variants,
+            TemplateKey = PublishedTextPage.TemplateKey,
        };
-
-        await ContentEditingService.UpdateAsync(Textpage.Key.Value, updateModel, Constants.Security.SuperUserKey);
+        await ContentEditingService.UpdateAsync(PublishedTextPage.Key.Value, updateModel, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, true);

        // Assert
        Assert.AreEqual(titleName, textPage.Value("title"));
@@ -429,12 +391,14 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Not_Get_Deleted_Content_By_Id()
    {
        // Arrange
-        var content = await PublishedContentHybridCache.GetByIdAsync(Subpage3Id, true);
+        var content = await PublishedContentHybridCache.GetByIdAsync(Subpage1Id, true);
        Assert.IsNotNull(content);
-        await ContentEditingService.DeleteAsync(Subpage3.Key.Value, Constants.Security.SuperUserKey);
+        await ContentEditingService.DeleteAsync(Subpage1.Key.Value, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Subpage3Id, true);
+        var textPagePublishedContent = await PublishedContentHybridCache.GetByIdAsync(Subpage1Id, false);
+
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(Subpage1Id, true);

        // Assert
        Assert.IsNull(textPage);
@@ -444,11 +408,13 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Not_Get_Deleted_Content_By_Key()
    {
        // Arrange
-        await PublishedContentHybridCache.GetByIdAsync(Subpage3.Key.Value, true);
-        var result = await ContentEditingService.DeleteAsync(Subpage3.Key.Value, Constants.Security.SuperUserKey);
+        await PublishedContentHybridCache.GetByIdAsync(Subpage1.Key.Value, true);
+        var hasContent = await PublishedContentHybridCache.GetByIdAsync(Subpage1Id, true);
+        Assert.IsNotNull(hasContent);
+        await ContentEditingService.DeleteAsync(Subpage1.Key.Value, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Subpage3.Key.Value, true);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(Subpage1.Key.Value, true);

        // Assert
        Assert.IsNull(textPage);
@@ -460,11 +426,10 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Not_Get_Deleted_Published_Content_By_Id(bool preview)
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        await ContentEditingService.DeleteAsync(Textpage.Key.Value, Constants.Security.SuperUserKey);
+        await ContentEditingService.DeleteAsync(PublishedTextPage.Key.Value, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(TextpageId, preview);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPageId, preview);

        // Assert
        Assert.IsNull(textPage);
@@ -476,11 +441,10 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
    public async Task Can_Not_Get_Deleted_Published_Content_By_Key(bool preview)
    {
        // Arrange
-        await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
-        await ContentEditingService.DeleteAsync(Textpage.Key.Value, Constants.Security.SuperUserKey);
+        await ContentEditingService.DeleteAsync(PublishedTextPage.Key.Value, Constants.Security.SuperUserKey);

        // Act
-        var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview);
+        var textPage = await PublishedContentHybridCache.GetByIdAsync(PublishedTextPage.Key.Value, preview);

        // Assert
        Assert.IsNull(textPage);
@@ -499,6 +463,19 @@ public class DocumentHybridCacheTests : UmbracoIntegrationTestWithContentEditing
        AssertProperties(Textpage.InvariantProperties, textPage.Properties);
    }

+    private void AssertPublishedTextPage(IPublishedContent textPage)
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.IsNotNull(textPage);
+            Assert.AreEqual(PublishedTextPage.Key, textPage.Key);
+            Assert.AreEqual(PublishedTextPage.ContentTypeKey, textPage.ContentType.Key);
+            Assert.AreEqual(PublishedTextPage.InvariantName, textPage.Name);
+        });
+
+        AssertProperties(PublishedTextPage.InvariantProperties, textPage.Properties);
+    }
+
    private void AssertProperties(IEnumerable<PropertyValueModel> propertyCollection, IEnumerable<IPublishedProperty> publishedProperties)
    {
        foreach (var prop in propertyCollection)
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheVariantsTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheVariantsTests.cs
@@ -4,6 +4,7 @@ using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.ContentEditing;
 using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.ContentTypeEditing;
 using Umbraco.Cms.Core.Web;
 using Umbraco.Cms.Tests.Common.Builders;
 using Umbraco.Cms.Tests.Common.Builders.Extensions;
@@ -24,12 +25,12 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
    private string _invariantTitleAlias = "invariantTitle";
    private string _invariantTitleName = "Invariant Title";

-    private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
-
    private ILanguageService LanguageService => GetRequiredService<ILanguageService>();

    private IContentEditingService ContentEditingService => GetRequiredService<IContentEditingService>();

+    private IContentTypeEditingService ContentTypeEditingService => GetRequiredService<IContentTypeEditingService>();
+
    private IUmbracoContextFactory UmbracoContextFactory => GetRequiredService<IUmbracoContextFactory>();

    private IPublishedContentCache PublishedContentHybridCache => GetRequiredService<IPublishedContentCache>();
@@ -49,31 +50,35 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
        var updatedInvariantTitle = "Updated Invariant Title";
        var updatedVariantTitle = "Updated Variant Title";

-
        var updateModel = new ContentUpdateModel
        {
-            InvariantProperties = new[]
-            {
-                new PropertyValueModel { Alias = _invariantTitleAlias, Value = updatedInvariantTitle }
-            },
-            Variants = new []
+            InvariantProperties =
+                new[] { new PropertyValueModel { Alias = _invariantTitleAlias, Value = updatedInvariantTitle } },
+            Variants = new[]
            {
                new VariantModel
                {
                    Culture = _englishIsoCode,
                    Name = "Updated English Name",
-                    Properties = new []
-                    {
-                        new PropertyValueModel { Alias = _variantTitleAlias, Value = updatedVariantTitle }
-                    }
+                    Properties =
+                        new[]
+                        {
+                            new PropertyValueModel
+                            {
+                                Alias = _variantTitleAlias, Value = updatedVariantTitle
+                            }
+                        },
                },
                new VariantModel
                {
                    Culture = _danishIsoCode,
                    Name = "Updated Danish Name",
-                    Properties = new []
+                    Properties = new[]
                    {
-                        new PropertyValueModel { Alias = _variantTitleAlias, Value = updatedVariantTitle }
+                        new PropertyValueModel
+                        {
+                            Alias = _variantTitleAlias, Value = updatedVariantTitle
+                        },
                    },
                },
            },
@@ -100,28 +105,29 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
        var updatedInvariantTitle = "Updated Invariant Title";
        var updatedVariantTitle = "Updated Invariant Title";

-
        var updateModel = new ContentUpdateModel
        {
-            InvariantProperties = new[]
-            {
-                new PropertyValueModel { Alias = _invariantTitleAlias, Value = updatedInvariantTitle }
-            },
-            Variants = new []
+            InvariantProperties =
+                new[] { new PropertyValueModel { Alias = _invariantTitleAlias, Value = updatedInvariantTitle } },
+            Variants = new[]
            {
                new VariantModel
                {
                    Culture = _englishIsoCode,
                    Name = "Updated English Name",
-                    Properties = new []
+                    Properties = new[]
                    {
-                        new PropertyValueModel { Alias = _variantTitleAlias, Value = updatedVariantTitle }
-                    }
+                        new PropertyValueModel
+                        {
+                            Alias = _variantTitleAlias, Value = updatedVariantTitle
+                        },
+                    },
                },
            },
        };

-        var result = await ContentEditingService.UpdateAsync(VariantPage.Key, updateModel, Constants.Security.SuperUserKey);
+        var result =
+            await ContentEditingService.UpdateAsync(VariantPage.Key, updateModel, Constants.Security.SuperUserKey);
        Assert.IsTrue(result.Success);

        // Act
@@ -134,59 +140,42 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
        Assert.AreEqual(_variantTitleName, textPage.Value(_variantTitleAlias, _danishIsoCode));
    }

-
    private async Task CreateTestData()
    {
-        // NOTE Maybe not the best way to create/save test data as we are using the services, which are being tested.
        var language = new LanguageBuilder()
            .WithCultureInfo(_danishIsoCode)
            .Build();
-
        await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey);

-        var contentType = new ContentTypeBuilder()
+        var groupKey = Guid.NewGuid();
+        var contentType = new ContentTypeEditingBuilder()
            .WithAlias("cultureVariationTest")
            .WithName("Culture Variation Test")
-            .WithContentVariation(ContentVariation.Culture)
+            .WithAllowAtRoot(true)
+            .WithVariesByCulture(true)
            .AddPropertyType()
-            .WithAlias(_variantTitleAlias)
-            .WithName(_variantTitleName)
-            .WithVariations(ContentVariation.Culture)
-            .Done()
+                .WithAlias(_variantTitleAlias)
+                .WithName(_variantTitleName)
+                .WithVariesByCulture(true)
+                .WithContainerKey(groupKey)
+                .Done()
            .AddPropertyType()
-            .WithAlias(_invariantTitleAlias)
-            .WithName(_invariantTitleName)
-            .WithVariations(ContentVariation.Nothing)
-            .Done()
+                .WithAlias(_invariantTitleAlias)
+                .WithName(_invariantTitleName)
+                .WithContainerKey(groupKey)
+                .Done()
+            .AddPropertyGroup()
+                .WithName("content")
+                .WithKey(groupKey)
+                .Done()
            .Build();
-        contentType.AllowedAsRoot = true;
-        ContentTypeService.Save(contentType);
-        var rootContentCreateModel = new ContentCreateModel
+        var contentTypeAttempt = await ContentTypeEditingService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+        if (!contentTypeAttempt.Success)
        {
-            ContentTypeKey = contentType.Key,
-            Variants = new[]
-            {
-                new VariantModel
-                {
-                    Culture = "en-US",
-                    Name = "English Page",
-                    Properties = new []
-                    {
-                        new PropertyValueModel { Alias = _variantTitleAlias, Value = _variantTitleName }
-                    },
-                },
-                new VariantModel
-                {
-                    Culture = "da-DK",
-                    Name = "Danish Page",
-                    Properties = new []
-                    {
-                        new PropertyValueModel { Alias = _variantTitleAlias, Value = _variantTitleName }
-                    },
-                },
-            },
-        };
+            throw new Exception("Failed to create content type");
+        }

+        var rootContentCreateModel = ContentEditingBuilder.CreateContentWithTwoVariantProperties(contentTypeAttempt.Result.Key, "en-US", "da-DK", _variantTitleAlias, _variantTitleName);
        var result = await ContentEditingService.CreateAsync(rootContentCreateModel, Constants.Security.SuperUserKey);
        VariantPage = result.Result.Content;
    }