yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
472be3d40efff855201719117823c015754dccb3
Umbraco-CMS/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/PublishedCache/PublishedSnapshotServiceCollectionTests.cs
Mole 1258962429 V15: Remove Nucache (#17166) 
* Remove nucache reference from Web.Common

* Get tests building-ish

* Move ReservedFieldNamesService to the right project

* Remove IPublishedSnapshotStatus

* Added functionality to the INavigationQueryService to get root keys

* Fixed issue with navigation

* Remove IPublishedSnapshot from UmbracoContext

* Begin removing usage of IPublishedSnapshot from PublishedContentExtensions

* Fix PublishedContentExtensions.cs

* Don't use snapshots in delivery media api

* Use IPublishedMediaCache in QueryMediaApiController

* Remove more usages of IPublishedSnapshotAccessor

* Comment out tests

* Remove more usages of PublishedSnapshotAccessor

* Remove PublishedSnapshot from property

* Fixed test build

* Fix errors

* Fix some tests

* Delete NuCache 🎉

* Implement DatabaseCacheRebuilder

* Remove usage of IPublishedSnapshotService

* Remove IPublishedSnapshotService

* Remove TestPublishedSnapshotAccessor and make tests build

* Don't test Snapshot cachelevel

It's no longer supported

* Fix BlockEditorConverter

Element != Element document type

* Remember to set cachemanager

* Fix RichTextParserTests

* Implement TryGetLevel on INavigationQueryService

* Fake level and obsolete it in PublishedContent

* Remove ChildrenForAllCultures

* Hack Path property on PublishedContent

* Remove usages of IPublishedSnapshot in tests

* More ConvertersTests

* Add hybrid cache to integration tests

We can actually do this now because we no longer save files on disk

* Rename IPublishedSnapshotRebuilder to ICacheRebuilder

* Comment out tests

* V15: Replacing the usages of Parent (navigation data) from IPublishedContent (#17125)

* Fix .Parent references in PublishedContentExtensions

* Add missing methods to FriendlyPublishedContentExtensions (ones that you were able to call on the content directly as they now require extra params)

* Fix references from the extension methods

* Fix dependencies in tests

* Replace IPublishedSnapshotAccessor with the content cache in tests

* Resolving more .Parent references

* Fix unit tests

* Obsolete and use extension methods

* Remove private method and use extension instead

* Moving code around

* Fix tests

* Fix more references

* Cleanup

* Fix more usages

* Resolve merge conflict

* Fix tests

* Cleanup

* Fix more tests

* Fixed unit tests

* Cleanup

* Replace last usages

---------

Co-authored-by: Bjarke Berg <mail@bergmania.dk>

* Remove usage of IPublishedSnapshotAccessor from IRequestItemProvider

* Post merge fixup

* Remo IPublishedSnapshot

* Add HasAny to IDocumentUrlService

* Fix TextBuilder

* Fix modelsbuilder tests

* Use explicit types

* Implement GetByContentType

* Support element types in PublishedContentTypeCache

* Run enlistments before publishing notifications

* Fix elements cache refreshing

* Implement GetByUdi

* Implement GetAtRoot

* Implement GetByRoute

* Reimplement GetRouteById

* Fix blocks unit tests

* Initialize domain cache on boot

* Only return routes with domains on non default lanauges

* V15: Replacing the usages of `Children` (navigation data) from `IPublishedContent` (#17159)

* Update params in PublishedContentExtensions to the general interfaces for the published cache and navigation service, so that we can use the extension methods on both documents and media

* Introduce GetParent() which uses the right services

* Fix obsolete message on .Parent

* Obsolete .Children

* Fix usages of Children for ApiMediaQueryService

* Fix usage in internal

* Fix usages in views

* Fix indentation

* Fix issue with delete language

* Update nuget pacakges

* Clear elements cache when content is deleted

instead of trying to update it

* Reset publishedModelFactory

* Fixed publishing

---------

Co-authored-by: Bjarke Berg <mail@bergmania.dk>
Co-authored-by: Elitsa Marinovska <21998037+elit0451@users.noreply.github.com>
Co-authored-by: kjac <kja@umbraco.dk>
2024-10-01 15:03:02 +02:00

1347 lines
53 KiB
C#
Raw Blame History

// using NUnit.Framework;
// using Umbraco.Cms.Core.Cache;
// using Umbraco.Cms.Core.Models;
// using Umbraco.Cms.Core.Models.PublishedContent;
// using Umbraco.Cms.Core.Services.Changes;
// using Umbraco.Cms.Infrastructure.PublishedCache;
// using Umbraco.Cms.Infrastructure.PublishedCache.DataSource;
// using Umbraco.Cms.Tests.Common.Builders;
// using Umbraco.Cms.Tests.UnitTests.TestHelpers;
// using Umbraco.Extensions;
//
// namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.PublishedCache;
//
// FIXME: Reintroduce if relevant
// [TestFixture]
// public class PublishedSnapshotServiceCollectionTests : PublishedSnapshotServiceTestBase
// {
// [SetUp]
// public override void Setup()
// {
// base.Setup();
//
// var propertyType =
// new PropertyType(TestHelper.ShortStringHelper, "Umbraco.Void.Editor", ValueStorageType.Nvarchar)
// {
// Alias = "prop",
// DataTypeId = 3,
// Variations = ContentVariation.Nothing,
// };
// _contentTypeInvariant =
// new ContentType(TestHelper.ShortStringHelper, -1)
// {
// Id = 2,
// Alias = "itype",
// Variations = ContentVariation.Nothing,
// };
// _contentTypeInvariant.AddPropertyType(propertyType);
//
// propertyType =
// new PropertyType(TestHelper.ShortStringHelper, "Umbraco.Void.Editor", ValueStorageType.Nvarchar)
// {
// Alias = "prop",
// DataTypeId = 3,
// Variations = ContentVariation.Culture,
// };
// _contentTypeVariant =
// new ContentType(TestHelper.ShortStringHelper, -1)
// {
// Id = 3,
// Alias = "vtype",
// Variations = ContentVariation.Culture,
// };
// _contentTypeVariant.AddPropertyType(propertyType);
//
// _contentTypes = new[] { _contentTypeInvariant, _contentTypeVariant };
// }
//
// private ContentType _contentTypeInvariant;
// private ContentType _contentTypeVariant;
// private ContentType[] _contentTypes;
//
// private IEnumerable<ContentNodeKit> GetNestedVariantKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// // 1x variant (root)
// yield return CreateVariantKit(1, -1, 1, paths);
//
// // 1x invariant under root
// yield return CreateInvariantKit(4, 1, 1, paths);
//
// // 1x variant under root
// yield return CreateVariantKit(7, 1, 4, paths);
//
// // 2x mixed under invariant
// yield return CreateVariantKit(10, 4, 1, paths);
// yield return CreateInvariantKit(11, 4, 2, paths);
//
// // 2x mixed under variant
// yield return CreateVariantKit(12, 7, 1, paths);
// yield return CreateInvariantKit(13, 7, 2, paths);
// }
//
// private IEnumerable<ContentNodeKit> GetInvariantKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// yield return CreateInvariantKit(1, -1, 1, paths);
// yield return CreateInvariantKit(2, -1, 2, paths);
// yield return CreateInvariantKit(3, -1, 3, paths);
//
// yield return CreateInvariantKit(4, 1, 1, paths);
// yield return CreateInvariantKit(5, 1, 2, paths);
// yield return CreateInvariantKit(6, 1, 3, paths);
//
// yield return CreateInvariantKit(7, 2, 3, paths);
// yield return CreateInvariantKit(8, 2, 2, paths);
// yield return CreateInvariantKit(9, 2, 1, paths);
//
// yield return CreateInvariantKit(10, 3, 1, paths);
//
// yield return CreateInvariantKit(11, 4, 1, paths);
// yield return CreateInvariantKit(12, 4, 2, paths);
// }
//
// private ContentNodeKit CreateInvariantKit(int id, int parentId, int sortOrder, Dictionary<int, string> paths)
// {
// if (!paths.TryGetValue(parentId, out var parentPath))
// {
// throw new Exception("Unknown parent.");
// }
//
// var path = paths[id] = parentPath + "," + id;
// var level = path.Count(x => x == ',');
// var now = DateTime.Now;
//
// var contentData = ContentDataBuilder.CreateBasic("N" + id, now);
//
// return ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// id,
// path,
// sortOrder,
// level,
// parentId,
// 0,
// Guid.NewGuid(),
// DateTime.Now,
// null,
// contentData);
// }
//
// private IEnumerable<ContentNodeKit> GetVariantKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// yield return CreateVariantKit(1, -1, 1, paths);
// yield return CreateVariantKit(2, -1, 2, paths);
// yield return CreateVariantKit(3, -1, 3, paths);
//
// yield return CreateVariantKit(4, 1, 1, paths);
// yield return CreateVariantKit(5, 1, 2, paths);
// yield return CreateVariantKit(6, 1, 3, paths);
//
// yield return CreateVariantKit(7, 2, 3, paths);
// yield return CreateVariantKit(8, 2, 2, paths);
// yield return CreateVariantKit(9, 2, 1, paths);
//
// yield return CreateVariantKit(10, 3, 1, paths);
//
// yield return CreateVariantKit(11, 4, 1, paths);
// yield return CreateVariantKit(12, 4, 2, paths);
// }
//
// private static Dictionary<string, CultureVariation> GetCultureInfos(int id, DateTime now)
// {
// var en = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
// var fr = new[] { 1, 3, 4, 6, 7, 9, 10, 12 };
//
// var infos = new Dictionary<string, CultureVariation>();
// if (en.Contains(id))
// {
// infos["en-US"] = new CultureVariation { Name = "N" + id + "-" + "en-US", Date = now, IsDraft = false };
// }
//
// if (fr.Contains(id))
// {
// infos["fr-FR"] = new CultureVariation { Name = "N" + id + "-" + "fr-FR", Date = now, IsDraft = false };
// }
//
// return infos;
// }
//
// private ContentNodeKit CreateVariantKit(int id, int parentId, int sortOrder, Dictionary<int, string> paths)
// {
// if (!paths.TryGetValue(parentId, out var parentPath))
// {
// throw new Exception("Unknown parent.");
// }
//
// var path = paths[id] = parentPath + "," + id;
// var level = path.Count(x => x == ',');
// var now = DateTime.Now;
//
// var contentData = ContentDataBuilder.CreateVariant(
// "N" + id,
// GetCultureInfos(id, now),
// now);
//
// return ContentNodeKitBuilder.CreateWithContent(
// _contentTypeVariant.Id,
// id,
// path,
// sortOrder,
// level,
// parentId,
// draftData: null,
// publishedData: contentData);
// }
//
// private IEnumerable<ContentNodeKit> GetVariantWithDraftKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// Dictionary<string, CultureVariation> GetCultureInfos(int id, DateTime now)
// {
// var en = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
// var fr = new[] { 1, 3, 4, 6, 7, 9, 10, 12 };
//
// var infos = new Dictionary<string, CultureVariation>();
// if (en.Contains(id))
// {
// infos["en-US"] = new CultureVariation { Name = "N" + id + "-" + "en-US", Date = now, IsDraft = false };
// }
//
// if (fr.Contains(id))
// {
// infos["fr-FR"] = new CultureVariation { Name = "N" + id + "-" + "fr-FR", Date = now, IsDraft = false };
// }
//
// return infos;
// }
//
// ContentNodeKit CreateKit(int id, int parentId, int sortOrder)
// {
// if (!paths.TryGetValue(parentId, out var parentPath))
// {
// throw new Exception("Unknown parent.");
// }
//
// var path = paths[id] = parentPath + "," + id;
// var level = path.Count(x => x == ',');
// var now = DateTime.Now;
//
// ContentData CreateContentData(bool published)
// {
// return ContentDataBuilder.CreateVariant(
// "N" + id,
// GetCultureInfos(id, now),
// now,
// published);
// }
//
// var withDraft = id % 2 == 0;
// var withPublished = !withDraft;
//
// return ContentNodeKitBuilder.CreateWithContent(
// _contentTypeVariant.Id,
// id,
// path,
// sortOrder,
// level,
// parentId,
// draftData: withDraft ? CreateContentData(false) : null,
// publishedData: withPublished ? CreateContentData(true) : null);
// }
//
// yield return CreateKit(1, -1, 1);
// yield return CreateKit(2, -1, 2);
// yield return CreateKit(3, -1, 3);
//
// yield return CreateKit(4, 1, 1);
// yield return CreateKit(5, 1, 2);
// yield return CreateKit(6, 1, 3);
//
// yield return CreateKit(7, 2, 3);
// yield return CreateKit(8, 2, 2);
// yield return CreateKit(9, 2, 1);
//
// yield return CreateKit(10, 3, 1);
//
// yield return CreateKit(11, 4, 1);
// yield return CreateKit(12, 4, 2);
// }
//
// [Test]
// public void EmptyTest()
// {
// InitializedCache(Array.Empty<ContentNodeKit>(), _contentTypes);
//
// var snapshot = GetPublishedSnapshot();
//
// var documents = snapshot.Content.GetAtRoot().ToArray();
// Assert.AreEqual(0, documents.Length);
// }
//
// [Test]
// public void ChildrenTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// var snapshot = GetPublishedSnapshot();
//
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1", "N2", "N3");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N5", "N6");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9", "N8", "N7");
//
// documents = snapshot.Content.GetById(3).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N10");
//
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N11", "N12");
//
// documents = snapshot.Content.GetById(10).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents);
// }
//
// [Test]
// public void ParentTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// var snapshot = GetPublishedSnapshot();
//
// Assert.IsNull(snapshot.Content.GetById(1).Parent);
// Assert.IsNull(snapshot.Content.GetById(2).Parent);
// Assert.IsNull(snapshot.Content.GetById(3).Parent);
//
// Assert.AreEqual(1, snapshot.Content.GetById(4).Parent?.Id);
// Assert.AreEqual(1, snapshot.Content.GetById(5).Parent?.Id);
// Assert.AreEqual(1, snapshot.Content.GetById(6).Parent?.Id);
//
// Assert.AreEqual(2, snapshot.Content.GetById(7).Parent?.Id);
// Assert.AreEqual(2, snapshot.Content.GetById(8).Parent?.Id);
// Assert.AreEqual(2, snapshot.Content.GetById(9).Parent?.Id);
//
// Assert.AreEqual(3, snapshot.Content.GetById(10).Parent?.Id);
//
// Assert.AreEqual(4, snapshot.Content.GetById(11).Parent?.Id);
// Assert.AreEqual(4, snapshot.Content.GetById(12).Parent?.Id);
// }
//
// [Test]
// public void MoveToRootTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// // do some changes
// var kit = NuCacheContentService.ContentKits[10];
// NuCacheContentService.ContentKits[10] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// "-1,10",
// 4,
// 1,
// -1,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 10,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _);
//
// // changes that *I* make are immediately visible on the current snapshot
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1", "N2", "N3", "N10");
//
// documents = snapshot.Content.GetById(3).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents);
//
// Assert.IsNull(snapshot.Content.GetById(10).Parent);
// }
//
// [Test]
// public void MoveFromRootTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// // do some changes
// var kit = NuCacheContentService.ContentKits[1];
// NuCacheContentService.ContentKits[1] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// "-1,3,10,1",
// 1,
// 1,
// 10,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 1,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _);
//
// // changes that *I* make are immediately visible on the current snapshot
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N2", "N3");
//
// documents = snapshot.Content.GetById(10).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N1");
//
// Assert.AreEqual(10, snapshot.Content.GetById(1).Parent?.Id);
// }
//
// [Test]
// public void ReOrderTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// // do some changes
// var kit = NuCacheContentService.ContentKits[7];
// NuCacheContentService.ContentKits[7] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// kit.Node.Path,
// 1,
// kit.Node.Level,
// kit.Node.ParentContentId,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// kit = NuCacheContentService.ContentKits[8];
// NuCacheContentService.ContentKits[8] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// kit.Node.Path,
// 3,
// kit.Node.Level,
// kit.Node.ParentContentId,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// kit = NuCacheContentService.ContentKits[9];
// NuCacheContentService.ContentKits[9] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// kit.Node.Path,
// 2,
// kit.Node.Level,
// kit.Node.ParentContentId,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = kit.Node.ParentContentId,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _);
//
// // changes that *I* make are immediately visible on the current snapshot
// var documents = snapshot.Content.GetById(kit.Node.ParentContentId).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N7", "N9", "N8");
// }
//
// [Test]
// public void MoveTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// // do some changes
// var kit = NuCacheContentService.ContentKits[4];
// NuCacheContentService.ContentKits[4] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// kit.Node.Path,
// 2,
// kit.Node.Level,
// kit.Node.ParentContentId,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// kit = NuCacheContentService.ContentKits[5];
// NuCacheContentService.ContentKits[5] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// kit.Node.Path,
// 3,
// kit.Node.Level,
// kit.Node.ParentContentId,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// kit = NuCacheContentService.ContentKits[6];
// NuCacheContentService.ContentKits[6] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// kit.Node.Path,
// 4,
// kit.Node.Level,
// kit.Node.ParentContentId,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// kit = NuCacheContentService.ContentKits[7];
// NuCacheContentService.ContentKits[7] = ContentNodeKitBuilder.CreateWithContent(
// _contentTypeInvariant.Id,
// kit.Node.Id,
// "-1,1,7",
// 1,
// kit.Node.Level,
// 1,
// draftData: null,
// publishedData: ContentDataBuilder.CreateBasic(kit.PublishedData.Name));
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// // removal must come first
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 2,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// },
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 1,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _);
//
// // changes that *I* make are immediately visible on the current snapshot
// var documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N7", "N4", "N5", "N6");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9", "N8");
//
// Assert.AreEqual(1, snapshot.Content.GetById(7).Parent?.Id);
// }
//
// [Test]
// public void Clear_Branch_Locked()
// {
// // This test replicates an issue we saw here https://github.com/umbraco/Umbraco-CMS/pull/7907#issuecomment-610259393
// // The data was sent to me and this replicates it's structure
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// InitializedCache(
// new List<ContentNodeKit>
// {
// CreateInvariantKit(1, -1, 1, paths), // first level
// CreateInvariantKit(2, 1, 1, paths), // second level
// CreateInvariantKit(3, 2, 1, paths), // third level
//
// CreateInvariantKit(4, 3, 1, paths), // fourth level (we'll copy this one to the same level)
//
// CreateInvariantKit(5, 4, 1, paths), // 6th level
//
// CreateInvariantKit(6, 5, 2, paths), // 7th level
// CreateInvariantKit(7, 5, 3, paths),
// CreateInvariantKit(8, 5, 4, paths),
// CreateInvariantKit(9, 5, 5, paths),
// CreateInvariantKit(10, 5, 6, paths),
// },
// _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// // This will set a flag to force creating a new Gen next time the store is locked (i.e. In Notify)
// contentStore.CreateSnapshot();
//
// // notify - which ensures there are 2 generations in the cache meaning each LinkedNode has a Next value.
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 4,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _);
//
// // refresh the branch again, this used to show the issue where a null ref exception would occur
// // because in the ClearBranchLocked logic, when SetValueLocked was called within a recursive call
// // to a child, we null out the .Value of the LinkedNode within the while loop because we didn't capture
// // this value before recursing.
// Assert.DoesNotThrow(() =>
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 4,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _));
// }
//
// [Test]
// public void NestedVariationChildrenTest()
// {
// InitializedCache(GetNestedVariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// // TEST with en-us variation context
// VariationContextAccessor.VariationContext = new VariationContext("en-US");
//
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1-en-US");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N7-en-US");
//
// // Get the invariant and list children, there's a variation context so it should return invariant AND en-us variants
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N10-en-US", "N11");
//
// // Get the variant and list children, there's a variation context so it should return invariant AND en-us variants
// documents = snapshot.Content.GetById(7).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N12-en-US", "N13");
//
// // TEST with fr-fr variation context
// VariationContextAccessor.VariationContext = new VariationContext("fr-FR");
//
// documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1-fr-FR");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N7-fr-FR");
//
// // Get the invariant and list children, there's a variation context so it should return invariant AND en-us variants
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N10-fr-FR", "N11");
//
// // Get the variant and list children, there's a variation context so it should return invariant AND en-us variants
// documents = snapshot.Content.GetById(7).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N12-fr-FR", "N13");
//
// // TEST specific cultures
// documents = snapshot.Content.GetAtRoot("fr-FR").ToArray();
// AssertDocuments(documents, "N1-fr-FR");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor, "fr-FR").ToArray();
// AssertDocuments(documents, "N4", "N7-fr-FR"); // NOTE: Returns invariant, this is expected
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor, string.Empty).ToArray();
// AssertDocuments(documents, "N4"); // Only returns invariant since that is what was requested
//
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor, "fr-FR").ToArray();
// AssertDocuments(documents, "N10-fr-FR", "N11"); // NOTE: Returns invariant, this is expected
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor, string.Empty).ToArray();
// AssertDocuments(documents, "N11"); // Only returns invariant since that is what was requested
//
// documents = snapshot.Content.GetById(7).Children(VariationContextAccessor, "fr-FR").ToArray();
// AssertDocuments(documents, "N12-fr-FR", "N13"); // NOTE: Returns invariant, this is expected
// documents = snapshot.Content.GetById(7).Children(VariationContextAccessor, string.Empty).ToArray();
// AssertDocuments(documents, "N13"); // Only returns invariant since that is what was requested
//
// // TEST without variation context
// // This will actually convert the culture to "" which will be invariant since that's all it will know how to do
// // This will return a NULL name for culture specific entities because there is no variation context
// VariationContextAccessor.VariationContext = null;
//
// documents = snapshot.Content.GetAtRoot().ToArray();
//
// // will return nothing because there's only variant at root
// Assert.AreEqual(0, documents.Length);
//
// // so we'll continue to getting the known variant, do not fully assert this because the Name will NULL
// documents = snapshot.Content.GetAtRoot("fr-FR").ToArray();
// Assert.AreEqual(1, documents.Length);
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4");
//
// // Get the invariant and list children
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N11");
//
// // Get the variant and list children
// documents = snapshot.Content.GetById(7).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N13");
// }
//
// [Test]
// public void VariantChildrenTest()
// {
// InitializedCache(GetVariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// VariationContextAccessor.VariationContext = new VariationContext("en-US");
//
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1-en-US", "N2-en-US", "N3-en-US");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4-en-US", "N5-en-US", "N6-en-US");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9-en-US", "N8-en-US", "N7-en-US");
//
// documents = snapshot.Content.GetById(3).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N10-en-US");
//
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N11-en-US", "N12-en-US");
//
// documents = snapshot.Content.GetById(10).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents);
//
// VariationContextAccessor.VariationContext = new VariationContext("fr-FR");
//
// documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1-fr-FR", "N3-fr-FR");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4-fr-FR", "N6-fr-FR");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9-fr-FR", "N7-fr-FR");
//
// documents = snapshot.Content.GetById(3).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N10-fr-FR");
//
// documents = snapshot.Content.GetById(4).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N12-fr-FR");
//
// documents = snapshot.Content.GetById(10).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents);
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor, "*").ToArray();
// AssertDocuments(documents, "N4-fr-FR", string.Empty, "N6-fr-FR");
// AssertDocuments("en-US", documents, "N4-en-US", "N5-en-US", "N6-en-US");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor, "en-US").ToArray();
// AssertDocuments(documents, "N4-fr-FR", string.Empty, "N6-fr-FR");
// AssertDocuments("en-US", documents, "N4-en-US", "N5-en-US", "N6-en-US");
//
// documents = snapshot.Content.GetById(1).ChildrenForAllCultures.ToArray();
// AssertDocuments(documents, "N4-fr-FR", string.Empty, "N6-fr-FR");
// AssertDocuments("en-US", documents, "N4-en-US", "N5-en-US", "N6-en-US");
//
// documents = snapshot.Content.GetAtRoot("*").ToArray();
// AssertDocuments(documents, "N1-fr-FR", string.Empty, "N3-fr-FR");
//
// documents = snapshot.Content.GetById(1).DescendantsOrSelf(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N1-fr-FR", "N4-fr-FR", "N12-fr-FR", "N6-fr-FR");
//
// documents = snapshot.Content.GetById(1).DescendantsOrSelf(VariationContextAccessor, "*").ToArray();
// AssertDocuments(documents, "N1-fr-FR", "N4-fr-FR", string.Empty /*11*/, "N12-fr-FR", string.Empty /*5*/, "N6-fr-FR");
// }
//
// [Test]
// public void RemoveTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1", "N2", "N3");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N5", "N6");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9", "N8", "N7");
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload() // remove last
// {
// Id = 3,
// ChangeTypes = TreeChangeTypes.Remove
// },
// new ContentCacheRefresher.JsonPayload() // remove middle
// {
// Id = 5,
// ChangeTypes = TreeChangeTypes.Remove
// },
// new ContentCacheRefresher.JsonPayload() // remove first
// {
// Id = 9,
// ChangeTypes = TreeChangeTypes.Remove
// }
// },
// out _,
// out _);
//
// documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1", "N2");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N6");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N8", "N7");
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload() // remove first
// {
// Id = 1,
// ChangeTypes = TreeChangeTypes.Remove
// },
// new ContentCacheRefresher.JsonPayload() // remove
// {
// Id = 8,
// ChangeTypes = TreeChangeTypes.Remove
// },
// new ContentCacheRefresher.JsonPayload() // remove
// {
// Id = 7,
// ChangeTypes = TreeChangeTypes.Remove
// }
// },
// out _,
// out _);
//
// documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N2");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents);
// }
//
// [Test]
// public void UpdateTest()
// {
// InitializedCache(GetInvariantKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// var parentNodes = contentStore.Test.GetValues(1);
// var parentNode = parentNodes[0];
// AssertLinkedNode(parentNode.contentNode, -1, -1, 2, 4, 6);
// Assert.AreEqual(1, parentNode.gen);
//
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1", "N2", "N3");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N5", "N6");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9", "N8", "N7");
//
// // notify
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 1,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// },
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 2,
// ChangeTypes = TreeChangeTypes.RefreshNode
// }
// },
// out _,
// out _);
//
// parentNodes = contentStore.Test.GetValues(1);
// Assert.AreEqual(2, parentNodes.Length);
// parentNode = parentNodes[1]; // get the first gen
// AssertLinkedNode(parentNode.contentNode, -1, -1, 2, 4, 6); // the structure should have remained the same
// Assert.AreEqual(1, parentNode.gen);
// parentNode = parentNodes[0]; // get the latest gen
// AssertLinkedNode(parentNode.contentNode, -1, -1, 2, 4, 6); // the structure should have remained the same
// Assert.AreEqual(2, parentNode.gen);
//
// documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1", "N2", "N3");
//
// documents = snapshot.Content.GetById(1).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N4", "N5", "N6");
//
// documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray();
// AssertDocuments(documents, "N9", "N8", "N7");
// }
//
// [Test]
// public void AtRootTest()
// {
// InitializedCache(GetVariantWithDraftKits(), _contentTypes);
//
// // get snapshot
// var snapshot = GetPublishedSnapshot();
//
// VariationContextAccessor.VariationContext = new VariationContext("en-US");
//
// // N2 is draft only
// var documents = snapshot.Content.GetAtRoot().ToArray();
// AssertDocuments(documents, "N1-en-US", /*"N2-en-US",*/ "N3-en-US");
//
// documents = snapshot.Content.GetAtRoot(true).ToArray();
// AssertDocuments(documents, "N1-en-US", "N2-en-US", "N3-en-US");
// }
//
// [Test]
// public void Set_All_Fast_Sorted_Ensure_LastChildContentId()
// {
// // see https://github.com/umbraco/Umbraco-CMS/issues/6353
// IEnumerable<ContentNodeKit> GetKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// yield return CreateInvariantKit(1, -1, 1, paths);
// yield return CreateInvariantKit(2, 1, 1, paths);
// }
//
// InitializedCache(GetKits(), _contentTypes);
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// var parentNodes = contentStore.Test.GetValues(1);
// var parentNode = parentNodes[0];
// AssertLinkedNode(parentNode.contentNode, -1, -1, -1, 2, 2);
//
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 2,
// ChangeTypes = TreeChangeTypes.Remove
// }
// },
// out _,
// out _);
//
// parentNodes = contentStore.Test.GetValues(1);
// parentNode = parentNodes[0];
//
// AssertLinkedNode(parentNode.contentNode, -1, -1, -1, -1, -1);
// }
//
// [Test]
// public void Remove_Node_Ensures_Linked_List()
// {
// // NOTE: these tests are not using real scopes, in which case a Scope does not control
// // how the snapshots generations work. We are forcing new snapshot generations manually.
// IEnumerable<ContentNodeKit> GetKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// // root
// yield return CreateInvariantKit(1, -1, 1, paths);
//
// // children
// yield return CreateInvariantKit(2, 1, 1, paths);
// yield return CreateInvariantKit(3, 1, 2, paths); // middle child
// yield return CreateInvariantKit(4, 1, 3, paths);
// }
//
// InitializedCache(GetKits(), _contentTypes);
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// Assert.AreEqual(1, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// var parentNode = contentStore.Test.GetValues(1)[0];
// Assert.AreEqual(1, parentNode.gen);
// AssertLinkedNode(parentNode.contentNode, -1, -1, -1, 2, 4);
//
// var child1 = contentStore.Test.GetValues(2)[0];
// Assert.AreEqual(1, child1.gen);
// AssertLinkedNode(child1.contentNode, 1, -1, 3, -1, -1);
//
// var child2 = contentStore.Test.GetValues(3)[0];
// Assert.AreEqual(1, child2.gen);
// AssertLinkedNode(child2.contentNode, 1, 2, 4, -1, -1);
//
// var child3 = contentStore.Test.GetValues(4)[0];
// Assert.AreEqual(1, child3.gen);
// AssertLinkedNode(child3.contentNode, 1, 3, -1, -1, -1);
//
// // This will set a flag to force creating a new Gen next time the store is locked (i.e. In Notify)
// contentStore.CreateSnapshot();
//
// Assert.IsFalse(contentStore.Test.NextGen);
//
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload() // remove middle child
// {
// Id = 3,
// ChangeTypes = TreeChangeTypes.Remove
// }
// },
// out _,
// out _);
//
// Assert.AreEqual(2, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// var parentNodes = contentStore.Test.GetValues(1);
// Assert.AreEqual(1, parentNodes.Length); // the parent doesn't get changed, not new gen's are added
// parentNode = parentNodes[0];
// Assert.AreEqual(1, parentNode.gen); // the parent node's gen has not changed
// AssertLinkedNode(parentNode.contentNode, -1, -1, -1, 2, 4);
//
// child1 = contentStore.Test.GetValues(2)[0];
// Assert.AreEqual(2, child1.gen); // there is now 2x gen's of this item
// AssertLinkedNode(child1.contentNode, 1, -1, 4, -1, -1);
//
// child2 = contentStore.Test.GetValues(3)[0];
// Assert.AreEqual(2, child2.gen); // there is now 2x gen's of this item
// Assert.IsNull(child2.contentNode); // because it doesn't exist anymore
//
// child3 = contentStore.Test.GetValues(4)[0];
// Assert.AreEqual(2, child3.gen); // there is now 2x gen's of this item
// AssertLinkedNode(child3.contentNode, 1, 2, -1, -1, -1);
// }
//
// [Test]
// public void Refresh_Node_Ensures_Linked_list()
// {
// // NOTE: these tests are not using real scopes, in which case a Scope does not control
// // how the snapshots generations work. We are forcing new snapshot generations manually.
// IEnumerable<ContentNodeKit> GetKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// // root
// yield return CreateInvariantKit(100, -1, 1, paths);
//
// // site
// yield return CreateInvariantKit(2, 100, 1, paths);
// yield return CreateInvariantKit(1, 100, 2, paths); // middle child
// yield return CreateInvariantKit(3, 100, 3, paths);
//
// // children of 1
// yield return CreateInvariantKit(20, 1, 1, paths);
// yield return CreateInvariantKit(30, 1, 2, paths);
// yield return CreateInvariantKit(40, 1, 3, paths);
// }
//
// InitializedCache(GetKits(), _contentTypes);
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// Assert.AreEqual(1, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// var middleNode = contentStore.Test.GetValues(1)[0];
// Assert.AreEqual(1, middleNode.gen);
// AssertLinkedNode(middleNode.contentNode, 100, 2, 3, 20, 40);
//
// // This will set a flag to force creating a new Gen next time the store is locked (i.e. In Notify)
// contentStore.CreateSnapshot();
//
// Assert.IsFalse(contentStore.Test.NextGen);
//
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 1,
// ChangeTypes = TreeChangeTypes.RefreshNode
// }
// },
// out _,
// out _);
//
// Assert.AreEqual(2, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// middleNode = contentStore.Test.GetValues(1)[0];
// Assert.AreEqual(2, middleNode.gen);
// AssertLinkedNode(middleNode.contentNode, 100, 2, 3, 20, 40);
// }
//
// /// <summary>
// /// This addresses issue: https://github.com/umbraco/Umbraco-CMS/issues/6698
// /// </summary>
// /// <remarks>
// /// This test mimics if someone were to:
// /// 1) Unpublish a "middle child"
// /// 2) Save and publish it
// /// 3) Publish it with descendants
// /// 4) Repeat steps 2 and 3
// /// Which has caused an exception. To replicate this test:
// /// 1) RefreshBranch with kits for a branch where the top most node is unpublished
// /// 2) RefreshBranch with kits for the branch where the top most node is published
// /// 3) RefreshBranch with kits for the branch where the top most node is published
// /// 4) RefreshNode
// /// 5) RefreshBranch with kits for the branch where the top most node is published
// /// </remarks>
// [Test]
// public void Refresh_Branch_With_Alternating_Publish_Flags()
// {
// // NOTE: these tests are not using real scopes, in which case a Scope does not control
// // how the snapshots generations work. We are forcing new snapshot generations manually.
// IEnumerable<ContentNodeKit> GetKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// // root
// yield return CreateInvariantKit(100, -1, 1, paths);
//
// // site
// yield return CreateInvariantKit(2, 100, 1, paths);
// yield return CreateInvariantKit(1, 100, 2, paths); // middle child
// yield return CreateInvariantKit(3, 100, 3, paths);
//
// // children of 1
// yield return CreateInvariantKit(20, 1, 1, paths);
// yield return CreateInvariantKit(30, 1, 2, paths);
// yield return CreateInvariantKit(40, 1, 3, paths);
// }
//
// // init with all published
// InitializedCache(GetKits(), _contentTypes);
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// var rootKit = NuCacheContentService.ContentKits[1].Clone(PublishedModelFactory);
//
// void ChangePublishFlagOfRoot(bool published, int assertGen, TreeChangeTypes changeType)
// {
// // This will set a flag to force creating a new Gen next time the store is locked (i.e. In Notify)
// contentStore.CreateSnapshot();
//
// Assert.IsFalse(contentStore.Test.NextGen);
//
// // Change the root publish flag
// var kit = rootKit.Clone(
// PublishedModelFactory,
// published ? null : rootKit.PublishedData,
// published ? rootKit.PublishedData : null);
// NuCacheContentService.ContentKits[1] = kit;
//
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload()
// {
// Id = 1,
// ChangeTypes = changeType
// }
// },
// out _,
// out _);
//
// Assert.AreEqual(assertGen, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// // get the latest gen for content Id 1
// var (gen, contentNode) = contentStore.Test.GetValues(1)[0];
// Assert.AreEqual(assertGen, gen);
//
// // even when unpublishing/re-publishing/etc... the linked list is always maintained
// AssertLinkedNode(contentNode, 100, 2, 3, 20, 40);
// }
//
// // unpublish the root
// ChangePublishFlagOfRoot(false, 2, TreeChangeTypes.RefreshBranch);
//
// // publish the root (since it's not published, it will cause a RefreshBranch)
// ChangePublishFlagOfRoot(true, 3, TreeChangeTypes.RefreshBranch);
//
// // publish root + descendants
// ChangePublishFlagOfRoot(true, 4, TreeChangeTypes.RefreshBranch);
//
// // save/publish the root (since it's already published, it will just cause a RefreshNode
// ChangePublishFlagOfRoot(true, 5, TreeChangeTypes.RefreshNode);
//
// // publish root + descendants
// ChangePublishFlagOfRoot(true, 6, TreeChangeTypes.RefreshBranch);
// }
//
// [Test]
// public void Refresh_Branch_Ensures_Linked_List()
// {
// // NOTE: these tests are not using real scopes, in which case a Scope does not control
// // how the snapshots generations work. We are forcing new snapshot generations manually.
// IEnumerable<ContentNodeKit> GetKits()
// {
// var paths = new Dictionary<int, string> { { -1, "-1" } };
//
// // root
// yield return CreateInvariantKit(1, -1, 1, paths);
//
// // children
// yield return CreateInvariantKit(2, 1, 1, paths);
// yield return CreateInvariantKit(3, 1, 2, paths); // middle child
// yield return CreateInvariantKit(4, 1, 3, paths);
// }
//
// InitializedCache(GetKits(), _contentTypes);
//
// var snapshotService = (PublishedSnapshotService)SnapshotService;
// var contentStore = snapshotService.GetContentStore();
//
// Assert.AreEqual(1, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// var parentNode = contentStore.Test.GetValues(1)[0];
// Assert.AreEqual(1, parentNode.gen);
// AssertLinkedNode(parentNode.contentNode, -1, -1, -1, 2, 4);
//
// var child1 = contentStore.Test.GetValues(2)[0];
// Assert.AreEqual(1, child1.gen);
// AssertLinkedNode(child1.contentNode, 1, -1, 3, -1, -1);
//
// var child2 = contentStore.Test.GetValues(3)[0];
// Assert.AreEqual(1, child2.gen);
// AssertLinkedNode(child2.contentNode, 1, 2, 4, -1, -1);
//
// var child3 = contentStore.Test.GetValues(4)[0];
// Assert.AreEqual(1, child3.gen);
// AssertLinkedNode(child3.contentNode, 1, 3, -1, -1, -1);
//
// // This will set a flag to force creating a new Gen next time the store is locked (i.e. In Notify)
// contentStore.CreateSnapshot();
//
// Assert.IsFalse(contentStore.Test.NextGen);
//
// SnapshotService.Notify(
// new[]
// {
// new ContentCacheRefresher.JsonPayload() // remove middle child
// {
// Id = 3,
// ChangeTypes = TreeChangeTypes.RefreshBranch
// }
// },
// out _,
// out _);
//
// Assert.AreEqual(2, contentStore.Test.LiveGen);
// Assert.IsTrue(contentStore.Test.NextGen);
//
// var parentNodes = contentStore.Test.GetValues(1);
// Assert.AreEqual(1, parentNodes.Length); // the parent doesn't get changed, not new gen's are added
// parentNode = parentNodes[0];
// Assert.AreEqual(1, parentNode.gen); // the parent node's gen has not changed
// AssertLinkedNode(parentNode.contentNode, -1, -1, -1, 2, 4);
//
// child1 = contentStore.Test.GetValues(2)[0];
// Assert.AreEqual(2, child1.gen); // there is now 2x gen's of this item
// AssertLinkedNode(child1.contentNode, 1, -1, 3, -1, -1);
//
// child2 = contentStore.Test.GetValues(3)[0];
// Assert.AreEqual(2, child2.gen); // there is now 2x gen's of this item
// AssertLinkedNode(child2.contentNode, 1, 2, 4, -1, -1);
//
// child3 = contentStore.Test.GetValues(4)[0];
// Assert.AreEqual(2, child3.gen); // there is now 2x gen's of this item
// AssertLinkedNode(child3.contentNode, 1, 3, -1, -1, -1);
// }
//
// [Test]
// public void MultipleCacheIteration()
// {
// // see https://github.com/umbraco/Umbraco-CMS/issues/7798
// InitializedCache(GetInvariantKits(), _contentTypes);
// var snapshot = GetPublishedSnapshot();
//
// var items = snapshot.Content.GetAtRoot().Where(x => x.ContentType.Alias == "itype").ToArray();
// Assert.AreEqual(items.Length, items.Length);
// }
//
// private void AssertLinkedNode(ContentNode node, int parent, int prevSibling, int nextSibling, int firstChild, int lastChild)
// {
// Assert.AreEqual(parent, node.ParentContentId);
// Assert.AreEqual(prevSibling, node.PreviousSiblingContentId);
// Assert.AreEqual(nextSibling, node.NextSiblingContentId);
// Assert.AreEqual(firstChild, node.FirstChildContentId);
// Assert.AreEqual(lastChild, node.LastChildContentId);
// }
//
// private void AssertDocuments(IPublishedContent[] documents, params string[] names)
// {
// Assert.AreEqual(names.Length, documents.Length);
// for (var i = 0; i < names.Length; i++)
// {
// Assert.AreEqual(names[i], documents[i].Name);
// }
// }
//
// private void AssertDocuments(string culture, IPublishedContent[] documents, params string[] names)
// {
// Assert.AreEqual(names.Length, documents.Length);
// for (var i = 0; i < names.Length; i++)
// {
// Assert.AreEqual(names[i], documents[i].Name(VariationContextAccessor, culture));
// }
// }
// }
Reference in New Issue View Git Blame Copy Permalink