public void Teardown() { if (_cacheHandler != null) { _cacheHandler.Unbind(); } _cacheHandler = null; ServerRegistrarResolver.Reset(); ServerMessengerResolver.Reset(); CacheRefreshersResolver.Reset(); }
public void Teardown() { if (_cacheHandler != null) { _cacheHandler.Unbind(); } _cacheHandler = null; _onPublishedAssertAction = null; content.HttpContextItemsGetter = null; ContentService.Published -= OnPublishedAssert; SafeXmlReaderWriter.Cloning = null; ServerRegistrarResolver.Reset(); ServerMessengerResolver.Reset(); CacheRefreshersResolver.Reset(); }
public void TestNoScope() { content.TestingUpdateSitemapProvider = false; var settings = SettingsForTests.GenerateMockSettings(); var contentMock = Mock.Get(settings.Content); contentMock.Setup(x => x.XmlCacheEnabled).Returns(false); SettingsForTests.ConfigureSettings(settings); var contentType = new ContentType(-1) { Alias = "contenttype", Name = "test" }; ApplicationContext.Services.ContentTypeService.Save(contentType); _cacheHandler = new CacheRefresherEventHandler(true); _cacheHandler.OnApplicationStarted(null, ApplicationContext); var xml = content.Instance.XmlContent; Assert.IsNotNull(xml); var beforeXml = xml.OuterXml; var item = new Content("name", -1, contentType); ApplicationContext.Services.ContentService.SaveAndPublishWithStatus(item); Console.WriteLine("Xml Before:"); Console.WriteLine(xml.OuterXml); Assert.AreEqual(beforeXml, xml.OuterXml); xml = content.Instance.XmlContent; Assert.IsNotNull(xml); Console.WriteLine("Xml After:"); Console.WriteLine(xml.OuterXml); var node = xml.GetElementById(item.Id.ToString()); Assert.IsNotNull(node); }
public void Can_Find_All_Event_Handlers() { 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 <IApplicationTreeService, EventArgs>(null, ServiceContext.ApplicationTreeService, new EventArgs(), "Deleted"), new EventDefinition <IApplicationTreeService, EventArgs>(null, ServiceContext.ApplicationTreeService, new EventArgs(), "Updated"), new EventDefinition <IApplicationTreeService, EventArgs>(null, ServiceContext.ApplicationTreeService, new EventArgs(), "New"), new EventDefinition <ISectionService, EventArgs>(null, ServiceContext.SectionService, new EventArgs(), "Deleted"), new EventDefinition <ISectionService, EventArgs>(null, ServiceContext.SectionService, new EventArgs(), "New"), 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 <IUserGroup> >(null, ServiceContext.UserService, new SaveEventArgs <IUserGroup>(Enumerable.Empty <IUserGroup>())), 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 <IDataTypeDefinition> >(null, ServiceContext.DataTypeService, new SaveEventArgs <IDataTypeDefinition>(Enumerable.Empty <IDataTypeDefinition>())), new EventDefinition <IDataTypeService, DeleteEventArgs <IDataTypeDefinition> >(null, ServiceContext.DataTypeService, new DeleteEventArgs <IDataTypeDefinition>(Enumerable.Empty <IDataTypeDefinition>())), 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 <IContentTypeService, SaveEventArgs <IMediaType> >(null, ServiceContext.ContentTypeService, new SaveEventArgs <IMediaType>(Enumerable.Empty <IMediaType>())), new EventDefinition <IContentTypeService, DeleteEventArgs <IMediaType> >(null, ServiceContext.ContentTypeService, 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 Dictionary <int, IEnumerable <Property> >(), true)), new EventDefinition <IContentService, SaveEventArgs <IContent> >(null, ServiceContext.ContentService, new SaveEventArgs <IContent>(Enumerable.Empty <IContent>()), "Saved"), 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>()), "Deleted"), 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 Dictionary <int, IEnumerable <Property> >(), true)), 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>())), }; foreach (var definition in definitions) { var found = CacheRefresherEventHandler.FindHandler(definition); Assert.IsNotNull(found, "Couldn't find method for " + definition.EventName + " on " + definition.Sender.GetType()); } }
public void DefaultRepositoryCachePolicy(bool complete) { var scopeProvider = DatabaseContext.ScopeProvider; var service = ApplicationContext.Services.UserService; var globalCache = ApplicationContext.ApplicationCache.IsolatedRuntimeCache.GetOrCreateCache(typeof(IUser)); var user = (IUser) new User("name", "email", "username", "rawPassword"); service.Save(user); // global cache contains the entity var globalCached = (IUser)globalCache.GetCacheItem(GetCacheIdKey <IUser>(user.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(user.Id, globalCached.Id); Assert.AreEqual("name", globalCached.Name); _cacheHandler = new CacheRefresherEventHandler(true); _cacheHandler.OnApplicationStarted(null, ApplicationContext); Assert.IsNull(scopeProvider.AmbientScope); using (var scope = scopeProvider.CreateScope(repositoryCacheMode: RepositoryCacheMode.Scoped)) { Assert.IsInstanceOf <Scope>(scope); Assert.IsNotNull(scopeProvider.AmbientScope); Assert.AreSame(scope, scopeProvider.AmbientScope); // scope has its own isolated cache var scopedCache = scope.IsolatedRuntimeCache.GetOrCreateCache(typeof(IUser)); Assert.AreNotSame(globalCache, scopedCache); user.Name = "changed"; service.Save(user); // scoped cache contains the "new" entity var scopeCached = (IUser)scopedCache.GetCacheItem(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.GetCacheItem(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.GetCacheItem(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.GetCacheItem(GetCacheIdKey <IUser>(user.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(user.Id, globalCached.Id); Assert.AreEqual(complete ? "changed" : "name", globalCached.Name); }
public void SingleItemsOnlyRepositoryCachePolicy(bool complete) { var scopeProvider = DatabaseContext.ScopeProvider; var service = ApplicationContext.Services.LocalizationService; var globalCache = ApplicationContext.ApplicationCache.IsolatedRuntimeCache.GetOrCreateCache(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.GetCacheItem(GetCacheIdKey <IDictionaryItem>(item.Id), () => null); Assert.IsNotNull(globalCached); Assert.AreEqual(item.Id, globalCached.Id); Assert.AreEqual("item-key", globalCached.ItemKey); _cacheHandler = new CacheRefresherEventHandler(true); _cacheHandler.OnApplicationStarted(null, ApplicationContext); Assert.IsNull(scopeProvider.AmbientScope); using (var scope = scopeProvider.CreateScope(repositoryCacheMode: RepositoryCacheMode.Scoped)) { Assert.IsInstanceOf <Scope>(scope); Assert.IsNotNull(scopeProvider.AmbientScope); Assert.AreSame(scope, scopeProvider.AmbientScope); // scope has its own isolated cache var scopedCache = scope.IsolatedRuntimeCache.GetOrCreateCache(typeof(IDictionaryItem)); Assert.AreNotSame(globalCache, scopedCache); item.ItemKey = "item-changed"; service.Save(item); // scoped cache contains the "new" entity var scopeCached = (IDictionaryItem)scopedCache.GetCacheItem(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.GetCacheItem(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.GetCacheItem(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.GetCacheItem(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 = DatabaseContext.ScopeProvider; var service = ApplicationContext.Services.LocalizationService; var globalCache = ApplicationContext.ApplicationCache.IsolatedRuntimeCache.GetOrCreateCache(typeof(ILanguage)); var lang = (ILanguage) new Language("fr-FR"); service.Save(lang); // global cache has been flushed, reload var globalFullCached = (IEnumerable <ILanguage>)globalCache.GetCacheItem(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNull(globalFullCached); var reload = service.GetLanguageById(lang.Id); // global cache contains the entity globalFullCached = (IEnumerable <ILanguage>)globalCache.GetCacheItem(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); _cacheHandler = new CacheRefresherEventHandler(true); _cacheHandler.OnApplicationStarted(null, ApplicationContext); Assert.IsNull(scopeProvider.AmbientScope); using (var scope = scopeProvider.CreateScope(repositoryCacheMode: RepositoryCacheMode.Scoped)) { Assert.IsInstanceOf <Scope>(scope); Assert.IsNotNull(scopeProvider.AmbientScope); Assert.AreSame(scope, scopeProvider.AmbientScope); // scope has its own isolated cache var scopedCache = scope.IsolatedRuntimeCache.GetOrCreateCache(typeof(ILanguage)); Assert.AreNotSame(globalCache, scopedCache); lang.IsoCode = "de-DE"; service.Save(lang); // scoped cache has been flushed, reload var scopeFullCached = (IEnumerable <ILanguage>)scopedCache.GetCacheItem(GetCacheTypeKey <ILanguage>(), () => null); Assert.IsNull(scopeFullCached); reload = service.GetLanguageById(lang.Id); // scoped cache contains the "new" entity scopeFullCached = (IEnumerable <ILanguage>)scopedCache.GetCacheItem(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.GetCacheItem(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.GetCacheItem(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.GetCacheItem(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); }
public void TestScopeMany(bool complete) { content.TestingUpdateSitemapProvider = false; var settings = SettingsForTests.GenerateMockSettings(); var contentMock = Mock.Get(settings.Content); contentMock.Setup(x => x.XmlCacheEnabled).Returns(false); SettingsForTests.ConfigureSettings(settings); var contentType = new ContentType(-1) { Alias = "contenttype", Name = "test" }; ApplicationContext.Services.ContentTypeService.Save(contentType); _cacheHandler = new CacheRefresherEventHandler(true); _cacheHandler.OnApplicationStarted(null, ApplicationContext); var xml = content.Instance.XmlContent; Assert.IsNotNull(xml); 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 = ApplicationContext.Current.ScopeProvider.CreateScope()) { ApplicationContext.Services.ContentService.SaveAndPublishWithStatus(item); for (var i = 0; i < count; i++) { var temp = new Content("content_" + i, -1, contentType); ApplicationContext.Services.ContentService.SaveAndPublishWithStatus(temp); ids[i] = temp.Id; } // this should never change Assert.AreEqual(beforeOuterXml, beforeXml.OuterXml); xml = content.Instance.XmlContent; Assert.IsNotNull(xml); Console.WriteLine("Xml InScope (before complete):"); Console.WriteLine(xml.OuterXml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); if (complete) { scope.Complete(); } xml = content.Instance.XmlContent; Assert.IsNotNull(xml); Console.WriteLine("Xml InScope (after complete):"); Console.WriteLine(xml.OuterXml); Assert.AreEqual(beforeOuterXml, xml.OuterXml); } var scopeProvider = ApplicationContext.Current.ScopeProvider as IScopeProviderInternal; 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 = content.Instance.XmlContent; 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 TestScope(bool complete) { content.TestingUpdateSitemapProvider = false; var httpContextItems = new Hashtable(); content.HttpContextItemsGetter = () => httpContextItems; var settings = SettingsForTests.GenerateMockSettings(); var contentMock = Mock.Get(settings.Content); contentMock.Setup(x => x.XmlCacheEnabled).Returns(false); SettingsForTests.ConfigureSettings(settings); var contentType = new ContentType(-1) { Alias = "contenttype", Name = "test" }; ApplicationContext.Services.ContentTypeService.Save(contentType); _cacheHandler = new CacheRefresherEventHandler(true); _cacheHandler.OnApplicationStarted(null, ApplicationContext); var xml = content.Instance.XmlContent; Assert.IsNotNull(xml); Assert.AreSame(xml, httpContextItems[content.XmlContextContentItemKey]); var beforeXml = xml; var beforeOuterXml = beforeXml.OuterXml; var item = new Content("name", -1, contentType); Console.WriteLine("Xml Before:"); Console.WriteLine(xml.OuterXml); var evented = 0; _onPublishedAssertAction = () => { evented++; xml = content.Instance.XmlContent; Assert.IsNotNull(xml); Assert.AreNotSame(beforeXml, xml); Console.WriteLine("Xml Event:"); Console.WriteLine(xml.OuterXml); var node = xml.GetElementById(item.Id.ToString()); Assert.IsNotNull(node); }; ContentService.Published += OnPublishedAssert; using (var scope = ApplicationContext.Current.ScopeProvider.CreateScope()) { ApplicationContext.Services.ContentService.SaveAndPublishWithStatus(item); // should create an xml clone item.Name = "changed"; ApplicationContext.Services.ContentService.SaveAndPublishWithStatus(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 = content.Instance.XmlContentInternal; Assert.IsNotNull(xml); 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 = content.Instance.XmlContent; Assert.IsNotNull(xml); Assert.AreSame(beforeXml, xml); // note // this means that, as long as ppl don't create scopes, they'll see their // changes right after SaveAndPublishWithStatus, 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 = content.Instance.XmlContent; Assert.IsNotNull(xml); 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! } }