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

V15 QA Hybrid Cache added media cache tests and fixed media cache refreshing (#17160)

Browse Source 
* 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

* Builder testing

* Media test

* Created builders

* Updated method from getByKey to getById to maintain structure

* Updated test setup

* Moved tests

* Cleaned up builders

* Added helper

* Added space

* Updated tests

* Cleaned setup

* Added tests for MediaTypes

* Uncommented tests

* Added builder extensions

* Added interfaces for builder methods

* Updated to use interface pattern

* Updated name

* Used builder

* Cleaned up test

* Added media scope tests

* Removed PropertyTypeModelBuilder

* moved PropertyTypeModelBuilder to PropertyTypeEditingBuilder

* Removed constructor

* Removed duplicate

* Fixed naming

* Reverted

* Removed space

* Added todos

* Removed only run on linux

* Commet out DocumentHybridCacheTemplateTest again

This is fixed in the release branch

* Update media when media type is updated

* Remove todo the tests pass now

---------

Co-authored-by: Nikolaj Geisle <70372949+Zeegaan@users.noreply.github.com>
Co-authored-by: Zeegaan <skrivdetud@gmail.com>
Co-authored-by: Sven Geusens <sge@umbraco.dk>
Co-authored-by: nikolajlauridsen <nikolajlauridsen@protonmail.ch>
Co-authored-by: Bjarke Berg <mail@bergmania.dk>
This commit is contained in:
Andreas Zerbst
2024-10-02 13:36:26 +02:00
committed by nikolajlauridsen
parent 1dfaa5edbc
commit 04d71fa354
51 changed files with 1313 additions and 680 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheDocumentTypeTests.cs
View File

@@ -20,7 +20,7 @@ public class DocumentHybridCacheDocumentTypeTests : UmbracoIntegrationTestWithCo
[Test]
public async Task Can_Get_Draft_Content_By_Id()
{
//Act
// Act
await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
ContentType.RemovePropertyType("title");
@@ -48,12 +48,12 @@ public class DocumentHybridCacheDocumentTypeTests : UmbracoIntegrationTestWithCo
public async Task Content_Gets_Removed_When_DocumentType_Is_Deleted()
{
// Load into cache
var textpage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview: true);
Assert.IsNotNull(textpage);
var textPage = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview: true);
Assert.IsNotNull(textPage);
await ContentTypeService.DeleteAsync(textpage.ContentType.Key, Constants.Security.SuperUserKey);
await ContentTypeService.DeleteAsync(textPage.ContentType.Key, Constants.Security.SuperUserKey);
var textpageAgain = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview: true);
Assert.IsNull(textpageAgain);
var textPageAgain = await PublishedContentHybridCache.GetByIdAsync(Textpage.Key.Value, preview: true);
Assert.IsNull(textPageAgain);
}
}

3
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheMockTests.cs
View File

@@ -13,6 +13,7 @@ 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.Serialization;
using Umbraco.Cms.Infrastructure.HybridCache.Services;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
@@ -86,7 +87,7 @@ public class DocumentHybridCacheMockTests : UmbracoIntegrationTestWithContent
_mockedNucacheRepository.Setup(r => r.GetContentSourceAsync(It.IsAny<Guid>(), false))
.ReturnsAsync(publishedTestCacheNode);
_mockedNucacheRepository.Setup(r => r.GetContentByContentTypeKey(It.IsAny<IReadOnlyCollection<Guid>>())).Returns(
_mockedNucacheRepository.Setup(r => r.GetContentByContentTypeKey(It.IsAny<IReadOnlyCollection<Guid>>(), ContentCacheDataSerializerEntityType.Document)).Returns(
new List<ContentCacheNode>()
{
draftTestCacheNode,

54
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCachePropertyTest.cs
View File

@@ -9,7 +9,6 @@ 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;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
@@ -84,7 +83,7 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest
updateResult.Result.Content!.Key,
new CultureAndScheduleModel()
{
CulturesToPublishImmediately = new HashSet<string> {"*"},
CulturesToPublishImmediately = new HashSet<string> { "*" },
Schedules = new ContentScheduleCollection(),
},
Constants.Security.SuperUserKey);
@@ -104,35 +103,13 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest
private async Task<IContent> CreateContentPickerDocument(Guid templateKey, Guid textPageKey)
{
var builder = new ContentTypeEditingBuilder();
var pickerContentType = builder
.WithAlias("test")
.WithName("TestName")
.WithAllowAtRoot(true)
.AddAllowedTemplateKeys([templateKey])
.AddPropertyGroup()
.WithName("Content")
.Done()
.AddPropertyType()
.WithAlias("contentPicker")
.WithName("Content Picker")
.WithDataTypeKey(Constants.DataTypes.Guids.ContentPickerGuid)
.WithSortOrder(16)
.Done()
.Build();
var pickerContentType = ContentTypeEditingBuilder.CreateContentTypeWithContentPicker(templateKey: templateKey);
await ContentTypeEditingService.CreateAsync(pickerContentType, Constants.Security.SuperUserKey);
var createOtherModel = new ContentCreateModel
{
ContentTypeKey = pickerContentType.Key.Value,
ParentKey = Constants.System.RootKey,
InvariantName = "Test Create",
InvariantProperties = new[] { new PropertyValueModel { Alias = "contentPicker", Value = textPageKey }, },
};
var createOtherModel = ContentEditingBuilder.CreateContentWithOneInvariantProperty(pickerContentType.Key.Value,
"Test Create", "contentPicker", textPageKey);
var result = await ContentEditingService.CreateAsync(createOtherModel, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(ContentEditingOperationStatus.Success, result.Status);
@@ -140,11 +117,12 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest
result.Result.Content!.Key,
new CultureAndScheduleModel()
{
CulturesToPublishImmediately = new HashSet<string> {"*"},
CulturesToPublishImmediately = new HashSet<string> { "*" },
Schedules = new ContentScheduleCollection(),
},
Constants.Security.SuperUserKey);
Assert.IsTrue(publishResult.Success);
return result.Result.Content;
}
@@ -153,26 +131,18 @@ public class DocumentHybridCachePropertyTest : UmbracoIntegrationTest
var textContentType = ContentTypeEditingBuilder.CreateTextPageContentType(defaultTemplateKey: templateKey);
await ContentTypeEditingService.CreateAsync(textContentType, Constants.Security.SuperUserKey);
var createModel = new ContentCreateModel
{
ContentTypeKey = textContentType.Key.Value,
ParentKey = Constants.System.RootKey,
InvariantName = "Root Create",
InvariantProperties = new[]
{
new PropertyValueModel { Alias = "title", Value = "The title value" },
new PropertyValueModel { Alias = "bodyText", Value = "The body text" }
},
};
var contentCreateModel = ContentEditingBuilder.CreateContentWithTwoInvariantProperties(
textContentType.Key.Value, "Root Create", "title", "The title value", "bodyText", "The body text",
Constants.System.RootKey);
var createResult = await ContentEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey);
var createResult = await ContentEditingService.CreateAsync(contentCreateModel, Constants.Security.SuperUserKey);
Assert.IsTrue(createResult.Success);
var publishResult = await ContentPublishingService.PublishAsync(
createResult.Result.Content!.Key,
new CultureAndScheduleModel()
{
CulturesToPublishImmediately = new HashSet<string> {"*"},
CulturesToPublishImmediately = new HashSet<string> { "*" },
Schedules = new ContentScheduleCollection(),
},
Constants.Security.SuperUserKey);

10
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheScopeTests.cs
View File

@@ -18,12 +18,12 @@ public class DocumentHybridCacheScopeTests : UmbracoIntegrationTestWithContentEd
private IContentPublishingService ContentPublishingService => GetRequiredService<IContentPublishingService>();
private ICoreScopeProvider ICoreScopeProvider => GetRequiredService<ICoreScopeProvider>();
private ICoreScopeProvider CoreScopeProvider => GetRequiredService<ICoreScopeProvider>();
[Test]
public async Task Can_Get_Correct_Content_After_Rollback_With_Id()
{
using (ICoreScopeProvider.CreateCoreScope())
using (CoreScopeProvider.CreateCoreScope())
{
await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
}
@@ -38,7 +38,7 @@ public class DocumentHybridCacheScopeTests : UmbracoIntegrationTestWithContentEd
[Test]
public async Task Can_Get_Correct_Content_After_Rollback_With_Key()
{
using (ICoreScopeProvider.CreateCoreScope())
using (CoreScopeProvider.CreateCoreScope())
{
await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
}
@@ -53,7 +53,7 @@ public class DocumentHybridCacheScopeTests : UmbracoIntegrationTestWithContentEd
[Test]
public async Task Can_Get_Document_After_Scope_Complete_With_Id()
{
using (var scope = ICoreScopeProvider.CreateCoreScope())
using (var scope = CoreScopeProvider.CreateCoreScope())
{
await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
scope.Complete();
@@ -69,7 +69,7 @@ public class DocumentHybridCacheScopeTests : UmbracoIntegrationTestWithContentEd
[Test]
public async Task Can_Get_Document_After_Scope_Completes_With_Key()
{
using (var scope = ICoreScopeProvider.CreateCoreScope())
using (var scope = CoreScopeProvider.CreateCoreScope())
{
await ContentPublishingService.PublishAsync(Textpage.Key.Value, CultureAndSchedule, Constants.Security.SuperUserKey);
scope.Complete();

3
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheTemplateTests.cs
View File

@@ -1,4 +1,4 @@
using NUnit.Framework;
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Models.ContentEditing;
using Umbraco.Cms.Core.PublishedCache;
@@ -36,7 +36,6 @@ public class DocumentHybridCacheTemplateTests : UmbracoIntegrationTestWithConten
// Assert
Assert.AreEqual(updateContentResult.Status, ContentEditingOperationStatus.Success);
var textPageAfter = await PublishedContentHybridCache.GetByIdAsync(TextpageId, true);
// Should this not be null?
Assert.AreEqual(textPageAfter.TemplateId, null);
}
}

50
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheVariantsTests.cs
View File

@@ -60,13 +60,7 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
Culture = _englishIsoCode,
Name = "Updated English Name",
Properties =
new[]
{
new PropertyValueModel
{
Alias = _variantTitleAlias, Value = updatedVariantTitle
}
},
new[] { new PropertyValueModel { Alias = _variantTitleAlias, Value = updatedVariantTitle } },
},
new VariantModel
{
@@ -74,16 +68,14 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
Name = "Updated Danish Name",
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
@@ -116,10 +108,7 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
Name = "Updated English Name",
Properties = new[]
{
new PropertyValueModel
{
Alias = _variantTitleAlias, Value = updatedVariantTitle
},
new PropertyValueModel { Alias = _variantTitleAlias, Value = updatedVariantTitle },
},
},
},
@@ -146,35 +135,18 @@ public class DocumentHybridCacheVariantsTests : UmbracoIntegrationTest
.Build();
await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey);
var groupKey = Guid.NewGuid();
var contentType = new ContentTypeEditingBuilder()
.WithAlias("cultureVariationTest")
.WithName("Culture Variation Test")
.WithAllowAtRoot(true)
.WithVariesByCulture(true)
.AddPropertyType()
.WithAlias(_variantTitleAlias)
.WithName(_variantTitleName)
.WithVariesByCulture(true)
.WithContainerKey(groupKey)
.Done()
.AddPropertyType()
.WithAlias(_invariantTitleAlias)
.WithName(_invariantTitleName)
.WithContainerKey(groupKey)
.Done()
.AddPropertyGroup()
.WithName("content")
.WithKey(groupKey)
.Done()
.Build();
var contentType = ContentTypeEditingBuilder.CreateContentTypeWithTwoPropertiesOneVariantAndOneInvariant(
"cultureVariationTest", "Culture Variation Test", _variantTitleAlias, _variantTitleName,
_invariantTitleAlias, _invariantTitleName);
var contentTypeAttempt = await ContentTypeEditingService.CreateAsync(contentType, Constants.Security.SuperUserKey);
if (!contentTypeAttempt.Success)
{
throw new Exception("Failed to create content type");
}
var rootContentCreateModel = ContentEditingBuilder.CreateContentWithTwoVariantProperties(contentTypeAttempt.Result.Key, "en-US", "da-DK", _variantTitleAlias, _variantTitleName);
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;
}

73
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaHybridCacheMediaTypeTests.cs Normal file
View File

@@ -0,0 +1,73 @@
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.PublishedCache;
using Umbraco.Cms.Core.Services.ContentTypeEditing;
using Umbraco.Cms.Tests.Common.TestHelpers;
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)]
public class MediaHybridCacheMediaTypeTests : UmbracoIntegrationTestWithMediaEditing
{
private IPublishedMediaCache PublishedMediaHybridCache => GetRequiredService<IPublishedMediaCache>();
private new IMediaTypeEditingService MediaTypeEditingService => GetRequiredService<IMediaTypeEditingService>();
protected override void CustomTestSetup(IUmbracoBuilder builder) => builder.AddUmbracoHybridCache();
[Test]
public async Task Cannot_Get_Property_From_Media_After_It_Is_Removed_From_MediaType_By_Id()
{
// Arrange
var oldMedia = await PublishedMediaHybridCache.GetByIdAsync(SubTestMediaId);
Assert.IsNotNull(oldMedia.Value("testProperty"));
MediaTypeUpdateHelper mediaTypeUpdateHelper = new MediaTypeUpdateHelper();
// Act
var updateModel = mediaTypeUpdateHelper.CreateMediaTypeUpdateModel(CustomMediaType);
updateModel.Properties = [];
updateModel.Containers = [];
await MediaTypeEditingService.UpdateAsync(CustomMediaType, updateModel, Constants.Security.SuperUserKey);
// Assert
var newMedia = await PublishedMediaHybridCache.GetByIdAsync(SubTestMediaId);
Assert.IsNull(newMedia.Value("testProperty"));
}
[Test]
public async Task Cannot_Get_Property_From_Media_After_It_Is_Removed_From_MediaType_By_Key()
{
// Arrange
var oldMedia = await PublishedMediaHybridCache.GetByIdAsync(SubTestMedia.Key.Value);
Assert.IsNotNull(oldMedia.Value("testProperty"));
MediaTypeUpdateHelper mediaTypeUpdateHelper = new MediaTypeUpdateHelper();
// Act
var updateModel = mediaTypeUpdateHelper.CreateMediaTypeUpdateModel(CustomMediaType);
updateModel.Properties = [];
updateModel.Containers = [];
await MediaTypeEditingService.UpdateAsync(CustomMediaType, updateModel, Constants.Security.SuperUserKey);
// Assert
var newMedia = await PublishedMediaHybridCache.GetByIdAsync(SubTestMedia.Key.Value);
Assert.IsNull(newMedia.Value("testProperty"));
}
[Test]
public async Task Media_Gets_Removed_When_MediaType_Is_Deleted()
{
// Arrange
var media = await PublishedMediaHybridCache.GetByIdAsync(SubTestMedia.Key.Value);
Assert.IsNotNull(media);
// Act
await MediaTypeService.DeleteAsync(CustomMediaType.Key, Constants.Security.SuperUserKey);
// Assert
var newMedia = await PublishedMediaHybridCache.GetByIdAsync(SubTestMedia.Key.Value);
Assert.IsNull(newMedia);
}
}

90
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaHybridCacheScopeTests.cs Normal file
View File

@@ -0,0 +1,90 @@
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.PublishedCache;
using Umbraco.Cms.Core.Scoping;
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)]
public class MediaHybridCacheScopeTests : UmbracoIntegrationTestWithMediaEditing
{
protected override void CustomTestSetup(IUmbracoBuilder builder) => builder.AddUmbracoHybridCache();
private IPublishedMediaCache PublishedMediaHybridCache => GetRequiredService<IPublishedMediaCache>();
private ICoreScopeProvider CoreScopeProvider => GetRequiredService<ICoreScopeProvider>();
[Test]
public async Task Can_Get_Media_After_Delete_Was_Rolled_back_With_Id()
{
// Arrange
using (CoreScopeProvider.CreateCoreScope())
{
await MediaEditingService.DeleteAsync(SubFolder1.Key.Value, Constants.Security.SuperUserKey);
}
// Act
var media = await PublishedMediaHybridCache.GetByIdAsync(SubFolder1Id);
// Assert
// media should still be in cache, as we rolled scope back.
Assert.IsNotNull(media);
}
[Test]
public async Task Can_Get_Media_After_Delete_Was_Rolled_back_With_Key()
{
// Arrange
using (CoreScopeProvider.CreateCoreScope())
{
await MediaEditingService.DeleteAsync(SubFolder1.Key.Value, Constants.Security.SuperUserKey);
}
// Act
var media = await PublishedMediaHybridCache.GetByIdAsync(SubFolder1.Key.Value);
// Assert
// Media should still be in cache, as we rolled scope back.
Assert.IsNotNull(media);
}
[Test]
public async Task Can_Not_Get_Deleted_Media_After_Scope_Complete_With_Id()
{
// Arrange
using (var scope = CoreScopeProvider.CreateCoreScope())
{
await MediaEditingService.DeleteAsync(SubFolder1.Key.Value, Constants.Security.SuperUserKey);
scope.Complete();
}
// Act
var media = await PublishedMediaHybridCache.GetByIdAsync(SubFolder1Id);
// Assert
// Media should not be in cache, as we completed the scope for delete.
Assert.IsNull(media);
}
[Test]
public async Task Can_Not_Get_Deleted_Media_After_Scope_Complete_With_Key()
{
// Arrange
using (var scope = CoreScopeProvider.CreateCoreScope())
{
await MediaEditingService.DeleteAsync(SubFolder1.Key.Value, Constants.Security.SuperUserKey);
scope.Complete();
}
// Act
var textPage = await PublishedMediaHybridCache.GetByIdAsync(SubFolder1.Key.Value);
// Assert
// Media should not be in cache, as we completed the scope for delete.
Assert.IsNull(textPage);
}
}

239
tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaHybridCacheTests.cs
View File

@@ -1,12 +1,7 @@
using NUnit.Framework;
using Umbraco.Cms.Core;
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.Web;
using Umbraco.Cms.Tests.Common.Builders;
using Umbraco.Cms.Tests.Common.Builders.Extensions;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
@@ -14,175 +9,161 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.PublishedCache.HybridCache;
[TestFixture]
[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
public class MediaHybridCacheTests : UmbracoIntegrationTest
public class MediaHybridCacheTests : UmbracoIntegrationTestWithMediaEditing
{
private IPublishedMediaCache PublishedMediaHybridCache => GetRequiredService<IPublishedMediaCache>();
private IUmbracoContextFactory UmbracoContextFactory => GetRequiredService<IUmbracoContextFactory>();
private IMediaTypeService MediaTypeService => GetRequiredService<IMediaTypeService>();
private IMediaEditingService MediaEditingService => GetRequiredService<IMediaEditingService>();
protected override void CustomTestSetup(IUmbracoBuilder builder) => builder.AddUmbracoHybridCache();
// TODO: make test with MediaWithCrops
// Media with crops
[Test]
public async Task Can_Get_Media_By_Key()
public async Task Can_Get_Root_Media_By_Id()
{
// Arrange
var newMediaType = new MediaTypeBuilder()
.WithAlias("album")
.WithName("Album")
.Build();
newMediaType.AllowedAsRoot = true;
MediaTypeService.Save(newMediaType);
var createModel = new MediaCreateModel
{
ContentTypeKey = newMediaType.Key,
ParentKey = Constants.System.RootKey,
InvariantName = "Image",
};
var result = await MediaEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
// Act
var media = await PublishedMediaHybridCache.GetByKeyAsync(result.Result.Content.Key);
var media = await PublishedMediaHybridCache.GetByIdAsync(RootFolderId);
// Assert
Assert.IsNotNull(media);
Assert.AreEqual("Image", media.Name);
Assert.AreEqual(newMediaType.Key, media.ContentType.Key);
Assert.AreEqual("RootFolder", media.Name);
Assert.AreEqual(RootFolder.ContentTypeKey, media.ContentType.Key);
}
[Test]
public async Task Can_Get_Media_By_Id()
public async Task Can_Get_Root_Media_By_Key()
{
// Arrange
var newMediaType = new MediaTypeBuilder()
.WithAlias("album")
.WithName("Album")
.Build();
newMediaType.AllowedAsRoot = true;
MediaTypeService.Save(newMediaType);
var createModel = new MediaCreateModel
{
ContentTypeKey = newMediaType.Key,
ParentKey = Constants.System.RootKey,
InvariantName = "Image",
};
var result = await MediaEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
// Act
var media = await PublishedMediaHybridCache.GetByIdAsync(result.Result.Content.Id);
var media = await PublishedMediaHybridCache.GetByIdAsync(RootFolder.Key.Value);
// Assert
Assert.IsNotNull(media);
Assert.AreEqual("Image", media.Name);
Assert.AreEqual(newMediaType.Key, media.ContentType.Key);
Assert.AreEqual("RootFolder", media.Name);
Assert.AreEqual(RootFolder.ContentTypeKey, media.ContentType.Key);
}
[Test]
public async Task Cannot_Get_Non_Existing_Media_By_Key()
public async Task Can_Get_Child_Media_By_Id()
{
// Act
var media = await PublishedMediaHybridCache.GetByKeyAsync(Guid.NewGuid());
var media = await PublishedMediaHybridCache.GetByIdAsync(SubImageId);
// Assert
Assert.IsNull(media);
Assert.IsNotNull(media);
Assert.AreEqual("SubImage", media.Name);
Assert.AreEqual(SubImage.ContentTypeKey, media.ContentType.Key);
Assert.AreEqual(SubImage.ParentKey, RootFolder.Key);
}
[Test]
public async Task Can_Get_Child_Media_By_Key()
{
var media = await PublishedMediaHybridCache.GetByIdAsync(SubImage.Key.Value);
// Assert
Assert.IsNotNull(media);
Assert.AreEqual("SubImage", media.Name);
Assert.AreEqual(SubImage.ContentTypeKey, media.ContentType.Key);
Assert.AreEqual(SubImage.ParentKey, RootFolder.Key);
}
[Test]
public async Task Cannot_Get_Non_Existing_Media_By_Id()
{
// Act
var media = await PublishedMediaHybridCache.GetByIdAsync(124214);
const int nonExistingId = 124214;
var media = await PublishedMediaHybridCache.GetByIdAsync(nonExistingId);
// Assert
Assert.IsNull(media);
}
[Test]
public async Task Can_Get_Media_Property_By_Key()
public async Task Cannot_Get_Non_Existing_Media_By_Key()
{
// Arrange
var media = await CreateMedia();
// Act
var publishedMedia = await PublishedMediaHybridCache.GetByKeyAsync(media.Key);
UmbracoContextFactory.EnsureUmbracoContext();
var media = await PublishedMediaHybridCache.GetByIdAsync(Guid.NewGuid());
// Assert
Assert.IsNotNull(media);
Assert.AreEqual("Image", media.Name);
Assert.AreEqual("NewTitle", publishedMedia.Value("title"));
Assert.IsNull(media);
}
[Test]
public async Task Can_Get_Media_Property_By_Id()
{
// Arrange
var media = await CreateMedia();
// Act
var publishedMedia = await PublishedMediaHybridCache.GetByKeyAsync(media.Key);
UmbracoContextFactory.EnsureUmbracoContext();
var media = await PublishedMediaHybridCache.GetByIdAsync(SubTestMediaId);
// Assert
Assert.IsNotNull(publishedMedia);
Assert.AreEqual("Image", publishedMedia.Name);
Assert.AreEqual("NewTitle", publishedMedia.Value("title"));
Assert.IsNotNull(media);
Assert.AreEqual("SubTestMedia", media.Name);
Assert.AreEqual("This is a test", media.Value("testProperty"));
}
[Test]
public async Task Can_Get_Updated_Media()
public async Task Can_Get_Media_Property_By_Key()
{
// Arrange
var media = await CreateMedia();
await PublishedMediaHybridCache.GetByIdAsync(media.Id);
// Act
var updateModel = new MediaUpdateModel()
{
InvariantName = "Update name",
InvariantProperties = new List<PropertyValueModel>()
{
new()
{
Alias = "title",
Value = "Updated Title"
}
}
};
var updateAttempt = await MediaEditingService.UpdateAsync(media.Key, updateModel, Constants.Security.SuperUserKey);
Assert.IsTrue(updateAttempt.Success);
var publishedMedia = await PublishedMediaHybridCache.GetByIdAsync(media.Id);
UmbracoContextFactory.EnsureUmbracoContext();
var media = await PublishedMediaHybridCache.GetByIdAsync(SubTestMedia.Key.Value);
// Assert
Assert.IsNotNull(publishedMedia);
Assert.AreEqual("Update name", publishedMedia.Name);
Assert.AreEqual("Updated Title", publishedMedia.Value("title"));
Assert.IsNotNull(media);
Assert.AreEqual("SubTestMedia", media.Name);
Assert.AreEqual("This is a test", media.Value("testProperty"));
}
[Test]
public async Task Can_Get_Updated_Media_By_Id()
{
// Arrange
const string newName = "NewImageName";
var media = await PublishedMediaHybridCache.GetByIdAsync(SubImageId);
Assert.AreEqual(media.Name, "SubImage");
var mediaUpdateModel = new MediaUpdateModel
{
InvariantName = newName,
InvariantProperties = SubImage.InvariantProperties,
Variants = SubImage.Variants,
};
// Act
await MediaEditingService.UpdateAsync(SubImage.Key.Value, mediaUpdateModel, Constants.Security.SuperUserKey);
var updatedMedia = await PublishedMediaHybridCache.GetByIdAsync(SubImageId);
// Assert
Assert.IsNotNull(updatedMedia);
Assert.AreEqual(newName, updatedMedia.Name);
}
[Test]
public async Task Can_Get_Updated_Media_By_Key()
{
// Arrange
const string newName = "NewImageName";
var media = await PublishedMediaHybridCache.GetByIdAsync(SubImage.Key.Value);
Assert.AreEqual(media.Name, "SubImage");
var mediaUpdateModel = new MediaUpdateModel
{
InvariantName = newName,
InvariantProperties = SubImage.InvariantProperties,
Variants = SubImage.Variants,
};
// Act
await MediaEditingService.UpdateAsync(SubImage.Key.Value, mediaUpdateModel, Constants.Security.SuperUserKey);
var updatedMedia = await PublishedMediaHybridCache.GetByIdAsync(SubImageId);
// Assert
Assert.IsNotNull(updatedMedia);
Assert.AreEqual(newName, updatedMedia.Name);
}
[Test]
public async Task Cannot_Get_Deleted_Media_By_Id()
{
// Arrange
var media = await CreateMedia();
var publishedMedia = await PublishedMediaHybridCache.GetByIdAsync(media.Id);
Assert.IsNotNull(publishedMedia);
var media = await PublishedMediaHybridCache.GetByIdAsync(SubImageId);
Assert.IsNotNull(media);
await MediaEditingService.DeleteAsync(media.Key, Constants.Security.SuperUserKey);
@@ -197,42 +178,16 @@ public class MediaHybridCacheTests : UmbracoIntegrationTest
public async Task Cannot_Get_Deleted_Media_By_Key()
{
// Arrange
var media = await CreateMedia();
var publishedMedia = await PublishedMediaHybridCache.GetByKeyAsync(media.Key);
Assert.IsNotNull(publishedMedia);
var media = await PublishedMediaHybridCache.GetByIdAsync(SubImage.Key.Value);
Assert.IsNotNull(media);
await MediaEditingService.DeleteAsync(media.Key, Constants.Security.SuperUserKey);
// Act
var deletedMedia = await PublishedMediaHybridCache.GetByKeyAsync(media.Key);
var deletedMedia = await PublishedMediaHybridCache.GetByIdAsync(media.Key);
// Assert
Assert.IsNull(deletedMedia);
}
private async Task<IMedia> CreateMedia()
{
IMediaType mediaType = MediaTypeBuilder.CreateSimpleMediaType("test", "Test");
mediaType.AllowedAsRoot = true;
MediaTypeService.Save(mediaType);
var createModel = new MediaCreateModel
{
ContentTypeKey = mediaType.Key,
ParentKey = Constants.System.RootKey,
InvariantName = "Image",
InvariantProperties = new List<PropertyValueModel>()
{
new()
{
Alias = "title",
Value = "NewTitle"
}
}
};
var result = await MediaEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
return result.Result.Content;
}
}