public void CanHandleEvent() { // refreshers.HandleEvents wants a UmbracoContext // which wants an HttpContext, which we build using a SimpleWorkerRequest // which requires these to be non-null var domain = Thread.GetDomain(); if (domain.GetData(".appPath") == null) { domain.SetData(".appPath", ""); } if (domain.GetData(".appVPath") == null) { domain.SetData(".appVPath", ""); } // create some event definitions var definitions = new IEventDefinition[] { // works because that event definition maps to an empty handler new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, Current.Services.ContentTypeService, new SaveEventArgs <IContentType>(Enumerable.Empty <IContentType>()), "Saved"), }; // just assert it does not throw var refreshers = new DistributedCacheBinder(null, null); refreshers.HandleEvents(definitions); }
public void Teardown() { _distributedCacheBinder?.UnbindEvents(); _distributedCacheBinder = null; _onPublishedAssertAction = null; ContentService.Published -= OnPublishedAssert; SafeXmlReaderWriter.Cloning = null; }
public override void TearDown() { base.TearDown(); _distributedCacheBinder?.UnbindEvents(); _distributedCacheBinder = null; _onPublishedAssertAction = null; ContentService.Published -= OnPublishedAssert; }
public void OnlyHandlesOnContentTypeEvent() { var definitions = new IEventDefinition[] { new EventDefinition <IContentTypeService, ContentTypeChange <IContentType> .EventArgs>(null, Current.Services.ContentTypeService, new ContentTypeChange <IContentType> .EventArgs(Enumerable.Empty <ContentTypeChange <IContentType> >()), "Changed"), new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, Current.Services.ContentTypeService, new SaveEventArgs <IContentType>(Enumerable.Empty <IContentType>()), "Saved"), new EventDefinition <IContentTypeService, ContentTypeChange <IContentType> .EventArgs>(null, Current.Services.ContentTypeService, new ContentTypeChange <IContentType> .EventArgs(Enumerable.Empty <ContentTypeChange <IContentType> >()), "Changed"), new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, Current.Services.ContentTypeService, new SaveEventArgs <IContentType>(Enumerable.Empty <IContentType>()), "Saved"), }; var result = DistributedCacheBinder.GetReducedEventList(definitions); Assert.AreEqual(1, result.Count()); }
public void CanHandleEvent() { // refreshers.HandleEvents wants a UmbracoContext // which wants an HttpContext, which we build using a SimpleWorkerRequest // which requires these to be non-null var domain = Thread.GetDomain(); if (domain.GetData(".appPath") == null) { domain.SetData(".appPath", ""); } if (domain.GetData(".appVPath") == null) { domain.SetData(".appVPath", ""); } // create some event definitions var definitions = new IEventDefinition[] { // works because that event definition maps to an empty handler new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, Current.Services.ContentTypeService, new SaveEventArgs <IContentType>(Enumerable.Empty <IContentType>()), "Saved"), }; var umbracoContextFactory = new UmbracoContextFactory( new TestUmbracoContextAccessor(), Mock.Of <IPublishedSnapshotService>(), new TestVariationContextAccessor(), new TestDefaultCultureAccessor(), TestObjects.GetUmbracoSettings(), TestObjects.GetGlobalSettings(), new UrlProviderCollection(Enumerable.Empty <IUrlProvider>()), new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>()), Mock.Of <IUserService>()); // just assert it does not throw var refreshers = new DistributedCacheBinder(null, umbracoContextFactory, null); refreshers.HandleEvents(definitions); }
public void TestScope(bool complete) { var umbracoContext = GetUmbracoContextNu("http://example.com/", setSingleton: true); // wire cache refresher _distributedCacheBinder = new DistributedCacheBinder(new DistributedCache(), Mock.Of <IUmbracoContextFactory>(), Mock.Of <ILogger>()); _distributedCacheBinder.BindEvents(true); // create document type, document var contentType = new ContentType(-1) { Alias = "CustomDocument", Name = "Custom Document" }; Current.Services.ContentTypeService.Save(contentType); var item = new Content("name", -1, contentType); // event handler var evented = 0; _onPublishedAssertAction = () => { evented++; var e = umbracoContext.Content.GetById(item.Id); // during events, due to LiveSnapshot, we see the changes Assert.IsNotNull(e); Assert.AreEqual("changed", e.Name()); }; using (var scope = ScopeProvider.CreateScope()) { Current.Services.ContentService.SaveAndPublish(item); scope.Complete(); } // been created var x = umbracoContext.Content.GetById(item.Id); Assert.IsNotNull(x); Assert.AreEqual("name", x.Name()); ContentService.Published += OnPublishedAssert; using (var scope = ScopeProvider.CreateScope()) { item.Name = "changed"; Current.Services.ContentService.SaveAndPublish(item); if (complete) { scope.Complete(); } } // only 1 event occuring because we are publishing twice for the same event for // the same object and the scope deduplicates the events (uses the latest) Assert.AreEqual(complete ? 1 : 0, evented); // after the scope, // if completed, we see the changes // else changes have been rolled back x = umbracoContext.Content.GetById(item.Id); Assert.IsNotNull(x); Assert.AreEqual(complete ? "changed" : "name", x.Name()); }
public void TestScope(bool complete) { var umbracoContext = GetUmbracoContext("http://example.com/", setSingleton: true); // sanity checks Assert.AreSame(umbracoContext, Umbraco.Web.Composing.Current.UmbracoContext); Assert.AreSame(XmlStore, ((PublishedContentCache)umbracoContext.ContentCache).XmlStore); // settings var contentMock = Mock.Get(Factory.GetInstance <IUmbracoSettingsSection>().Content); contentMock.Setup(x => x.XmlCacheEnabled).Returns(false); // create document type, document var contentType = new ContentType(-1) { Alias = "CustomDocument", Name = "Custom Document" }; Current.Services.ContentTypeService.Save(contentType); var item = new Content("name", -1, contentType); // wire cache refresher _distributedCacheBinder = new DistributedCacheBinder(new DistributedCache(), Mock.Of <ILogger>()); _distributedCacheBinder.BindEvents(true); // check xml in context = "before" var xml = XmlInContext; var beforeXml = xml; var beforeOuterXml = beforeXml.OuterXml; Console.WriteLine("Xml Before:"); Console.WriteLine(xml.OuterXml); // event handler var evented = 0; _onPublishedAssertAction = () => { evented++; // should see the changes in context, not in master xml = XmlInContext; Assert.AreNotSame(beforeXml, xml); Console.WriteLine("Xml Event:"); Console.WriteLine(xml.OuterXml); var node = xml.GetElementById(item.Id.ToString()); Assert.IsNotNull(node); xml = XmlMaster; Assert.AreSame(beforeXml, xml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); }; ContentService.Published += OnPublishedAssert; using (var scope = ScopeProvider.CreateScope()) { Current.Services.ContentService.SaveAndPublish(item); // should create an xml clone item.Name = "changed"; Current.Services.ContentService.SaveAndPublish(item); // should re-use the xml clone // this should never change Assert.AreEqual(beforeOuterXml, beforeXml.OuterXml); // this does not change, other thread don't see the changes xml = XmlMaster; Assert.AreSame(beforeXml, xml); Console.WriteLine("XmlInternal During:"); Console.WriteLine(xml.OuterXml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); // this does not change during the scope (only in events) // because it is the events that trigger the changes xml = XmlInContext; Assert.IsNotNull(xml); Assert.AreSame(beforeXml, xml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); // note // this means that, as long as ppl don't create scopes, they'll see their // changes right after SaveAndPublish, but if they create scopes, // they will have to wail until the scope is completed, ie wait until the // events trigger, to use eg GetUrl etc if (complete) { scope.Complete(); } } //The reason why there is only 1 event occuring is because we are publishing twice for the same event for the same //object and the scope deduplicates the events(uses the latest) Assert.AreEqual(complete? 1 : 0, evented); // this should never change Assert.AreEqual(beforeOuterXml, beforeXml.OuterXml); xml = XmlInContext; Console.WriteLine("Xml After:"); Console.WriteLine(xml.OuterXml); if (complete) { var node = xml.GetElementById(item.Id.ToString()); Assert.IsNotNull(node); } else { Assert.AreSame(beforeXml, xml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); // nothing has changed! } xml = XmlMaster; if (complete) { var node = xml.GetElementById(item.Id.ToString()); Assert.IsNotNull(node); } else { Assert.AreSame(beforeXml, xml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); // nothing has changed! } }
public void TestScopeMany(bool complete) { var umbracoContext = GetUmbracoContext("http://example.com/", setSingleton: true); // sanity checks Assert.AreSame(umbracoContext, Umbraco.Web.Composing.Current.UmbracoContext); Assert.AreSame(XmlStore, ((PublishedContentCache)umbracoContext.ContentCache).XmlStore); // settings var settings = SettingsForTests.GenerateMockUmbracoSettings(); var contentMock = Mock.Get(Factory.GetInstance <IUmbracoSettingsSection>().Content); contentMock.Setup(x => x.XmlCacheEnabled).Returns(false); // create document type var contentType = new ContentType(-1) { Alias = "CustomDocument", Name = "Custom Document" }; Current.Services.ContentTypeService.Save(contentType); // wire cache refresher _distributedCacheBinder = new DistributedCacheBinder(new DistributedCache(), Mock.Of <ILogger>()); _distributedCacheBinder.BindEvents(true); // check xml in context = "before" var xml = XmlInContext; var beforeXml = xml; var beforeOuterXml = beforeXml.OuterXml; var item = new Content("name", -1, contentType); const int count = 10; var ids = new int[count]; var clones = 0; SafeXmlReaderWriter.Cloning = () => { clones++; }; Console.WriteLine("Xml Before:"); Console.WriteLine(xml.OuterXml); using (var scope = ScopeProvider.CreateScope()) { Current.Services.ContentService.SaveAndPublish(item); for (var i = 0; i < count; i++) { var temp = new Content("content_" + i, -1, contentType); Current.Services.ContentService.SaveAndPublish(temp); ids[i] = temp.Id; } // this should never change Assert.AreEqual(beforeOuterXml, beforeXml.OuterXml); xml = XmlMaster; Assert.IsNotNull(xml); Console.WriteLine("Xml InScope (before complete):"); Console.WriteLine(xml.OuterXml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); if (complete) { scope.Complete(); } xml = XmlMaster; Assert.IsNotNull(xml); Console.WriteLine("Xml InScope (after complete):"); Console.WriteLine(xml.OuterXml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); } var scopeProvider = ScopeProvider; Assert.IsNotNull(scopeProvider); // ambient scope may be null, or maybe not, depending on whether the code that // was called did proper scoped work, or some direct (NoScope) use of the database Assert.IsNull(scopeProvider.AmbientContext); // limited number of clones! Assert.AreEqual(complete ? 1 : 0, clones); // this should never change Assert.AreEqual(beforeOuterXml, beforeXml.OuterXml); xml = XmlMaster; Assert.IsNotNull(xml); Console.WriteLine("Xml After:"); Console.WriteLine(xml.OuterXml); if (complete) { var node = xml.GetElementById(item.Id.ToString()); Assert.IsNotNull(node); for (var i = 0; i < 10; i++) { node = xml.GetElementById(ids[i].ToString()); Assert.IsNotNull(node); } } else { Assert.AreEqual(beforeOuterXml, xml.OuterXml); // nothing has changed! } }
public void Can_Find_All_Event_Handlers() { // FIXME: cannot work with mocks // because the events are defined on actual static classes, not on the interfaces, so name matching fails // we should really refactor events entirely - in the meantime, let it be an UmbracoTestBase ;( //var testObjects = new TestObjects(null); //var serviceContext = testObjects.GetServiceContextMock(); var serviceContext = Current.Services; var definitions = new IEventDefinition[] { //I would test these but they are legacy events and we don't need them for deploy, when we migrate to new/better events we can wire up the check //Permission.New += PermissionNew; //Permission.Updated += PermissionUpdated; //Permission.Deleted += PermissionDeleted; //PermissionRepository<IContent>.AssignedPermissions += CacheRefresherEventHandler_AssignedPermissions; new EventDefinition <IUserService, SaveEventArgs <IUser> >(null, serviceContext.UserService, new SaveEventArgs <IUser>(Enumerable.Empty <IUser>())), new EventDefinition <IUserService, DeleteEventArgs <IUser> >(null, serviceContext.UserService, new DeleteEventArgs <IUser>(Enumerable.Empty <IUser>())), new EventDefinition <IUserService, SaveEventArgs <UserGroupWithUsers> >(null, serviceContext.UserService, new SaveEventArgs <UserGroupWithUsers>(Enumerable.Empty <UserGroupWithUsers>())), new EventDefinition <IUserService, DeleteEventArgs <IUserGroup> >(null, serviceContext.UserService, new DeleteEventArgs <IUserGroup>(Enumerable.Empty <IUserGroup>())), new EventDefinition <ILocalizationService, SaveEventArgs <IDictionaryItem> >(null, serviceContext.LocalizationService, new SaveEventArgs <IDictionaryItem>(Enumerable.Empty <IDictionaryItem>())), new EventDefinition <ILocalizationService, DeleteEventArgs <IDictionaryItem> >(null, serviceContext.LocalizationService, new DeleteEventArgs <IDictionaryItem>(Enumerable.Empty <IDictionaryItem>())), new EventDefinition <IDataTypeService, SaveEventArgs <IDataType> >(null, serviceContext.DataTypeService, new SaveEventArgs <IDataType>(Enumerable.Empty <IDataType>())), new EventDefinition <IDataTypeService, DeleteEventArgs <IDataType> >(null, serviceContext.DataTypeService, new DeleteEventArgs <IDataType>(Enumerable.Empty <IDataType>())), new EventDefinition <IFileService, SaveEventArgs <Stylesheet> >(null, serviceContext.FileService, new SaveEventArgs <Stylesheet>(Enumerable.Empty <Stylesheet>())), new EventDefinition <IFileService, DeleteEventArgs <Stylesheet> >(null, serviceContext.FileService, new DeleteEventArgs <Stylesheet>(Enumerable.Empty <Stylesheet>())), new EventDefinition <IDomainService, SaveEventArgs <IDomain> >(null, serviceContext.DomainService, new SaveEventArgs <IDomain>(Enumerable.Empty <IDomain>())), new EventDefinition <IDomainService, DeleteEventArgs <IDomain> >(null, serviceContext.DomainService, new DeleteEventArgs <IDomain>(Enumerable.Empty <IDomain>())), new EventDefinition <ILocalizationService, SaveEventArgs <ILanguage> >(null, serviceContext.LocalizationService, new SaveEventArgs <ILanguage>(Enumerable.Empty <ILanguage>())), new EventDefinition <ILocalizationService, DeleteEventArgs <ILanguage> >(null, serviceContext.LocalizationService, new DeleteEventArgs <ILanguage>(Enumerable.Empty <ILanguage>())), new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, serviceContext.ContentTypeService, new SaveEventArgs <IContentType>(Enumerable.Empty <IContentType>())), new EventDefinition <IContentTypeService, DeleteEventArgs <IContentType> >(null, serviceContext.ContentTypeService, new DeleteEventArgs <IContentType>(Enumerable.Empty <IContentType>())), new EventDefinition <IMediaTypeService, SaveEventArgs <IMediaType> >(null, serviceContext.MediaTypeService, new SaveEventArgs <IMediaType>(Enumerable.Empty <IMediaType>())), new EventDefinition <IMediaTypeService, DeleteEventArgs <IMediaType> >(null, serviceContext.MediaTypeService, new DeleteEventArgs <IMediaType>(Enumerable.Empty <IMediaType>())), new EventDefinition <IMemberTypeService, SaveEventArgs <IMemberType> >(null, serviceContext.MemberTypeService, new SaveEventArgs <IMemberType>(Enumerable.Empty <IMemberType>())), new EventDefinition <IMemberTypeService, DeleteEventArgs <IMemberType> >(null, serviceContext.MemberTypeService, new DeleteEventArgs <IMemberType>(Enumerable.Empty <IMemberType>())), new EventDefinition <IFileService, SaveEventArgs <ITemplate> >(null, serviceContext.FileService, new SaveEventArgs <ITemplate>(Enumerable.Empty <ITemplate>())), new EventDefinition <IFileService, DeleteEventArgs <ITemplate> >(null, serviceContext.FileService, new DeleteEventArgs <ITemplate>(Enumerable.Empty <ITemplate>())), new EventDefinition <IMacroService, SaveEventArgs <IMacro> >(null, serviceContext.MacroService, new SaveEventArgs <IMacro>(Enumerable.Empty <IMacro>())), new EventDefinition <IMacroService, DeleteEventArgs <IMacro> >(null, serviceContext.MacroService, new DeleteEventArgs <IMacro>(Enumerable.Empty <IMacro>())), new EventDefinition <IMemberService, SaveEventArgs <IMember> >(null, serviceContext.MemberService, new SaveEventArgs <IMember>(Enumerable.Empty <IMember>())), new EventDefinition <IMemberService, DeleteEventArgs <IMember> >(null, serviceContext.MemberService, new DeleteEventArgs <IMember>(Enumerable.Empty <IMember>())), new EventDefinition <IMemberGroupService, SaveEventArgs <IMemberGroup> >(null, serviceContext.MemberGroupService, new SaveEventArgs <IMemberGroup>(Enumerable.Empty <IMemberGroup>())), new EventDefinition <IMemberGroupService, DeleteEventArgs <IMemberGroup> >(null, serviceContext.MemberGroupService, new DeleteEventArgs <IMemberGroup>(Enumerable.Empty <IMemberGroup>())), new EventDefinition <IMediaService, SaveEventArgs <IMedia> >(null, serviceContext.MediaService, new SaveEventArgs <IMedia>(Enumerable.Empty <IMedia>())), new EventDefinition <IMediaService, DeleteEventArgs <IMedia> >(null, serviceContext.MediaService, new DeleteEventArgs <IMedia>(Enumerable.Empty <IMedia>())), new EventDefinition <IMediaService, MoveEventArgs <IMedia> >(null, serviceContext.MediaService, new MoveEventArgs <IMedia>(new MoveEventInfo <IMedia>(null, "", -1)), "Moved"), new EventDefinition <IMediaService, MoveEventArgs <IMedia> >(null, serviceContext.MediaService, new MoveEventArgs <IMedia>(new MoveEventInfo <IMedia>(null, "", -1)), "Trashed"), new EventDefinition <IMediaService, RecycleBinEventArgs>(null, serviceContext.MediaService, new RecycleBinEventArgs(Guid.NewGuid())), new EventDefinition <IContentService, SaveEventArgs <IContent> >(null, serviceContext.ContentService, new SaveEventArgs <IContent>(Enumerable.Empty <IContent>()), "Saved"), new EventDefinition <IContentService, DeleteEventArgs <IContent> >(null, serviceContext.ContentService, new DeleteEventArgs <IContent>(Enumerable.Empty <IContent>()), "Deleted"), // not managed //new EventDefinition<IContentService, SaveEventArgs<IContent>>(null, serviceContext.ContentService, new SaveEventArgs<IContent>(Enumerable.Empty<IContent>()), "SavedBlueprint"), //new EventDefinition<IContentService, DeleteEventArgs<IContent>>(null, serviceContext.ContentService, new DeleteEventArgs<IContent>(Enumerable.Empty<IContent>()), "DeletedBlueprint"), new EventDefinition <IContentService, CopyEventArgs <IContent> >(null, serviceContext.ContentService, new CopyEventArgs <IContent>(null, null, -1)), new EventDefinition <IContentService, MoveEventArgs <IContent> >(null, serviceContext.ContentService, new MoveEventArgs <IContent>(new MoveEventInfo <IContent>(null, "", -1)), "Trashed"), new EventDefinition <IContentService, RecycleBinEventArgs>(null, serviceContext.ContentService, new RecycleBinEventArgs(Guid.NewGuid())), new EventDefinition <IContentService, PublishEventArgs <IContent> >(null, serviceContext.ContentService, new PublishEventArgs <IContent>(Enumerable.Empty <IContent>()), "Published"), new EventDefinition <IContentService, PublishEventArgs <IContent> >(null, serviceContext.ContentService, new PublishEventArgs <IContent>(Enumerable.Empty <IContent>()), "Unpublished"), new EventDefinition <IPublicAccessService, SaveEventArgs <PublicAccessEntry> >(null, serviceContext.PublicAccessService, new SaveEventArgs <PublicAccessEntry>(Enumerable.Empty <PublicAccessEntry>())), new EventDefinition <IPublicAccessService, DeleteEventArgs <PublicAccessEntry> >(null, serviceContext.PublicAccessService, new DeleteEventArgs <PublicAccessEntry>(Enumerable.Empty <PublicAccessEntry>())), new EventDefinition <IRelationService, SaveEventArgs <IRelationType> >(null, serviceContext.RelationService, new SaveEventArgs <IRelationType>(Enumerable.Empty <IRelationType>())), new EventDefinition <IRelationService, DeleteEventArgs <IRelationType> >(null, serviceContext.RelationService, new DeleteEventArgs <IRelationType>(Enumerable.Empty <IRelationType>())), new EventDefinition <IRelationService, SaveEventArgs <IRelationType> >(null, serviceContext.RelationService, new SaveEventArgs <IRelationType>(Enumerable.Empty <IRelationType>())), new EventDefinition <IRelationService, DeleteEventArgs <IRelationType> >(null, serviceContext.RelationService, new DeleteEventArgs <IRelationType>(Enumerable.Empty <IRelationType>())), }; var ok = true; foreach (var definition in definitions) { var found = DistributedCacheBinder.FindHandler(definition); if (found == null) { Console.WriteLine("Couldn't find method for " + definition.EventName + " on " + definition.Sender.GetType()); ok = false; } } Assert.IsTrue(ok, "see log for details"); }
public void GroupsContentTypeEvents() { var num = 30; var contentTypes = Enumerable.Repeat(MockedContentTypes.CreateBasicContentType(), num); var mediaTypes = Enumerable.Repeat(MockedContentTypes.CreateImageMediaType(), num); var memberTypes = Enumerable.Repeat(MockedContentTypes.CreateSimpleMemberType(), num); var definitionsContent = contentTypes.SelectMany(x => new IEventDefinition[] { new EventDefinition <IContentTypeService, ContentTypeChange <IContentType> .EventArgs>(null, Current.Services.ContentTypeService, new ContentTypeChange <IContentType> .EventArgs(new ContentTypeChange <IContentType>(x, ContentTypeChangeTypes.Create)), "Changed"), new EventDefinition <IContentTypeService, SaveEventArgs <IContentType> >(null, Current.Services.ContentTypeService, new SaveEventArgs <IContentType>(x), "Saved"), }); var definitionsMedia = mediaTypes.SelectMany(x => new IEventDefinition[] { new EventDefinition <IMediaTypeService, ContentTypeChange <IMediaType> .EventArgs>(null, Current.Services.MediaTypeService, new ContentTypeChange <IMediaType> .EventArgs(new ContentTypeChange <IMediaType>(x, ContentTypeChangeTypes.Create)), "Changed"), new EventDefinition <IMediaTypeService, SaveEventArgs <IMediaType> >(null, Current.Services.MediaTypeService, new SaveEventArgs <IMediaType>(x), "Saved"), }); var definitionsMember = memberTypes.SelectMany(x => new IEventDefinition[] { new EventDefinition <IMemberTypeService, ContentTypeChange <IMemberType> .EventArgs>(null, Current.Services.MemberTypeService, new ContentTypeChange <IMemberType> .EventArgs(new ContentTypeChange <IMemberType>(x, ContentTypeChangeTypes.Create)), "Changed"), new EventDefinition <IMemberTypeService, SaveEventArgs <IMemberType> >(null, Current.Services.MemberTypeService, new SaveEventArgs <IMemberType>(x), "Saved"), }); var definitions = new List <IEventDefinition>(); definitions.AddRange(definitionsContent); definitions.AddRange(definitionsMedia); definitions.AddRange(definitionsMember); var result = DistributedCacheBinder.GetGroupedEventList(definitions); Assert.Multiple(() => { Assert.AreEqual(num * 6, definitions.Count(), "Precondition is we have many definitions"); Assert.AreEqual(6, result.Count(), "Unexpected number of reduced definitions"); foreach (var eventDefinition in result) { if (eventDefinition.Args is SaveEventArgs <IContentType> saveContentEventArgs) { Assert.AreEqual(num, saveContentEventArgs.SavedEntities.Count()); } if (eventDefinition.Args is ContentTypeChange <IContentType> .EventArgs changeContentEventArgs) { Assert.AreEqual(num, changeContentEventArgs.Changes.Count()); } if (eventDefinition.Args is SaveEventArgs <IMediaType> saveMediaEventArgs) { Assert.AreEqual(num, saveMediaEventArgs.SavedEntities.Count()); } if (eventDefinition.Args is ContentTypeChange <IMediaType> .EventArgs changeMediaEventArgs) { Assert.AreEqual(num, changeMediaEventArgs.Changes.Count()); } if (eventDefinition.Args is SaveEventArgs <IMemberType> saveMemberEventArgs) { Assert.AreEqual(num, saveMemberEventArgs.SavedEntities.Count()); } if (eventDefinition.Args is ContentTypeChange <IMemberType> .EventArgs changeMemberEventArgs) { Assert.AreEqual(num, changeMemberEventArgs.Changes.Count()); } } }); }
public void DefaultRepositoryCachePolicy(bool complete) { var scopeProvider = ScopeProvider; var service = Current.Services.UserService; var globalCache = Current.AppCaches.IsolatedCaches.GetOrCreate(typeof(IUser)); var user = (IUser) new User("name", "email", "username", "rawPassword"); service.Save(user); // global cache contains the entity var globalCached = (IUser)globalCache.Get(GetCacheIdKey <IUser>(user.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(user.Id, globalCached.Id); Assert.AreEqual("name", globalCached.Name); // get user again - else we'd modify the one that's in the cache user = service.GetUserById(user.Id); _distributedCacheBinder = new DistributedCacheBinder(new DistributedCache(), Mock.Of <IUmbracoContextFactory>(), Mock.Of <ILogger>()); _distributedCacheBinder.BindEvents(true); Assert.IsNull(scopeProvider.AmbientScope); using (var scope = scopeProvider.CreateScope(repositoryCacheMode: RepositoryCacheMode.Scoped)) { Assert.IsInstanceOf <Core.Scoping.Scope>(scope); Assert.IsNotNull(scopeProvider.AmbientScope); Assert.AreSame(scope, scopeProvider.AmbientScope); // scope has its own isolated cache var scopedCache = scope.IsolatedCaches.GetOrCreate(typeof(IUser)); Assert.AreNotSame(globalCache, scopedCache); user.Name = "changed"; service.Save(user); // scoped cache contains the "new" entity var scopeCached = (IUser)scopedCache.Get(GetCacheIdKey <IUser>(user.Id), () => null); Assert.IsNotNull(scopeCached); Assert.AreEqual(user.Id, scopeCached.Id); Assert.AreEqual("changed", scopeCached.Name); // global cache is unchanged globalCached = (IUser)globalCache.Get(GetCacheIdKey <IUser>(user.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(user.Id, globalCached.Id); Assert.AreEqual("name", globalCached.Name); if (complete) { scope.Complete(); } } Assert.IsNull(scopeProvider.AmbientScope); globalCached = (IUser)globalCache.Get(GetCacheIdKey <IUser>(user.Id), () => null); if (complete) { // global cache has been cleared Assert.IsNull(globalCached); } else { // global cache has *not* been cleared Assert.IsNotNull(globalCached); } // get again, updated if completed user = service.GetUserById(user.Id); Assert.AreEqual(complete ? "changed" : "name", user.Name); // global cache contains the entity again globalCached = (IUser)globalCache.Get(GetCacheIdKey <IUser>(user.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(user.Id, globalCached.Id); Assert.AreEqual(complete ? "changed" : "name", globalCached.Name); }
public void Teardown() { _distributedCacheBinder?.UnbindEvents(); _distributedCacheBinder = null; }
public void SingleItemsOnlyRepositoryCachePolicy(bool complete) { var scopeProvider = ScopeProvider; var service = Current.Services.LocalizationService; var globalCache = Current.AppCaches.IsolatedCaches.GetOrCreate(typeof(IDictionaryItem)); var lang = (ILanguage) new Language("fr-FR"); service.Save(lang); var item = (IDictionaryItem) new DictionaryItem("item-key"); item.Translations = new IDictionaryTranslation[] { new DictionaryTranslation(lang.Id, "item-value"), }; service.Save(item); // global cache contains the entity var globalCached = (IDictionaryItem)globalCache.Get(GetCacheIdKey <IDictionaryItem>(item.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(item.Id, globalCached.Id); Assert.AreEqual("item-key", globalCached.ItemKey); _distributedCacheBinder = new DistributedCacheBinder(new DistributedCache(), Mock.Of <IUmbracoContextFactory>(), Mock.Of <ILogger>()); _distributedCacheBinder.BindEvents(true); Assert.IsNull(scopeProvider.AmbientScope); using (var scope = scopeProvider.CreateScope(repositoryCacheMode: RepositoryCacheMode.Scoped)) { Assert.IsInstanceOf <Core.Scoping.Scope>(scope); Assert.IsNotNull(scopeProvider.AmbientScope); Assert.AreSame(scope, scopeProvider.AmbientScope); // scope has its own isolated cache var scopedCache = scope.IsolatedCaches.GetOrCreate(typeof(IDictionaryItem)); Assert.AreNotSame(globalCache, scopedCache); item.ItemKey = "item-changed"; service.Save(item); // scoped cache contains the "new" entity var scopeCached = (IDictionaryItem)scopedCache.Get(GetCacheIdKey <IDictionaryItem>(item.Id), () => null); Assert.IsNotNull(scopeCached); Assert.AreEqual(item.Id, scopeCached.Id); Assert.AreEqual("item-changed", scopeCached.ItemKey); // global cache is unchanged globalCached = (IDictionaryItem)globalCache.Get(GetCacheIdKey <IDictionaryItem>(item.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(item.Id, globalCached.Id); Assert.AreEqual("item-key", globalCached.ItemKey); if (complete) { scope.Complete(); } } Assert.IsNull(scopeProvider.AmbientScope); globalCached = (IDictionaryItem)globalCache.Get(GetCacheIdKey <IDictionaryItem>(item.Id), () => null); if (complete) { // global cache has been cleared Assert.IsNull(globalCached); } else { // global cache has *not* been cleared Assert.IsNotNull(globalCached); } // get again, updated if completed item = service.GetDictionaryItemById(item.Id); Assert.AreEqual(complete ? "item-changed" : "item-key", item.ItemKey); // global cache contains the entity again globalCached = (IDictionaryItem)globalCache.Get(GetCacheIdKey <IDictionaryItem>(item.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(item.Id, globalCached.Id); Assert.AreEqual(complete ? "item-changed" : "item-key", globalCached.ItemKey); }
public void FullDataSetRepositoryCachePolicy(bool complete) { var scopeProvider = ScopeProvider; var service = Current.Services.LocalizationService; var globalCache = Current.AppCaches.IsolatedCaches.GetOrCreate(typeof(ILanguage)); var lang = (ILanguage) new Language("fr-FR"); service.Save(lang); // global cache has been flushed, reload var globalFullCached = (IEnumerable <ILanguage>)globalCache.Get(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNull(globalFullCached); var reload = service.GetLanguageById(lang.Id); // global cache contains the entity globalFullCached = (IEnumerable <ILanguage>)globalCache.Get(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNotNull(globalFullCached); var globalCached = globalFullCached.First(x => x.Id == lang.Id); Assert.IsNotNull(globalCached); Assert.AreEqual(lang.Id, globalCached.Id); Assert.AreEqual("fr-FR", globalCached.IsoCode); _distributedCacheBinder = new DistributedCacheBinder(new DistributedCache(), Mock.Of <IUmbracoContextFactory>(), Mock.Of <ILogger>()); _distributedCacheBinder.BindEvents(true); Assert.IsNull(scopeProvider.AmbientScope); using (var scope = scopeProvider.CreateScope(repositoryCacheMode: RepositoryCacheMode.Scoped)) { Assert.IsInstanceOf <Core.Scoping.Scope>(scope); Assert.IsNotNull(scopeProvider.AmbientScope); Assert.AreSame(scope, scopeProvider.AmbientScope); // scope has its own isolated cache var scopedCache = scope.IsolatedCaches.GetOrCreate(typeof(ILanguage)); Assert.AreNotSame(globalCache, scopedCache); lang.IsoCode = "de-DE"; service.Save(lang); // scoped cache has been flushed, reload var scopeFullCached = (IEnumerable <ILanguage>)scopedCache.Get(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNull(scopeFullCached); reload = service.GetLanguageById(lang.Id); // scoped cache contains the "new" entity scopeFullCached = (IEnumerable <ILanguage>)scopedCache.Get(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNotNull(scopeFullCached); var scopeCached = scopeFullCached.First(x => x.Id == lang.Id); Assert.IsNotNull(scopeCached); Assert.AreEqual(lang.Id, scopeCached.Id); Assert.AreEqual("de-DE", scopeCached.IsoCode); // global cache is unchanged globalFullCached = (IEnumerable <ILanguage>)globalCache.Get(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNotNull(globalFullCached); globalCached = globalFullCached.First(x => x.Id == lang.Id); Assert.IsNotNull(globalCached); Assert.AreEqual(lang.Id, globalCached.Id); Assert.AreEqual("fr-FR", globalCached.IsoCode); if (complete) { scope.Complete(); } } Assert.IsNull(scopeProvider.AmbientScope); globalFullCached = (IEnumerable <ILanguage>)globalCache.Get(GetCacheTypeKey <ILanguage>(), () => null); if (complete) { // global cache has been cleared Assert.IsNull(globalFullCached); } else { // global cache has *not* been cleared Assert.IsNotNull(globalFullCached); } // get again, updated if completed lang = service.GetLanguageById(lang.Id); Assert.AreEqual(complete ? "de-DE" : "fr-FR", lang.IsoCode); // global cache contains the entity again globalFullCached = (IEnumerable <ILanguage>)globalCache.Get(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNotNull(globalFullCached); globalCached = globalFullCached.First(x => x.Id == lang.Id); Assert.IsNotNull(globalCached); Assert.AreEqual(lang.Id, globalCached.Id); Assert.AreEqual(complete ? "de-DE" : "fr-FR", lang.IsoCode); }