V15 QA Hybrid Cache added media cache tests and fixed media cache refreshing

src/Umbraco.Core/PublishedCache/IPublishedMediaCache.cs

@@ -18,5 +18,5 @@ public interface IPublishedMediaCache : IPublishedCache
     /// <param name="key">The content unique identifier.</param>
     /// <returns>The content, or null.</returns>
     /// <remarks>Considers published or unpublished content depending on defaults.</remarks>
-    Task<IPublishedContent?> GetByKeyAsync(Guid key);
+    Task<IPublishedContent?> GetByIdAsync(Guid key);
 }

src/Umbraco.PublishedCache.HybridCache/DependencyInjection/UmbracoBuilderExtensions.cs

@@ -65,6 +65,8 @@ public static IUmbracoBuilder AddUmbracoHybridCache(this IUmbracoBuilder builder
         builder.AddNotificationAsyncHandler<MediaDeletedNotification, CacheRefreshingNotificationHandler>();
         builder.AddNotificationAsyncHandler<ContentTypeRefreshedNotification, CacheRefreshingNotificationHandler>();
         builder.AddNotificationAsyncHandler<ContentTypeDeletedNotification, CacheRefreshingNotificationHandler>();
+        builder.AddNotificationAsyncHandler<MediaTypeRefreshedNotification, CacheRefreshingNotificationHandler>();
+        builder.AddNotificationAsyncHandler<MediaTypeDeletedNotification, CacheRefreshingNotificationHandler>();
         builder.AddNotificationAsyncHandler<UmbracoApplicationStartedNotification, SeedingNotificationHandler>();
         builder.AddCacheSeeding();
         return builder;

src/Umbraco.PublishedCache.HybridCache/MediaCache.cs

@@ -18,17 +18,17 @@ public MediaCache(IMediaCacheService mediaCacheService, IPublishedContentTypeCac
 
     public async Task<IPublishedContent?> GetByIdAsync(int id) => await _mediaCacheService.GetByIdAsync(id);
 
-    public async Task<IPublishedContent?> GetByKeyAsync(Guid key) => await _mediaCacheService.GetByKeyAsync(key);
+    public async Task<IPublishedContent?> GetByIdAsync(Guid key) => await _mediaCacheService.GetByKeyAsync(key);
 
     public IPublishedContent? GetById(bool preview, int contentId) => GetByIdAsync(contentId).GetAwaiter().GetResult();
 
     public IPublishedContent? GetById(bool preview, Guid contentId) =>
-        GetByKeyAsync(contentId).GetAwaiter().GetResult();
+        GetByIdAsync(contentId).GetAwaiter().GetResult();
 
 
     public IPublishedContent? GetById(int contentId) => GetByIdAsync(contentId).GetAwaiter().GetResult();
 
-    public IPublishedContent? GetById(Guid contentId) => GetByKeyAsync(contentId).GetAwaiter().GetResult();
+    public IPublishedContent? GetById(Guid contentId) => GetByIdAsync(contentId).GetAwaiter().GetResult();
 
 
     public IPublishedContentType? GetContentType(Guid key) => _publishedContentTypeCache.Get(PublishedItemType.Media, key);

src/Umbraco.PublishedCache.HybridCache/NotificationHandlers/CacheRefreshingNotificationHandler.cs

@@ -19,7 +19,9 @@ internal sealed class CacheRefreshingNotificationHandler :
     INotificationAsyncHandler<MediaRefreshNotification>,
     INotificationAsyncHandler<MediaDeletedNotification>,
     INotificationAsyncHandler<ContentTypeRefreshedNotification>,
-    INotificationAsyncHandler<ContentTypeDeletedNotification>
+    INotificationAsyncHandler<ContentTypeDeletedNotification>,
+    INotificationAsyncHandler<MediaTypeRefreshedNotification>,
+    INotificationAsyncHandler<MediaTypeDeletedNotification>
 {
     private readonly IDocumentCacheService _documentCacheService;
     private readonly IMediaCacheService _mediaCacheService;
@@ -126,7 +128,7 @@ public Task HandleAsync(ContentTypeRefreshedNotification notification, Cancellat
         var contentTypeIds = notification.Changes.Where(x => x.ChangeTypes.HasTypesAny(types)).Select(x => x.Item.Id)
             .ToArray();
 
-        if (contentTypeIds.Length != 0)
+        if (contentTypeIds.Length > 0)
         {
             foreach (var contentTypeId in contentTypeIds)
             {
@@ -148,4 +150,33 @@ public Task HandleAsync(ContentTypeDeletedNotification notification, Cancellatio
 
         return Task.CompletedTask;
     }
+
+    public Task HandleAsync(MediaTypeRefreshedNotification notification, CancellationToken cancellationToken)
+    {
+        const ContentTypeChangeTypes types // only for those that have been refreshed
+            = ContentTypeChangeTypes.RefreshMain | ContentTypeChangeTypes.RefreshOther;
+        var mediaTypeIds = notification.Changes.Where(x => x.ChangeTypes.HasTypesAny(types)).Select(x => x.Item.Id)
+            .ToArray();
+
+        if (mediaTypeIds.Length > 0)
+        {
+            foreach (var mediaTypeId in mediaTypeIds)
+            {
+                _publishedContentTypeCache.ClearContentType(mediaTypeId);
+            }
+
+            _mediaCacheService.Rebuild(mediaTypeIds);
+        }
+        return Task.CompletedTask;
+    }
+
+    public Task HandleAsync(MediaTypeDeletedNotification notification, CancellationToken cancellationToken)
+    {
+        foreach (IMediaType deleted in notification.DeletedEntities )
+        {
+            _publishedContentTypeCache.ClearContentType(deleted.Id);
+        }
+
+        return Task.CompletedTask;
+    }
 }

src/Umbraco.PublishedCache.HybridCache/Persistence/DatabaseCacheRepository.cs

@@ -237,7 +237,7 @@ AND cmsContentNu.nodeId IS NULL
         return CreateContentNodeKit(dto, serializer, preview);
     }
 
-    private IEnumerable<ContentSourceDto> GetContentSourceByDocumentTypeKey(IEnumerable<Guid> documentTypeKeys)
+    private IEnumerable<ContentSourceDto> GetContentSourceByDocumentTypeKey(IEnumerable<Guid> documentTypeKeys, Guid objectType)
     {
         Guid[] keys = documentTypeKeys.ToArray();
         if (keys.Any() is false)
@@ -248,19 +248,27 @@ private IEnumerable<ContentSourceDto> GetContentSourceByDocumentTypeKey(IEnumera
         Sql<ISqlContext>? sql = SqlContentSourcesSelect()
             .InnerJoin<NodeDto>("n")
             .On<NodeDto, ContentDto>((n, c) => n.NodeId == c.ContentTypeId, "n", "umbracoContent")
-            .Append(SqlObjectTypeNotTrashed(SqlContext, Constants.ObjectTypes.Document))
+            .Append(SqlObjectTypeNotTrashed(SqlContext, objectType))
             .WhereIn<NodeDto>(x => x.UniqueId, keys,"n")
             .Append(SqlOrderByLevelIdSortOrder(SqlContext));
 
         return GetContentNodeDtos(sql);
     }
 
-    public IEnumerable<ContentCacheNode> GetContentByContentTypeKey(IEnumerable<Guid> keys)
+    public IEnumerable<ContentCacheNode> GetContentByContentTypeKey(IEnumerable<Guid> keys, ContentCacheDataSerializerEntityType entityType)
     {
-        IEnumerable<ContentSourceDto> dtos = GetContentSourceByDocumentTypeKey(keys);
+        Guid objectType = entityType switch
+        {
+            ContentCacheDataSerializerEntityType.Document => Constants.ObjectTypes.Document,
+            ContentCacheDataSerializerEntityType.Media => Constants.ObjectTypes.Media,
+            ContentCacheDataSerializerEntityType.Member => Constants.ObjectTypes.Member,
+            _ => throw new ArgumentOutOfRangeException(nameof(entityType), entityType, null),
+        };
+
+        IEnumerable<ContentSourceDto> dtos = GetContentSourceByDocumentTypeKey(keys, objectType);
 
         IContentCacheDataSerializer serializer =
-            _contentCacheDataSerializerFactory.Create(ContentCacheDataSerializerEntityType.Document);
+            _contentCacheDataSerializerFactory.Create(entityType);
 
         foreach (ContentSourceDto row in dtos)
         {
@@ -269,8 +277,8 @@ public IEnumerable<ContentCacheNode> GetContentByContentTypeKey(IEnumerable<Guid
     }
 
     /// <inheritdoc />
-    public IEnumerable<Guid> GetContentKeysByContentTypeKeys(IEnumerable<Guid> keys, bool published = false)
-        => GetContentSourceByDocumentTypeKey(keys).Where(x => x.Published == published).Select(x => x.Key);
+    public IEnumerable<Guid> GetDocumentKeysByContentTypeKeys(IEnumerable<Guid> keys, bool published = false)
+        => GetContentSourceByDocumentTypeKey(keys, Constants.ObjectTypes.Document).Where(x => x.Published == published).Select(x => x.Key);
 
     public async Task<ContentCacheNode?> GetMediaSourceAsync(int id)
     {

src/Umbraco.PublishedCache.HybridCache/Persistence/IDatabaseCacheRepository.cs

@@ -1,4 +1,5 @@
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Infrastructure.HybridCache.Serialization;
 
 namespace Umbraco.Cms.Infrastructure.HybridCache.Persistence;
 
@@ -15,14 +16,14 @@ internal interface IDatabaseCacheRepository
     Task<ContentCacheNode?> GetMediaSourceAsync(Guid key);
 
 
-    IEnumerable<ContentCacheNode> GetContentByContentTypeKey(IEnumerable<Guid> keys);
+    IEnumerable<ContentCacheNode> GetContentByContentTypeKey(IEnumerable<Guid> keys, ContentCacheDataSerializerEntityType entityType);
 
     /// <summary>
     /// Gets all content keys of specific document types
     /// </summary>
     /// <param name="keys">The document types to find content using.</param>
     /// <returns>The keys of all content use specific document types.</returns>
-    IEnumerable<Guid> GetContentKeysByContentTypeKeys(IEnumerable<Guid> keys, bool published = false);
+    IEnumerable<Guid> GetDocumentKeysByContentTypeKeys(IEnumerable<Guid> keys, bool published = false);
 
     /// <summary>
     ///     Refreshes the nucache database row for the given cache node />

src/Umbraco.PublishedCache.HybridCache/SeedKeyProviders/Document/ContentTypeSeedKeyProvider.cs

@@ -24,7 +24,7 @@ public ContentTypeSeedKeyProvider(
     public ISet<Guid> GetSeedKeys()
     {
         using ICoreScope scope = _scopeProvider.CreateCoreScope();
-        var documentKeys = _databaseCacheRepository.GetContentKeysByContentTypeKeys(_cacheSettings.ContentTypeKeys, published: true).ToHashSet();
+        var documentKeys = _databaseCacheRepository.GetDocumentKeysByContentTypeKeys(_cacheSettings.ContentTypeKeys, published: true).ToHashSet();
         scope.Complete();
 
         return documentKeys;

src/Umbraco.PublishedCache.HybridCache/Services/DocumentCacheService.cs

@@ -7,6 +7,7 @@
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Infrastructure.HybridCache.Factories;
 using Umbraco.Cms.Infrastructure.HybridCache.Persistence;
+using Umbraco.Cms.Infrastructure.HybridCache.Serialization;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Infrastructure.HybridCache.Services;
@@ -97,7 +98,7 @@ public DocumentCacheService(
     public IEnumerable<IPublishedContent> GetByContentType(IPublishedContentType contentType)
     {
         using ICoreScope scope = _scopeProvider.CreateCoreScope();
-        IEnumerable<ContentCacheNode> nodes = _databaseCacheRepository.GetContentByContentTypeKey([contentType.Key]);
+        IEnumerable<ContentCacheNode> nodes = _databaseCacheRepository.GetContentByContentTypeKey([contentType.Key], ContentCacheDataSerializerEntityType.Document);
         scope.Complete();
 
         return nodes
@@ -239,11 +240,11 @@ public async Task DeleteItemAsync(IContentBase content)
         scope.Complete();
     }
 
-    public void Rebuild(IReadOnlyCollection<int> contentTypeKeys)
+    public void Rebuild(IReadOnlyCollection<int> contentTypeIds)
     {
         using ICoreScope scope = _scopeProvider.CreateCoreScope();
-        _databaseCacheRepository.Rebuild(contentTypeKeys.ToList());
-        IEnumerable<ContentCacheNode> contentByContentTypeKey = _databaseCacheRepository.GetContentByContentTypeKey(contentTypeKeys.Select(x => _idKeyMap.GetKeyForId(x, UmbracoObjectTypes.DocumentType).Result));
+        _databaseCacheRepository.Rebuild(contentTypeIds.ToList());
+        IEnumerable<ContentCacheNode> contentByContentTypeKey = _databaseCacheRepository.GetContentByContentTypeKey(contentTypeIds.Select(x => _idKeyMap.GetKeyForId(x, UmbracoObjectTypes.DocumentType).Result), ContentCacheDataSerializerEntityType.Document);
 
         foreach (ContentCacheNode content in contentByContentTypeKey)
         {

src/Umbraco.PublishedCache.HybridCache/Services/IDocumentCacheService.cs

@@ -17,7 +17,7 @@ public interface IDocumentCacheService
 
     Task DeleteItemAsync(IContentBase content);
 
-    void Rebuild(IReadOnlyCollection<int> contentTypeKeys);
+    void Rebuild(IReadOnlyCollection<int> contentTypeIds);
 
     internal IEnumerable<IPublishedContent> GetByContentType(IPublishedContentType contentType);
 }

src/Umbraco.PublishedCache.HybridCache/Services/IMediaCacheService.cs

@@ -16,4 +16,6 @@ public interface IMediaCacheService
     Task DeleteItemAsync(IContentBase media);
 
     Task SeedAsync(CancellationToken cancellationToken);
+
+    void Rebuild(IReadOnlyCollection<int> contentTypeIds);
 }

src/Umbraco.PublishedCache.HybridCache/Services/MediaCacheService.cs

@@ -7,6 +7,7 @@
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Infrastructure.HybridCache.Factories;
 using Umbraco.Cms.Infrastructure.HybridCache.Persistence;
+using Umbraco.Cms.Infrastructure.HybridCache.Serialization;
 
 namespace Umbraco.Cms.Infrastructure.HybridCache.Services;
 
@@ -164,6 +165,26 @@ public async Task SeedAsync(CancellationToken cancellationToken)
         scope.Complete();
     }
 
+    public void Rebuild(IReadOnlyCollection<int> contentTypeIds)
+    {
+        using ICoreScope scope = _scopeProvider.CreateCoreScope();
+        _databaseCacheRepository.Rebuild(contentTypeIds.ToList());
+
+        IEnumerable<Guid> mediaTypeKeys = contentTypeIds.Select(x => _idKeyMap.GetKeyForId(x, UmbracoObjectTypes.MediaType))
+            .Where(x => x.Success)
+            .Select(x => x.Result);
+
+        IEnumerable<ContentCacheNode> mediaCacheNodesByContentTypeKey =
+            _databaseCacheRepository.GetContentByContentTypeKey(mediaTypeKeys, ContentCacheDataSerializerEntityType.Media);
+
+        foreach (ContentCacheNode media in mediaCacheNodesByContentTypeKey)
+        {
+            _hybridCache.RemoveAsync(GetCacheKey(media.Key, false));
+        }
+
+        scope.Complete();
+    }
+
     private HybridCacheEntryOptions GetSeedEntryOptions() => new()
     {
         Expiration = _cacheSettings.SeedCacheDuration, LocalCacheExpiration = _cacheSettings.SeedCacheDuration,

tests/Umbraco.Tests.Common/Builders/ContentEditingBaseBuilder.cs

@@ -0,0 +1,75 @@
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Tests.Common.Builders.Interfaces;
+
+namespace Umbraco.Cms.Tests.Common.Builders;
+
+public abstract class ContentEditingBaseBuilder<TCreateModel> : BuilderBase<TCreateModel>,
+    IWithInvariantNameBuilder,
+    IWithKeyBuilder,
+    IWithContentTypeKeyBuilder,
+    IWithParentKeyBuilder,
+    IBuildContentTypes
+    where TCreateModel : ContentCreationModelBase, new()
+{
+    protected TCreateModel _model = new();
+    private List<ContentEditingPropertyValueBuilder<ContentEditingBaseBuilder<TCreateModel>>> _invariantProperties = [];
+    private List<ContentEditingVariantBuilder<ContentEditingBaseBuilder<TCreateModel>>> _variants = [];
+    private Guid _contentTypeKey;
+    private Guid? _parentKey;
+    private Guid? _key;
+    private string _invariantName;
+
+    Guid? IWithKeyBuilder.Key
+    {
+        get => _key;
+        set => _key = value;
+    }
+
+    string IWithInvariantNameBuilder.InvariantName
+    {
+        get => _invariantName;
+        set => _invariantName = value;
+    }
+
+    Guid? IWithParentKeyBuilder.ParentKey
+    {
+        get => _parentKey;
+        set => _parentKey = value;
+    }
+
+    Guid IWithContentTypeKeyBuilder.ContentTypeKey
+    {
+        get => _contentTypeKey;
+        set => _contentTypeKey = value;
+    }
+
+    public ContentEditingPropertyValueBuilder<ContentEditingBaseBuilder<TCreateModel>> AddInvariantProperty()
+    {
+        var builder = new ContentEditingPropertyValueBuilder<ContentEditingBaseBuilder<TCreateModel>>(this);
+        _invariantProperties.Add(builder);
+        return builder;
+    }
+
+    public ContentEditingVariantBuilder<ContentEditingBaseBuilder<TCreateModel>> AddVariant()
+    {
+        var builder = new ContentEditingVariantBuilder<ContentEditingBaseBuilder<TCreateModel>>(this);
+        _variants.Add(builder);
+        return builder;
+    }
+
+    public override TCreateModel Build()
+    {
+        if (_parentKey is not null)
+        {
+            _model.ParentKey = _parentKey;
+        }
+
+        _model.InvariantName = _invariantName ?? Guid.NewGuid().ToString();
+        _model.ContentTypeKey = _contentTypeKey;
+        _model.Key = _key ?? Guid.NewGuid();
+        _model.InvariantProperties = _invariantProperties.Select(x => x.Build()).ToList();
+        _model.Variants = _variants.Select(x => x.Build()).ToList();
+
+        return _model;
+    }
+}