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(2, Guid.Empty, TreeChangeTypes.Remove) }, out _, out _); parentNodes = contentStore.Test.GetValues(1); parentNode = parentNodes[0]; AssertLinkedNode(parentNode.contentNode, -1, -1, -1, -1, -1); }
public DatabaseFixture() { Secret = "KeGPyghP5CSoSwPpzkBvKG2k"; InstanceName = "Hawkeye"; DbContextOptions <ExilenceContext> options; var builder = new DbContextOptionsBuilder <ExilenceContext>(); builder.UseInMemoryDatabase("Exilence"); options = builder.Options; var mockMapper = new MapperConfiguration(cfg => { cfg.AddProfile(new AccountProfileMapper()); cfg.AddProfile(new CharacterProfileMapper()); cfg.AddProfile(new ConnectionProfileMapper()); cfg.AddProfile(new GroupProfileMapper()); cfg.AddProfile(new LeagueProfileMapper()); cfg.AddProfile(new PricedItemProfileMapper()); cfg.AddProfile(new SnapshotProfileMapper()); cfg.AddProfile(new SnapshotProfileProfileMapper()); cfg.AddProfile(new StashtabProfileMapper()); }); var mapper = mockMapper.CreateMapper(); var context = new ExilenceContext(options); var accountRepository = new AccountRepository(context); var snapshotRepository = new SnapshotRepository(context); var groupRepository = new GroupRepository(context); AccountService = new AccountService(snapshotRepository, accountRepository, mapper); SnapshotService = new SnapshotService(snapshotRepository, accountRepository, mapper); GroupService = new GroupService(groupRepository, accountRepository, mapper); }
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(1, Guid.Empty, 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); }
public static async Task Main() { BuildConfigRoot(); BuildServiceProvider(); snapshotService = serviceProvider.GetService <SnapshotService>(); logger = serviceProvider.GetService <Logger>(); await TryCaptureSnapshots(); }
/// <summary> /// Creates internal services. /// </summary> private void createServices() { LoadService = new LoadService(this); ProtocolService = new ProtocolService(this, LoadService); MessagingService = new MessagingService(this); ProtocolReplicationService = new ProtocolReplicationService(this); SnapshotService = new SnapshotService(this); PackService = new PackService(this); }
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(1, Guid.Empty, 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); }
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(kit.Node.ParentContentId, Guid.Empty, 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"); }
public static async Task Main() { BuildConfigRoot(); BuildServiceProvider(); snapshotService = serviceProvider.GetService <SnapshotService>(); using (logger = new Logger(configRoot[AppInsightsKeyConfig])) { await CaptureSnapshots(BatchSize); } }
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(3, Guid.Empty, TreeChangeTypes.Remove), // remove last new ContentCacheRefresher.JsonPayload(5, Guid.Empty, TreeChangeTypes.Remove), // remove middle new ContentCacheRefresher.JsonPayload(9, Guid.Empty, TreeChangeTypes.Remove), // remove first }, 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(1, Guid.Empty, TreeChangeTypes.Remove), // remove first new ContentCacheRefresher.JsonPayload(8, Guid.Empty, TreeChangeTypes.Remove), // remove new ContentCacheRefresher.JsonPayload(7, Guid.Empty, TreeChangeTypes.Remove), // remove }, out _, out _); documents = snapshot.Content.GetAtRoot().ToArray(); AssertDocuments(documents, "N2"); documents = snapshot.Content.GetById(2).Children(VariationContextAccessor).ToArray(); AssertDocuments(documents); }
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(1, Guid.Empty, TreeChangeTypes.RefreshBranch), new ContentCacheRefresher.JsonPayload(2, Guid.Empty, 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"); }
public void ShouldGetAllSnapshots() { var snapshots = GetTestSnapshots(); var snapshotRepository = new Mock<ISnapshotRepository>(); snapshotRepository.Setup(rep => rep.GetSnapshots()).Returns(snapshots); var service = new SnapshotService(snapshotRepository.Object); var returnedSnapshots = service.GetSnapshots(); Assert.AreEqual(2, returnedSnapshots.Count, "There should be 2 snapshots."); Assert.AreEqual(1, returnedSnapshots.Count(shot => shot.Name == "first"), "There should be a snapshot called first"); Assert.AreEqual(1, returnedSnapshots.Count(shot => shot.Name == "second"), "There should be a snapshot called second"); }
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(4, Guid.Empty, 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(4, Guid.Empty, TreeChangeTypes.RefreshBranch) }, out _, out _)); }
public static async Task Main(string[] args) { var mapDAO = new MapDAO(Constants.MapSQLConnection); var logDAO = new LogDAO(Constants.NOSQLConnection); var userDAO = new UserDAO(Constants.SQLConnection); var uploadDAO = new UploadDAO(Constants.SQLConnection); var snapshotDAO = new SnapshotDAO(Constants.NOSQLConnection); var maskService = new MaskingService(mapDAO); var ffLoggingService = new FlatFileLoggingService(maskService); var dsLoggingService = new DataStoreLoggingService(logDAO, maskService); var snapshotService = new SnapshotService(logDAO, userDAO, uploadDAO, snapshotDAO); var loggingManager = new LoggingManager(ffLoggingService, dsLoggingService); var createSnapManager = new CreateSnapshotManager(loggingManager, snapshotService); // Script called at the beginning of every month. // Get the year and month according the Utc time. var year = DateTime.UtcNow.Year; var month = DateTime.UtcNow.Month; // We want to create a snapshot of the previous month so we have to subtract 1 to the month if it is not 1 (January). // If it is 1, then change month to 12, and subtract 1 from year instead. if (month == 1) { year = year - 1; month = 12; } else { month = month - 1; } var tries = 0; var createSnapshotSuccess = false; // If the createsnapshot was a failure, there are 3 extra tries. It can stop if it was successful though. while (!createSnapshotSuccess && tries < 4) { createSnapshotSuccess = await createSnapManager.CreateSnapshotAsync(tries, year, month).ConfigureAwait(false); if (!createSnapshotSuccess) { tries++; } } }
public void ShouldDeleteSnapshots() { var snapshots = GetTestSnapshots(); var initialSnapshotsCount = snapshots.Count; var snapshotRepository = new Mock<ISnapshotRepository>(); snapshotRepository.Setup(rep => rep.GetSnapshots()).Returns(snapshots); snapshotRepository.Setup(rep => rep.Delete(It.IsAny<string>())) .Callback((string name) => snapshots.Remove(snapshots.First(shot => shot.Name == name))); var service = new SnapshotService(snapshotRepository.Object); var nameToDelete = "second"; service.DeleteSnapshot(snapshots.First(shot => shot.Name == nameToDelete)); Assert.AreEqual(initialSnapshotsCount - 1, snapshots.Count, "There should be one less snapshot after deletion."); Assert.AreEqual(0, service.GetSnapshots().Count(shot => shot.Name == nameToDelete), string.Format("The snapshot named {0} should have been deleted", nameToDelete)); }
public void Setup() { _ms = new MemoryStream(); _memoryDb = new LiteDatabase(_ms); _userCollection = _memoryDb.GetCollection <MiningMonitorUser>(); _userStoreLogger = new Mock <ILogger <MiningMonitorUserStore> >(); _userStore = new MiningMonitorUserStore(new LiteDbRepository <MiningMonitorUser, Guid>(_userCollection), _userStoreLogger.Object); _optionsAccessor = new Mock <IOptions <IdentityOptions> >(); _passwordHasher = new Mock <IPasswordHasher <MiningMonitorUser> >(); _normalizer = new Mock <ILookupNormalizer>(); _serviceProvider = new Mock <IServiceProvider>(); _userManagerLogger = new Mock <ILogger <UserManager <MiningMonitorUser> > >(); _userManager = new UserManager <MiningMonitorUser>(_userStore, _optionsAccessor.Object, _passwordHasher.Object, Enumerable.Empty <IUserValidator <MiningMonitorUser> >(), Enumerable.Empty <IPasswordValidator <MiningMonitorUser> >(), _normalizer.Object, new IdentityErrorDescriber(), _serviceProvider.Object, _userManagerLogger.Object); _httpContextAccessor = new Mock <IHttpContextAccessor>(); _signinManagerLogger = new Mock <ILogger <SignInManager <MiningMonitorUser> > >(); _userFactory = new Mock <IUserClaimsPrincipalFactory <MiningMonitorUser> >(); _authSchemeProvider = new Mock <IAuthenticationSchemeProvider>(); _signinManager = new SignInManager <MiningMonitorUser>(_userManager, _httpContextAccessor.Object, _userFactory.Object, _optionsAccessor.Object, _signinManagerLogger.Object, _authSchemeProvider.Object); _loginService = new LoginService(_signinManager); _snapshotCollection = _memoryDb.GetCollection <Snapshot>(); _snapshotService = new SnapshotService(new LiteDbRepository <Snapshot, Guid>(_snapshotCollection)); _minerCollection = _memoryDb.GetCollection <Miner>(); _minerService = new MinerService(new LiteDbRepository <Miner, Guid>(_minerCollection), _snapshotService); _userMapper = new UserMapper(); _resultMapper = new IdentityResultMapper(); _subject = new CollectorService(_userManager, _loginService, _minerService, _snapshotService, _userMapper, _userMapper, _resultMapper); }
public IHttpActionResult MonthlySnapshots(DateTime?startDate = null, DateTime?endDate = null) { //var account = GetLogInAccount(); var groupOwner = GetGroupOwnerAccount(); var snapshots = SnapshotService.GetMonthlySnapshots(groupOwner); if (startDate.HasValue) { snapshots = snapshots.Where(s => s.DateTaken >= startDate.Value.ToLocalTime()); } if (endDate.HasValue) { // one day is added to the end date to ignore the actual time. snapshots = snapshots.Where(s => s.DateTaken <= endDate.Value.ToLocalTime().AddDays(1)); } return(Ok(snapshots.ToList().ToApiModel())); }
private void InitCache() { cacheMgr = (CacheManager)CacheFactory.GetCacheManager(); //string file = Path.Combine(HttpRuntime.AppDomainAppPath, "stateserver.state"); //Stream s = null; //try //{ // if (File.Exists(file)) // { // log.Debug("Analyzing StateServer persistance..."); // s = File.Open(file, FileMode.Open); // BinaryFormatter bf = new BinaryFormatter(); // List<LineControl> lineControls = (List<LineControl>)bf.Deserialize(s); // log.Debug(lineControls.Count + " lines retreived..."); foreach (LineControl lc in SnapshotService.GetSnapshot()) { log.Debug("Adding " + lc.directoryNumber + " to the cache."); cacheMgr.Add(lc.directoryNumber, lc); } // s.Close(); // s.Dispose(); // } //} //catch (Exception ex) //{ // log.Error("Unable to initialize cache: " + ex.Message); //} //finally //{ // if (s != null) // { // s.Close(); // s.Dispose(); // } //} }
public void Verifies_Variant_Data() { // this test implements a full standalone NuCache (based upon a test IDataSource, does not // use any local db files, does not rely on any database) - and tests variations // get a snapshot, get a published content IPublishedSnapshot snapshot = GetPublishedSnapshot(); IPublishedContent publishedContent = snapshot.Content.GetById(1); Assert.IsNotNull(publishedContent); Assert.AreEqual("val1", publishedContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop")); Assert.AreEqual("val-fr1", publishedContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop", "fr-FR")); Assert.AreEqual("val-uk1", publishedContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop", "en-UK")); Assert.IsNull(publishedContent.Name(VariationContextAccessor)); // no invariant name for varying content Assert.AreEqual("name-fr1", publishedContent.Name(VariationContextAccessor, "fr-FR")); Assert.AreEqual("name-uk1", publishedContent.Name(VariationContextAccessor, "en-UK")); var draftContent = snapshot.Content.GetById(true, 1); Assert.AreEqual("val2", draftContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop")); Assert.AreEqual("val-fr2", draftContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop", "fr-FR")); Assert.AreEqual("val-uk2", draftContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop", "en-UK")); Assert.IsNull(draftContent.Name(VariationContextAccessor)); // no invariant name for varying content Assert.AreEqual("name-fr2", draftContent.Name(VariationContextAccessor, "fr-FR")); Assert.AreEqual("name-uk2", draftContent.Name(VariationContextAccessor, "en-UK")); // now french is default VariationContextAccessor.VariationContext = new VariationContext("fr-FR"); Assert.AreEqual("val-fr1", publishedContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop")); Assert.AreEqual("name-fr1", publishedContent.Name(VariationContextAccessor)); Assert.AreEqual(new DateTime(2018, 01, 01, 01, 00, 00), publishedContent.CultureDate(VariationContextAccessor)); // now uk is default VariationContextAccessor.VariationContext = new VariationContext("en-UK"); Assert.AreEqual("val-uk1", publishedContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop")); Assert.AreEqual("name-uk1", publishedContent.Name(VariationContextAccessor)); Assert.AreEqual(new DateTime(2018, 01, 02, 01, 00, 00), publishedContent.CultureDate(VariationContextAccessor)); // invariant needs to be retrieved explicitly, when it's not default Assert.AreEqual("val1", publishedContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop", culture: "")); // but, // if the content type / property type does not vary, then it's all invariant again // modify the content type and property type, notify the snapshot service _contentType.Variations = ContentVariation.Nothing; _propertyType.Variations = ContentVariation.Nothing; SnapshotService.Notify(new[] { new ContentTypeCacheRefresher.JsonPayload("IContentType", publishedContent.ContentType.Id, ContentTypeChangeTypes.RefreshMain) }); // get a new snapshot (nothing changed in the old one), get the published content again var anotherSnapshot = SnapshotService.CreatePublishedSnapshot(previewToken: null); var againContent = anotherSnapshot.Content.GetById(1); Assert.AreEqual(ContentVariation.Nothing, againContent.ContentType.Variations); Assert.AreEqual(ContentVariation.Nothing, againContent.ContentType.GetPropertyType("prop").Variations); // now, "no culture" means "invariant" Assert.AreEqual("It Works1!", againContent.Name(VariationContextAccessor)); Assert.AreEqual("val1", againContent.Value <string>(Mock.Of <IPublishedValueFallback>(), "prop")); }
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(3, Guid.Empty, TreeChangeTypes.Remove), // remove middle child }, 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); }
public void GetSnapshot(int snapshotId) { var snapShotService = new SnapshotService(); this.Snapshot = snapShotService.GetSnapshot(snapshotId); }
public void Teardown() => SnapshotService?.Dispose();
public MainViewModel() { var snapShotService = new SnapshotService(); this.Snapshots = snapShotService.GetSnapshots(); }
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(2, Guid.Empty, TreeChangeTypes.RefreshBranch), new ContentCacheRefresher.JsonPayload(1, Guid.Empty, 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); }
public CreateSnapshotManager(LoggingManager loggingManager, SnapshotService snapshotService) { _loggingManager = loggingManager; _snapshotService = snapshotService; }
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(1, Guid.Empty, 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); }