From 06d61094cc6a9e68cfa86102bb07b6efd18511c9 Mon Sep 17 00:00:00 2001 From: Kenn Jacobsen Date: Tue, 7 Nov 2023 09:01:27 +0100 Subject: [PATCH] Ensure invariant properties return the correct cache value at source level (#15145) Co-authored-by: Bjarke Berg --- .../Property.cs | 5 +- .../PublishedContentVarianceTests.cs | 152 ++++++++++++++++++ 2 files changed, 156 insertions(+), 1 deletion(-) create mode 100644 tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PublishedContentVarianceTests.cs diff --git a/src/Umbraco.PublishedCache.NuCache/Property.cs b/src/Umbraco.PublishedCache.NuCache/Property.cs index d921eb3f7c..6a9e1a982c 100644 --- a/src/Umbraco.PublishedCache.NuCache/Property.cs +++ b/src/Umbraco.PublishedCache.NuCache/Property.cs @@ -25,6 +25,7 @@ internal class Property : PublishedPropertyBase // the invariant-neutral source and inter values private readonly object? _sourceValue; private readonly ContentVariation _variations; + private bool _sourceValueIsInvariant; // the variant and non-variant object values private CacheValues? _cacheValues; @@ -89,6 +90,7 @@ internal class Property : PublishedPropertyBase // this variable is used for contextualizing the variation level when calculating property values. // it must be set to the union of variance (the combination of content type and property type variance). _variations = propertyType.Variations | content.ContentType.Variations; + _sourceValueIsInvariant = propertyType.Variations is ContentVariation.Nothing; } // clone for previewing as draft a published content that is published and has no draft @@ -104,6 +106,7 @@ internal class Property : PublishedPropertyBase _isMember = origin._isMember; _publishedSnapshotAccessor = origin._publishedSnapshotAccessor; _variations = origin._variations; + _sourceValueIsInvariant = origin._sourceValueIsInvariant; } // used to cache the CacheValues of this property @@ -152,7 +155,7 @@ internal class Property : PublishedPropertyBase { _content.VariationContextAccessor.ContextualizeVariation(_variations, _content.Id, ref culture, ref segment); - if (culture == string.Empty && segment == string.Empty) + if (_sourceValueIsInvariant || (culture == string.Empty && segment == string.Empty)) { return _sourceValue; } diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PublishedContentVarianceTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PublishedContentVarianceTests.cs new file mode 100644 index 0000000000..7d117b96c5 --- /dev/null +++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PublishedContentVarianceTests.cs @@ -0,0 +1,152 @@ +using Moq; +using NUnit.Framework; +using Umbraco.Cms.Core.Cache; +using Umbraco.Cms.Core.Models; +using Umbraco.Cms.Core.Models.PublishedContent; +using Umbraco.Cms.Core.PropertyEditors; +using Umbraco.Cms.Core.PublishedCache; +using Umbraco.Cms.Infrastructure.PublishedCache; +using Umbraco.Cms.Infrastructure.PublishedCache.DataSource; + +namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Published; + +[TestFixture] +public class PublishedContentVarianceTests +{ + private const string PropertyTypeAlias = "theProperty"; + private const string DaCulture = "da-DK"; + private const string EnCulture = "en-US"; + private const string Segment1 = "segment1"; + private const string Segment2 = "segment2"; + + [Test] + public void No_Content_Variation_Can_Get_Invariant_Property() + { + var content = CreatePublishedContent(ContentVariation.Nothing, ContentVariation.Nothing); + var value = GetPropertyValue(content); + Assert.AreEqual("Invariant property value", value); + } + + [TestCase(DaCulture)] + [TestCase(EnCulture)] + [TestCase("")] + public void Content_Culture_Variation_Can_Get_Invariant_Property(string culture) + { + var content = CreatePublishedContent(ContentVariation.Culture, ContentVariation.Nothing, variationContextCulture: culture); + var value = GetPropertyValue(content); + Assert.AreEqual("Invariant property value", value); + } + + [TestCase(Segment1)] + [TestCase(Segment2)] + [TestCase("")] + public void Content_Segment_Variation_Can_Get_Invariant_Property(string segment) + { + var content = CreatePublishedContent(ContentVariation.Culture, ContentVariation.Nothing, variationContextSegment: segment); + var value = GetPropertyValue(content); + Assert.AreEqual("Invariant property value", value); + } + + [TestCase(DaCulture, "DaDk property value")] + [TestCase(EnCulture, "EnUs property value")] + public void Content_Culture_Variation_Can_Get_Culture_Variant_Property(string culture, string expectedValue) + { + var content = CreatePublishedContent(ContentVariation.Culture, ContentVariation.Culture, variationContextCulture: culture); + var value = GetPropertyValue(content); + Assert.AreEqual(expectedValue, value); + } + + [TestCase(Segment1, "Segment1 property value")] + [TestCase(Segment2, "Segment2 property value")] + public void Content_Segment_Variation_Can_Get_Segment_Variant_Property(string segment, string expectedValue) + { + var content = CreatePublishedContent(ContentVariation.Segment, ContentVariation.Segment, variationContextSegment: segment); + var value = GetPropertyValue(content); + Assert.AreEqual(expectedValue, value); + } + + [TestCase(DaCulture, Segment1, "DaDk Segment1 property value")] + [TestCase(DaCulture, Segment2, "DaDk Segment2 property value")] + [TestCase(EnCulture, Segment1, "EnUs Segment1 property value")] + [TestCase(EnCulture, Segment2, "EnUs Segment2 property value")] + public void Content_Culture_And_Segment_Variation_Can_Get_Culture_And_Segment_Variant_Property(string culture, string segment, string expectedValue) + { + var content = CreatePublishedContent(ContentVariation.CultureAndSegment, ContentVariation.CultureAndSegment, variationContextCulture: culture, variationContextSegment: segment); + var value = GetPropertyValue(content); + Assert.AreEqual(expectedValue, value); + } + + private object? GetPropertyValue(IPublishedContent content) => content.GetProperty(PropertyTypeAlias)!.GetValue(); + + private IPublishedContent CreatePublishedContent(ContentVariation contentTypeVariation, ContentVariation propertyTypeVariation, string? variationContextCulture = null, string? variationContextSegment = null) + { + var propertyType = new Mock(); + propertyType.SetupGet(p => p.Alias).Returns(PropertyTypeAlias); + propertyType.SetupGet(p => p.CacheLevel).Returns(PropertyCacheLevel.None); + propertyType.SetupGet(p => p.DeliveryApiCacheLevel).Returns(PropertyCacheLevel.None); + propertyType.SetupGet(p => p.Variations).Returns(propertyTypeVariation); + propertyType + .Setup(p => p.ConvertSourceToInter(It.IsAny(), It.IsAny(), It.IsAny())) + .Returns((IPublishedElement _, object? source, bool _) => source); + propertyType + .Setup(p => p.ConvertInterToObject(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns((IPublishedElement _, PropertyCacheLevel _, object? inter, bool _) => inter); + + var contentType = new Mock(); + contentType.SetupGet(c => c.PropertyTypes).Returns(new[] { propertyType.Object }); + contentType.SetupGet(c => c.Variations).Returns(contentTypeVariation); + + var propertyData = new List(); + + switch (propertyTypeVariation) + { + case ContentVariation.Culture: + propertyData.Add(CreatePropertyData("EnUs property value", culture: EnCulture)); + propertyData.Add(CreatePropertyData("DaDk property value", culture: DaCulture)); + break; + case ContentVariation.Segment: + propertyData.Add(CreatePropertyData("Segment1 property value", segment: Segment1)); + propertyData.Add(CreatePropertyData("Segment2 property value", segment: Segment2)); + break; + case ContentVariation.CultureAndSegment: + propertyData.Add(CreatePropertyData("EnUs Segment1 property value", culture: EnCulture, segment: Segment1)); + propertyData.Add(CreatePropertyData("EnUs Segment2 property value", culture: EnCulture, segment: Segment2)); + propertyData.Add(CreatePropertyData("DaDk Segment1 property value", culture: DaCulture, segment: Segment1)); + propertyData.Add(CreatePropertyData("DaDk Segment2 property value", culture: DaCulture, segment: Segment2)); + break; + case ContentVariation.Nothing: + propertyData.Add(CreatePropertyData("Invariant property value")); + break; + } + + var properties = new Dictionary { { PropertyTypeAlias, propertyData.ToArray() } }; + + var contentNode = new ContentNode(123, Guid.NewGuid(), contentType.Object, 1, string.Empty, 1, 1, DateTime.Now, 1); + var contentData = new ContentData("bla", "bla", 1, DateTime.Now, 1, 1, true, properties, null); + + var elementCache = new FastDictionaryAppCache(); + var snapshotCache = new FastDictionaryAppCache(); + var publishedSnapshotMock = new Mock(); + publishedSnapshotMock.SetupGet(p => p.ElementsCache).Returns(elementCache); + publishedSnapshotMock.SetupGet(p => p.SnapshotCache).Returns(snapshotCache); + + var publishedSnapshot = publishedSnapshotMock.Object; + var publishedSnapshotAccessor = new Mock(); + publishedSnapshotAccessor.Setup(p => p.TryGetPublishedSnapshot(out publishedSnapshot)).Returns(true); + + var variationContextAccessorMock = new Mock(); + variationContextAccessorMock + .SetupGet(mock => mock.VariationContext) + .Returns(() => new VariationContext(variationContextCulture, variationContextSegment)); + + return new PublishedContent( + contentNode, + contentData, + publishedSnapshotAccessor.Object, + variationContextAccessorMock.Object, + Mock.Of()); + + PropertyData CreatePropertyData(string value, string? culture = null, string? segment = null) + => new() { Culture = culture ?? string.Empty, Segment = segment ?? string.Empty, Value = value }; + } +}