public void CacheUnknownTest() { var converter = new CacheConverter1(PropertyCacheLevel.Unknown); var converters = new PropertyValueConverterCollection(() => new IPropertyValueConverter[] { converter, }); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType = new DataType( new VoidEditor( Mock.Of <IDataValueEditorFactory>()), new ConfigurationEditorJsonSerializer()) { Id = 1 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } IPublishedContentType setType1 = publishedContentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "set1", CreatePropertyTypes); Assert.Throws <Exception>(() => { var unused = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); }); }
public void Fragment2() { IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(PublishedContentTypeFactory.CreatePropertyType(contentType, "legend", _dataTypes[0].Id)); yield return(PublishedContentTypeFactory.CreatePropertyType(contentType, "image", _dataTypes[0].Id)); yield return(PublishedContentTypeFactory.CreatePropertyType(contentType, "size", _dataTypes[0].Id)); } const string val1 = "boom bam"; const int val2 = 0; const int val3 = 666; var guid = Guid.NewGuid(); var ct = PublishedContentTypeFactory.CreateContentType(Guid.NewGuid(), 0, "alias", CreatePropertyTypes); var c = new ImageWithLegendModel( ct, guid, new Dictionary <string, object> { { "legend", val1 }, { "image", val2 }, { "size", val3 } }, false); Assert.AreEqual(val1, c.Legend); Assert.AreEqual(val3, c.Size); }
protected override void Initialize() { base.Initialize(); var converters = Factory.GetInstance <PropertyValueConverterCollection>(); var umbracoContextAccessor = Mock.Of <IUmbracoContextAccessor>(); var logger = Mock.Of <ILogger>(); var imageSourceParser = new HtmlImageSourceParser(umbracoContextAccessor); var pastedImages = new RichTextEditorPastedImages(umbracoContextAccessor, logger, Mock.Of <IMediaService>(), Mock.Of <IContentTypeBaseServiceProvider>()); var localLinkParser = new HtmlLocalLinkParser(umbracoContextAccessor); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new RichTextPropertyEditor(logger, umbracoContextAccessor, imageSourceParser, localLinkParser, pastedImages, Mock.Of <IImageUrlGenerator>())) { Id = 1 }); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "content", 1)); } var type = new AutoPublishedContentType(0, "anything", CreatePropertyTypes); ContentTypesCache.GetPublishedContentTypeByAlias = alias => type; var umbracoContext = GetUmbracoContext("/test"); Umbraco.Web.Composing.Current.UmbracoContextAccessor.UmbracoContext = umbracoContext; }
public void CacheUnknownTest() { var converter = new CacheConverter1(PropertyCacheLevel.Unknown); var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[] { converter, }); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } var setType1 = publishedContentTypeFactory.CreateContentType(1000, "set1", CreatePropertyTypes); Assert.Throws <Exception>(() => { var unused = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); }); }
protected override void Initialize() { base.Initialize(); var converters = Factory.GetInstance <PropertyValueConverterCollection>(); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new RichTextPropertyEditor(Mock.Of <ILogger>())) { Id = 1 }); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); // need to specify a custom callback for unit tests var propertyTypes = new[] { // AutoPublishedContentType will auto-generate other properties publishedContentTypeFactory.CreatePropertyType("content", 1), }; var type = new AutoPublishedContentType(0, "anything", propertyTypes); ContentTypesCache.GetPublishedContentTypeByAlias = alias => type; var umbracoContext = GetUmbracoContext("/test"); Umbraco.Web.Composing.Current.UmbracoContextAccessor.UmbracoContext = umbracoContext; }
protected override IPublishedSnapshotService CreatePublishedSnapshotService() { var options = new PublishedSnapshotService.Options { IgnoreLocalDb = true }; var publishedSnapshotAccessor = new UmbracoContextPublishedSnapshotAccessor(Umbraco.Web.Composing.Current.UmbracoContextAccessor); var runtimeStateMock = new Mock <IRuntimeState>(); runtimeStateMock.Setup(x => x.Level).Returns(() => RuntimeLevel.Run); var contentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), Mock.Of <IDataTypeService>()); var documentRepository = Mock.Of <IDocumentRepository>(); var mediaRepository = Mock.Of <IMediaRepository>(); var memberRepository = Mock.Of <IMemberRepository>(); return(new PublishedSnapshotService( options, null, runtimeStateMock.Object, ServiceContext, contentTypeFactory, null, publishedSnapshotAccessor, Mock.Of <IVariationContextAccessor>(), Logger, ScopeProvider, documentRepository, mediaRepository, memberRepository, DefaultCultureAccessor, new DatabaseDataSource(), Factory.GetInstance <IGlobalSettings>(), new SiteDomainHelper())); }
private IPublishedContent GetContent(bool createChildren, int indexVals) { var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); var contentTypeAlias = createChildren ? "Parent" : "Child"; var d = new TestPublishedContent { CreateDate = DateTime.Now, CreatorId = 1, CreatorName = "Shannon", Id = 3, SortOrder = 4, TemplateId = 5, UpdateDate = DateTime.Now, Path = "-1,3", UrlSegment = "home-page", Name = "Page" + Guid.NewGuid().ToString(), Version = Guid.NewGuid(), WriterId = 1, WriterName = "Shannon", Parent = null, Level = 1, Children = new List <IPublishedContent>() }; d.Properties = new Collection <IPublishedProperty>(new List <IPublishedProperty> { new RawValueProperty(factory.CreatePropertyType("property1", 1), d, "value" + indexVals), new RawValueProperty(factory.CreatePropertyType("property2", 1), d, "value" + (indexVals + 1)) }); if (createChildren) { d.Children = new List <IPublishedContent>() { GetContent(false, indexVals + 3), GetContent(false, indexVals + 6), GetContent(false, indexVals + 9) }; } if (!createChildren) { //create additional columns, used to test the different columns for child nodes ((Collection <IPublishedProperty>)d.Properties).Add( new RawValueProperty(factory.CreatePropertyType("property4", 1), d, "value" + (indexVals + 2))); } else { ((Collection <IPublishedProperty>)d.Properties).Add( new RawValueProperty(factory.CreatePropertyType("property3", 1), d, "value" + (indexVals + 2))); } d.ContentType = new PublishedContentType(22, contentTypeAlias, PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing); return(d); }
public void CanConvertImageCropperPropertyEditor(string val1, string val2, bool expected) { try { var container = RegisterFactory.Create(); var composition = new Composition(container, new TypeLoader(), Mock.Of <IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run)); composition.WithCollectionBuilder <PropertyValueConverterCollectionBuilder>(); Current.Factory = composition.CreateFactory(); var logger = Mock.Of <ILogger>(); var scheme = Mock.Of <IMediaPathScheme>(); var config = Mock.Of <IContentSection>(); var mediaFileSystem = new MediaFileSystem(Mock.Of <IFileSystem>(), config, scheme, logger); var imageCropperConfiguration = new ImageCropperConfiguration() { Crops = new[] { new ImageCropperConfiguration.Crop() { Alias = "thumb", Width = 100, Height = 100 } } }; var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new ImageCropperPropertyEditor(Mock.Of <ILogger>(), mediaFileSystem, Mock.Of <IContentSection>(), Mock.Of <IDataTypeService>())) { Id = 1, Configuration = imageCropperConfiguration }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); var converter = new ImageCropperValueConverter(); var result = converter.ConvertSourceToIntermediate(null, factory.CreatePropertyType("test", 1), val1, false); // does not use type for conversion var resultShouldMatch = val2.DeserializeImageCropperValue(); if (expected) { Assert.AreEqual(resultShouldMatch, result); } else { Assert.AreNotEqual(resultShouldMatch, result); } } finally { Current.Reset(); } }
public void CacheLevelTest(PropertyCacheLevel cacheLevel, int interConverts) { var converter = new CacheConverter1(cacheLevel); var converters = new PropertyValueConverterCollection(() => new IPropertyValueConverter[] { converter, }); var configurationEditorJsonSerializer = new ConfigurationEditorJsonSerializer(); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType = new DataType( new VoidEditor( Mock.Of <IDataValueEditorFactory>()), configurationEditorJsonSerializer) { Id = 1 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "prop1", dataType.Id)); } IPublishedContentType setType1 = publishedContentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "set1", CreatePropertyTypes); // PublishedElementPropertyBase.GetCacheLevels: // // if property level is > reference level, or both are None // use None for property & new reference // else // use Content for property, & keep reference // // PublishedElement creates properties with reference being None // if converter specifies None, keep using None // anything else is not > None, use Content // // for standalone elements, it's only None or Content var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); Assert.AreEqual(1234, set1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(1, converter.InterConverts); // source is always converted once and cached per content // inter conversion depends on the specified cache level Assert.AreEqual(1234, set1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(interConverts, converter.InterConverts); }
public void SimpleConverter2Test() { var cacheMock = new Mock <IPublishedContentCache>(); var cacheContent = new Dictionary <int, IPublishedContent>(); cacheMock.Setup(x => x.GetById(It.IsAny <int>())) .Returns <int>(id => cacheContent.TryGetValue(id, out var content) ? content : null); var publishedSnapshotMock = new Mock <IPublishedSnapshot>(); publishedSnapshotMock.Setup(x => x.Content).Returns(cacheMock.Object); var publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>(); var localPublishedSnapshot = publishedSnapshotMock.Object; publishedSnapshotAccessorMock.Setup(x => x.TryGetPublishedSnapshot(out localPublishedSnapshot)).Returns(true); var publishedSnapshotAccessor = publishedSnapshotAccessorMock.Object; var converters = new PropertyValueConverterCollection(() => new IPropertyValueConverter[] { new SimpleConverter2(publishedSnapshotAccessor), }); var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType = new DataType( new VoidEditor(Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 1 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield); var contentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(contentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } var elementType1 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "element1", CreatePropertyTypes); var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); var cntType1 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 1001, "cnt1", t => Enumerable.Empty <PublishedPropertyType>()); var cnt1 = new InternalPublishedContent(cntType1) { Id = 1234 }; cacheContent[cnt1.Id] = cnt1; Assert.AreSame(cnt1, element1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); }
static AutoPublishedContentType() { var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 666 }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); Default = factory.CreatePropertyType("*", 666); }
public void FragmentProperty() { IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(PublishedContentTypeFactory.CreatePropertyType(contentType, "detached", _dataTypes[0].Id)); } var ct = PublishedContentTypeFactory.CreateContentType(Guid.NewGuid(), 0, "alias", CreatePropertyTypes); var pt = ct.GetPropertyType("detached"); var prop = new PublishedElementPropertyBase(pt, null, false, PropertyCacheLevel.None, 5548); Assert.IsInstanceOf <int>(prop.GetValue()); Assert.AreEqual(5548, prop.GetValue()); }
public void CacheLevelTest(PropertyCacheLevel cacheLevel, int interConverts) { var converter = new CacheConverter1(cacheLevel); var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[] { converter, }); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); var setType1 = publishedContentTypeFactory.CreateContentType(1000, "set1", new[] { publishedContentTypeFactory.CreatePropertyType("prop1", 1), }); // PublishedElementPropertyBase.GetCacheLevels: // // if property level is > reference level, or both are None // use None for property & new reference // else // use Content for property, & keep reference // // PublishedElement creates properties with reference being None // if converter specifies None, keep using None // anything else is not > None, use Content // // for standalone elements, it's only None or Content var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); Assert.AreEqual(1234, set1.Value("prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(1, converter.InterConverts); // source is always converted once and cached per content // inter conversion depends on the specified cache level Assert.AreEqual(1234, set1.Value("prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(interConverts, converter.InterConverts); }
private SolidPublishedSnapshot CreatePublishedSnapshot() { var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); var caches = new SolidPublishedSnapshot(); var cache = caches.InnerContentCache; PopulateCache(factory, cache); return(caches); }
static AutoPublishedContentType() { var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType = new DataType(new VoidEditor(Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 666 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeServiceMock.Object); Default = factory.CreatePropertyType("*", 666); }
public void SimpleConverter2Test() { var cacheMock = new Mock <IPublishedContentCache>(); var cacheContent = new Dictionary <int, IPublishedContent>(); cacheMock.Setup(x => x.GetById(It.IsAny <int>())).Returns <int>(id => cacheContent.TryGetValue(id, out IPublishedContent content) ? content : null); var publishedSnapshotMock = new Mock <IPublishedSnapshot>(); publishedSnapshotMock.Setup(x => x.Content).Returns(cacheMock.Object); var publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>(); publishedSnapshotAccessorMock.Setup(x => x.PublishedSnapshot).Returns(publishedSnapshotMock.Object); var publishedSnapshotAccessor = publishedSnapshotAccessorMock.Object; var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[] { new SimpleConverter2(publishedSnapshotAccessor), }); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var contentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(contentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } var elementType1 = contentTypeFactory.CreateContentType(1000, "element1", CreatePropertyTypes); var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); var cntType1 = contentTypeFactory.CreateContentType(1001, "cnt1", t => Enumerable.Empty <PublishedPropertyType>()); var cnt1 = new SolidPublishedContent(cntType1) { Id = 1234 }; cacheContent[cnt1.Id] = cnt1; Assert.AreSame(cnt1, element1.Value("prop1")); }
public void SimpleConverter1Test() { var converters = new PropertyValueConverterCollection(() => new IPropertyValueConverter[] { new SimpleConverter1(), }); var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType = new DataType( new VoidEditor( Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 1 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield); var contentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(contentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } IPublishedContentType elementType1 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "element1", CreatePropertyTypes); var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); Assert.AreEqual(1234, element1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); // 'null' would be considered a 'missing' value by the default, magic logic var e = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", null } }, false); Assert.IsFalse(e.HasValue("prop1")); // '0' would not - it's a valid integer - but the converter knows better e = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "0" } }, false); Assert.IsFalse(e.HasValue("prop1")); }
protected override void Initialize() { base.Initialize(); var converters = Factory.GetRequiredService <PropertyValueConverterCollection>(); var umbracoContextAccessor = Mock.Of <IUmbracoContextAccessor>(); var publishedUrlProvider = Mock.Of <IPublishedUrlProvider>(); var loggerFactory = NullLoggerFactory.Instance; var serializer = new ConfigurationEditorJsonSerializer(); var imageSourceParser = new HtmlImageSourceParser(publishedUrlProvider); var mediaFileManager = new MediaFileManager(Mock.Of <IFileSystem>(), Mock.Of <IMediaPathScheme>(), loggerFactory.CreateLogger <MediaFileManager>(), Mock.Of <IShortStringHelper>()); var pastedImages = new RichTextEditorPastedImages(umbracoContextAccessor, loggerFactory.CreateLogger <RichTextEditorPastedImages>(), HostingEnvironment, Mock.Of <IMediaService>(), Mock.Of <IContentTypeBaseServiceProvider>(), mediaFileManager, ShortStringHelper, publishedUrlProvider, serializer); var localLinkParser = new HtmlLocalLinkParser(umbracoContextAccessor, publishedUrlProvider); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new RichTextPropertyEditor( DataValueEditorFactory, Mock.Of <IBackOfficeSecurityAccessor>(), imageSourceParser, localLinkParser, pastedImages, IOHelper, Mock.Of <IImageUrlGenerator>()), serializer) { Id = 1 }); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "content", 1)); } var type = new AutoPublishedContentType(Guid.NewGuid(), 0, "anything", CreatePropertyTypes); ContentTypesCache.GetPublishedContentTypeByAlias = alias => type; var umbracoContext = GetUmbracoContext("/test"); Umbraco.Web.Composing.Current.UmbracoContextAccessor.UmbracoContext = umbracoContext; }
protected override void Initialize() { base.Initialize(); // need to specify a custom callback for unit tests // AutoPublishedContentTypes generates properties automatically var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); var type = new AutoPublishedContentType(Guid.NewGuid(), 0, "anything", new PublishedPropertyType[] { }); ContentTypesCache.GetPublishedContentTypeByAlias = alias => GetPublishedContentTypeByAlias(alias) ?? type; }
public void SimpleConverter1Test() { var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[] { new SimpleConverter1(), }); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var contentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(contentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } var elementType1 = contentTypeFactory.CreateContentType(1000, "element1", CreatePropertyTypes); var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false); Assert.AreEqual(1234, element1.Value("prop1")); // 'null' would be considered a 'missing' value by the default, magic logic var e = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", null } }, false); Assert.IsFalse(e.HasValue("prop1")); // '0' would not - it's a valid integer - but the converter knows better e = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "0" } }, false); Assert.IsFalse(e.HasValue("prop1")); }
private static PublishedContentType GetPublishedContentType(PublishedItemType type, string alias) { var dataType = new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }; var dataTypeService = Mock.Of <IDataTypeService>(); Mock.Get(dataTypeService) .Setup(x => x.GetDataType(It.IsAny <int>())) .Returns <int>(id => id == 1 ? dataType : null); Mock.Get(dataTypeService) .Setup(x => x.GetAll()) .Returns(new[] { dataType }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); return(factory.CreateContentType(0, alias, new string[] {}, new List <PublishedPropertyType>(Enumerable.Range(0, 10).Select(x => factory.CreatePropertyType("prop" + x, 1))))); }
internal override void PopulateCache(PublishedContentTypeFactory factory, SolidPublishedContentCache cache) { IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "prop1", 1)); } var contentType1 = factory.CreateContentType(Guid.NewGuid(), 1, "ContentType1", Enumerable.Empty <string>(), CreatePropertyTypes); var contentType2 = factory.CreateContentType(Guid.NewGuid(), 2, "ContentType2", Enumerable.Empty <string>(), CreatePropertyTypes); var contentType2Sub = factory.CreateContentType(Guid.NewGuid(), 3, "ContentType2Sub", Enumerable.Empty <string>(), CreatePropertyTypes); var content = new SolidPublishedContent(contentType1) { Id = 1, SortOrder = 0, Name = "Content 1", UrlSegment = "content-1", Path = "/1", Level = 1, Url = "/content-1", ParentId = -1, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = 1234, SolidSourceValue = "1234" } } }; cache.Add(content); content = new SolidPublishedContent(contentType2) { Id = 2, SortOrder = 1, Name = "Content 2", UrlSegment = "content-2", Path = "/2", Level = 1, Url = "/content-2", ParentId = -1, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = 1234, SolidSourceValue = "1234" } } }; cache.Add(content); content = new SolidPublishedContent(contentType2Sub) { Id = 3, SortOrder = 2, Name = "Content 2Sub", UrlSegment = "content-2sub", Path = "/3", Level = 1, Url = "/content-2sub", ParentId = -1, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = 1234, SolidSourceValue = "1234" } } }; cache.Add(content); }
public void CachePublishedSnapshotTest(PropertyCacheLevel referenceCacheLevel, PropertyCacheLevel converterCacheLevel, int interConverts, int elementsCount1, int snapshotCount1, int elementsCount2, int snapshotCount2) { var converter = new CacheConverter1(converterCacheLevel); var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[] { converter, }); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } var setType1 = publishedContentTypeFactory.CreateContentType(1000, "set1", CreatePropertyTypes); var elementsCache = new FastDictionaryAppCache(); var snapshotCache = new FastDictionaryAppCache(); var publishedSnapshot = new Mock <IPublishedSnapshot>(); publishedSnapshot.Setup(x => x.SnapshotCache).Returns(snapshotCache); publishedSnapshot.Setup(x => x.ElementsCache).Returns(elementsCache); var publishedSnapshotAccessor = new Mock <IPublishedSnapshotAccessor>(); publishedSnapshotAccessor.Setup(x => x.PublishedSnapshot).Returns(publishedSnapshot.Object); // pretend we're creating this set as a value for a property // referenceCacheLevel is the cache level for this fictious property // converterCacheLevel is the cache level specified by the converter var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false, referenceCacheLevel, publishedSnapshotAccessor.Object); Assert.AreEqual(1234, set1.Value("prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(1, converter.InterConverts); Assert.AreEqual(elementsCount1, elementsCache.Items.Count); Assert.AreEqual(snapshotCount1, snapshotCache.Items.Count); Assert.AreEqual(1234, set1.Value("prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(interConverts, converter.InterConverts); Assert.AreEqual(elementsCount2, elementsCache.Items.Count); Assert.AreEqual(snapshotCount2, snapshotCache.Items.Count); var oldSnapshotCache = snapshotCache; snapshotCache.Items.Clear(); Assert.AreEqual(1234, set1.Value("prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(elementsCount2, elementsCache.Items.Count); Assert.AreEqual(snapshotCount2, snapshotCache.Items.Count); Assert.AreEqual(snapshotCount2, oldSnapshotCache.Items.Count); Assert.AreEqual((interConverts == 1 ? 1 : 3) + snapshotCache.Items.Count, converter.InterConverts); var oldElementsCache = elementsCache; elementsCache.Items.Clear(); Assert.AreEqual(1234, set1.Value("prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(elementsCount2, elementsCache.Items.Count); Assert.AreEqual(elementsCount2, oldElementsCache.Items.Count); Assert.AreEqual(snapshotCount2, snapshotCache.Items.Count); Assert.AreEqual((interConverts == 1 ? 1 : 4) + snapshotCache.Items.Count + elementsCache.Items.Count, converter.InterConverts); }
internal override void PopulateCache(PublishedContentTypeFactory factory, SolidPublishedContentCache cache) { var props = new[] { factory.CreatePropertyType("prop1", 1), }; var contentType1 = factory.CreateContentType(1, "ContentType1", Enumerable.Empty <string>(), props); var contentType2 = factory.CreateContentType(2, "ContentType2", Enumerable.Empty <string>(), props); var contentType2Sub = factory.CreateContentType(3, "ContentType2Sub", Enumerable.Empty <string>(), props); cache.Add(new SolidPublishedContent(contentType1) { Id = 1, SortOrder = 0, Name = "Content 1", UrlSegment = "content-1", Path = "/1", Level = 1, Url = "/content-1", ParentId = -1, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = 1234, SolidSourceValue = "1234" } } }); cache.Add(new SolidPublishedContent(contentType2) { Id = 2, SortOrder = 1, Name = "Content 2", UrlSegment = "content-2", Path = "/2", Level = 1, Url = "/content-2", ParentId = -1, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = 1234, SolidSourceValue = "1234" } } }); cache.Add(new SolidPublishedContent(contentType2Sub) { Id = 3, SortOrder = 2, Name = "Content 2Sub", UrlSegment = "content-2sub", Path = "/3", Level = 1, Url = "/content-2sub", ParentId = -1, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = 1234, SolidSourceValue = "1234" } } }); }
internal abstract void PopulateCache(PublishedContentTypeFactory factory, SolidPublishedContentCache cache);
public void CachePublishedSnapshotTest( PropertyCacheLevel referenceCacheLevel, PropertyCacheLevel converterCacheLevel, int interConverts, int elementsCount1, int snapshotCount1, int elementsCount2, int snapshotCount2) { var converter = new CacheConverter1(converterCacheLevel); var converters = new PropertyValueConverterCollection(() => new IPropertyValueConverter[] { converter, }); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType = new DataType( new VoidEditor( Mock.Of <IDataValueEditorFactory>()), new ConfigurationEditorJsonSerializer()) { Id = 1 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield); var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } IPublishedContentType setType1 = publishedContentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "set1", CreatePropertyTypes); var elementsCache = new FastDictionaryAppCache(); var snapshotCache = new FastDictionaryAppCache(); var publishedSnapshot = new Mock <IPublishedSnapshot>(); publishedSnapshot.Setup(x => x.SnapshotCache).Returns(snapshotCache); publishedSnapshot.Setup(x => x.ElementsCache).Returns(elementsCache); var publishedSnapshotAccessor = new Mock <IPublishedSnapshotAccessor>(); var localPublishedSnapshot = publishedSnapshot.Object; publishedSnapshotAccessor.Setup(x => x.TryGetPublishedSnapshot(out localPublishedSnapshot)).Returns(true); // pretend we're creating this set as a value for a property // referenceCacheLevel is the cache level for this fictious property // converterCacheLevel is the cache level specified by the converter var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "1234" } }, false, referenceCacheLevel, publishedSnapshotAccessor.Object); Assert.AreEqual(1234, set1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(1, converter.InterConverts); Assert.AreEqual(elementsCount1, elementsCache.Count); Assert.AreEqual(snapshotCount1, snapshotCache.Count); Assert.AreEqual(1234, set1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(interConverts, converter.InterConverts); Assert.AreEqual(elementsCount2, elementsCache.Count); Assert.AreEqual(snapshotCount2, snapshotCache.Count); FastDictionaryAppCache oldSnapshotCache = snapshotCache; snapshotCache.Clear(); Assert.AreEqual(1234, set1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(elementsCount2, elementsCache.Count); Assert.AreEqual(snapshotCount2, snapshotCache.Count); Assert.AreEqual(snapshotCount2, oldSnapshotCache.Count); Assert.AreEqual((interConverts == 1 ? 1 : 3) + snapshotCache.Count, converter.InterConverts); FastDictionaryAppCache oldElementsCache = elementsCache; elementsCache.Clear(); Assert.AreEqual(1234, set1.Value(Mock.Of <IPublishedValueFallback>(), "prop1")); Assert.AreEqual(1, converter.SourceConverts); Assert.AreEqual(elementsCount2, elementsCache.Count); Assert.AreEqual(elementsCount2, oldElementsCache.Count); Assert.AreEqual(snapshotCount2, snapshotCache.Count); Assert.AreEqual((interConverts == 1 ? 1 : 4) + snapshotCache.Count + elementsCache.Count, converter.InterConverts); }
private (IPublishedContentType, IPublishedContentType) CreateContentTypes() { Current.Reset(); var logger = Mock.Of <ILogger>(); var profiler = Mock.Of <IProfiler>(); var proflog = new ProfilingLogger(logger, profiler); PropertyEditorCollection editors = null; var editor = new NestedContentPropertyEditor(logger, new Lazy <PropertyEditorCollection>(() => editors)); editors = new PropertyEditorCollection(new DataEditorCollection(new DataEditor[] { editor })); var dataType1 = new DataType(editor) { Id = 1, Configuration = new NestedContentConfiguration { MinItems = 1, MaxItems = 1, ContentTypes = new[] { new NestedContentConfiguration.ContentType { Alias = "contentN1" } } } }; var dataType2 = new DataType(editor) { Id = 2, Configuration = new NestedContentConfiguration { MinItems = 1, MaxItems = 99, ContentTypes = new[] { new NestedContentConfiguration.ContentType { Alias = "contentN1" } } } }; var dataType3 = new DataType(new TextboxPropertyEditor(logger)) { Id = 3 }; // mocked dataservice returns nested content preValues var dataTypeService = new TestObjects.TestDataTypeService(dataType1, dataType2, dataType3); var publishedModelFactory = new Mock <IPublishedModelFactory>(); // mocked model factory returns model type var modelTypes = new Dictionary <string, Type> { { "contentN1", typeof(TestElementModel) } }; publishedModelFactory .Setup(x => x.MapModelType(It.IsAny <Type>())) .Returns((Type type) => ModelType.Map(type, modelTypes)); // mocked model factory creates models publishedModelFactory .Setup(x => x.CreateModel(It.IsAny <IPublishedElement>())) .Returns((IPublishedElement element) => { if (element.ContentType.Alias.InvariantEquals("contentN1")) { return(new TestElementModel(element)); } return(element); }); // mocked model factory creates model lists publishedModelFactory .Setup(x => x.CreateModelList(It.IsAny <string>())) .Returns((string alias) => { return(alias == "contentN1" ? (IList) new List <TestElementModel>() : (IList) new List <IPublishedElement>()); }); var contentCache = new Mock <IPublishedContentCache>(); var publishedSnapshot = new Mock <IPublishedSnapshot>(); // mocked published snapshot returns a content cache publishedSnapshot .Setup(x => x.Content) .Returns(contentCache.Object); var publishedSnapshotAccessor = new Mock <IPublishedSnapshotAccessor>(); // mocked published snapshot accessor returns a facade publishedSnapshotAccessor .Setup(x => x.PublishedSnapshot) .Returns(publishedSnapshot.Object); var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[] { new NestedContentSingleValueConverter(publishedSnapshotAccessor.Object, publishedModelFactory.Object, proflog), new NestedContentManyValueConverter(publishedSnapshotAccessor.Object, publishedModelFactory.Object, proflog), }); var factory = new PublishedContentTypeFactory(publishedModelFactory.Object, converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes1(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "property1", 1)); } IEnumerable <IPublishedPropertyType> CreatePropertyTypes2(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "property2", 2)); } IEnumerable <IPublishedPropertyType> CreatePropertyTypesN1(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "propertyN1", 3)); } var contentType1 = factory.CreateContentType(1, "content1", CreatePropertyTypes1); var contentType2 = factory.CreateContentType(2, "content2", CreatePropertyTypes2); var contentTypeN1 = factory.CreateContentType(2, "contentN1", CreatePropertyTypesN1, isElement: true); // mocked content cache returns content types contentCache .Setup(x => x.GetContentType(It.IsAny <string>())) .Returns((string alias) => { if (alias.InvariantEquals("contentN1")) { return(contentTypeN1); } return(null); }); return(contentType1, contentType2); }
private void Init() { Current.Reset(); var factory = Mock.Of <IFactory>(); Current.Factory = factory; var configs = new Configs(); Mock.Get(factory).Setup(x => x.GetInstance(typeof(Configs))).Returns(configs); var globalSettings = new GlobalSettings(); configs.Add(SettingsForTests.GenerateMockUmbracoSettings); configs.Add <IGlobalSettings>(() => globalSettings); var publishedModelFactory = new NoopPublishedModelFactory(); Mock.Get(factory).Setup(x => x.GetInstance(typeof(IPublishedModelFactory))).Returns(publishedModelFactory); // create a content node kit var kit = new ContentNodeKit { ContentTypeId = 2, Node = new ContentNode(1, Guid.NewGuid(), 0, "-1,1", 0, -1, DateTime.Now, 0), DraftData = new ContentData { Name = "It Works2!", Published = false, TemplateId = 0, VersionId = 2, VersionDate = DateTime.Now, WriterId = 0, Properties = new Dictionary <string, PropertyData[]> { { "prop", new[] { new PropertyData { Culture = "", Segment = "", Value = "val2" }, new PropertyData { Culture = "fr-FR", Segment = "", Value = "val-fr2" }, new PropertyData { Culture = "en-UK", Segment = "", Value = "val-uk2" }, new PropertyData { Culture = "dk-DA", Segment = "", Value = "val-da2" }, new PropertyData { Culture = "de-DE", Segment = "", Value = "val-de2" } } } }, CultureInfos = new Dictionary <string, CultureVariation> { // draft data = everything, and IsDraft indicates what's edited { "fr-FR", new CultureVariation { Name = "name-fr2", IsDraft = true, Date = new DateTime(2018, 01, 03, 01, 00, 00) } }, { "en-UK", new CultureVariation { Name = "name-uk2", IsDraft = true, Date = new DateTime(2018, 01, 04, 01, 00, 00) } }, { "dk-DA", new CultureVariation { Name = "name-da2", IsDraft = true, Date = new DateTime(2018, 01, 05, 01, 00, 00) } }, { "de-DE", new CultureVariation { Name = "name-de1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00) } } } }, PublishedData = new ContentData { Name = "It Works1!", Published = true, TemplateId = 0, VersionId = 1, VersionDate = DateTime.Now, WriterId = 0, Properties = new Dictionary <string, PropertyData[]> { { "prop", new[] { new PropertyData { Culture = "", Segment = "", Value = "val1" }, new PropertyData { Culture = "fr-FR", Segment = "", Value = "val-fr1" }, new PropertyData { Culture = "en-UK", Segment = "", Value = "val-uk1" } } } }, CultureInfos = new Dictionary <string, CultureVariation> { // published data = only what's actually published, and IsDraft has to be false { "fr-FR", new CultureVariation { Name = "name-fr1", IsDraft = false, Date = new DateTime(2018, 01, 01, 01, 00, 00) } }, { "en-UK", new CultureVariation { Name = "name-uk1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00) } }, { "de-DE", new CultureVariation { Name = "name-de1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00) } } } } }; // create a data source for NuCache var dataSource = new TestDataSource(kit); var runtime = Mock.Of <IRuntimeState>(); Mock.Get(runtime).Setup(x => x.Level).Returns(RuntimeLevel.Run); // create data types, property types and content types var dataType = new DataType(new VoidEditor("Editor", Mock.Of <ILogger>())) { Id = 3 }; var dataTypes = new[] { dataType }; _propertyType = new PropertyType("Umbraco.Void.Editor", ValueStorageType.Nvarchar) { Alias = "prop", DataTypeId = 3, Variations = ContentVariation.Culture }; _contentType = new ContentType(-1) { Id = 2, Alias = "alias-ct", Variations = ContentVariation.Culture }; _contentType.AddPropertyType(_propertyType); var contentTypes = new[] { _contentType }; var contentTypeService = new Mock <IContentTypeService>(); contentTypeService.Setup(x => x.GetAll()).Returns(contentTypes); contentTypeService.Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(contentTypes); var mediaTypeService = new Mock <IMediaTypeService>(); mediaTypeService.Setup(x => x.GetAll()).Returns(Enumerable.Empty <IMediaType>()); mediaTypeService.Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(Enumerable.Empty <IMediaType>()); var contentTypeServiceBaseFactory = new Mock <IContentTypeBaseServiceProvider>(); contentTypeServiceBaseFactory.Setup(x => x.For(It.IsAny <IContentBase>())).Returns(contentTypeService.Object); var dataTypeService = Mock.Of <IDataTypeService>(); Mock.Get(dataTypeService).Setup(x => x.GetAll()).Returns(dataTypes); // create a service context var serviceContext = ServiceContext.CreatePartial( dataTypeService: dataTypeService, memberTypeService: Mock.Of <IMemberTypeService>(), memberService: Mock.Of <IMemberService>(), contentTypeService: contentTypeService.Object, mediaTypeService: mediaTypeService.Object, localizationService: Mock.Of <ILocalizationService>(), domainService: Mock.Of <IDomainService>() ); // create a scope provider var scopeProvider = Mock.Of <IScopeProvider>(); Mock.Get(scopeProvider) .Setup(x => x.CreateScope( It.IsAny <IsolationLevel>(), It.IsAny <RepositoryCacheMode>(), It.IsAny <IEventDispatcher>(), It.IsAny <bool?>(), It.IsAny <bool>(), It.IsAny <bool>())) .Returns(Mock.Of <IScope>); // create a published content type factory var contentTypeFactory = new PublishedContentTypeFactory( Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); // create a variation accessor _variationAccesor = new TestVariationContextAccessor(); // at last, create the complete NuCache snapshot service! var options = new PublishedSnapshotServiceOptions { IgnoreLocalDb = true }; _snapshotService = new PublishedSnapshotService(options, null, runtime, serviceContext, contentTypeFactory, null, new TestPublishedSnapshotAccessor(), _variationAccesor, Mock.Of <IProfilingLogger>(), scopeProvider, Mock.Of <IDocumentRepository>(), Mock.Of <IMediaRepository>(), Mock.Of <IMemberRepository>(), new TestDefaultCultureAccessor(), dataSource, globalSettings, Mock.Of <IEntityXmlSerializer>(), Mock.Of <IPublishedModelFactory>(), new UrlSegmentProviderCollection(new[] { new DefaultUrlSegmentProvider() })); // invariant is the current default _variationAccesor.VariationContext = new VariationContext(); Mock.Get(factory).Setup(x => x.GetInstance(typeof(IVariationContextAccessor))).Returns(_variationAccesor); }
internal override void PopulateCache(PublishedContentTypeFactory factory, SolidPublishedContentCache cache) { var prop1Type = factory.CreatePropertyType("prop1", 1, variations: ContentVariation.Culture); var welcomeType = factory.CreatePropertyType("welcomeText", 1, variations: ContentVariation.Culture); var welcome2Type = factory.CreatePropertyType("welcomeText2", 1, variations: ContentVariation.Culture); var nopropType = factory.CreatePropertyType("noprop", 1, variations: ContentVariation.Culture); IEnumerable <IPublishedPropertyType> CreatePropertyTypes1(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "prop1", 1, variations: ContentVariation.Culture)); yield return(factory.CreatePropertyType(contentType, "welcomeText", 1, variations: ContentVariation.Culture)); yield return(factory.CreatePropertyType(contentType, "welcomeText2", 1, variations: ContentVariation.Culture)); yield return(factory.CreatePropertyType(contentType, "noprop", 1, variations: ContentVariation.Culture)); } var contentType1 = factory.CreateContentType(Guid.NewGuid(), 1, "ContentType1", Enumerable.Empty <string>(), CreatePropertyTypes1); IEnumerable <IPublishedPropertyType> CreatePropertyTypes2(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "prop3", 1, variations: ContentVariation.Culture)); } var contentType2 = factory.CreateContentType(Guid.NewGuid(), 2, "contentType2", Enumerable.Empty <string>(), CreatePropertyTypes2); var prop1 = new SolidPublishedPropertyWithLanguageVariants { Alias = "welcomeText", PropertyType = welcomeType }; prop1.SetSourceValue("en-US", "Welcome", true); prop1.SetValue("en-US", "Welcome", true); prop1.SetSourceValue("de", "Willkommen"); prop1.SetValue("de", "Willkommen"); prop1.SetSourceValue("nl", "Welkom"); prop1.SetValue("nl", "Welkom"); var prop2 = new SolidPublishedPropertyWithLanguageVariants { Alias = "welcomeText2", PropertyType = welcome2Type }; prop2.SetSourceValue("en-US", "Welcome", true); prop2.SetValue("en-US", "Welcome", true); var prop3 = new SolidPublishedPropertyWithLanguageVariants { Alias = "welcomeText", PropertyType = welcomeType }; prop3.SetSourceValue("en-US", "Welcome", true); prop3.SetValue("en-US", "Welcome", true); var noprop = new SolidPublishedProperty { Alias = "noprop", PropertyType = nopropType }; noprop.SolidHasValue = false; // has no value noprop.SolidValue = "xxx"; // but returns something var item1 = new SolidPublishedContent(contentType1) { Id = 1, SortOrder = 0, Name = "Content 1", UrlSegment = "content-1", Path = "/1", Level = 1, Url = "/content-1", ParentId = -1, ChildIds = new[] { 2 }, Properties = new Collection <IPublishedProperty> { prop1, prop2, noprop } }; var item2 = new SolidPublishedContent(contentType1) { Id = 2, SortOrder = 0, Name = "Content 2", UrlSegment = "content-2", Path = "/1/2", Level = 2, Url = "/content-1/content-2", ParentId = 1, ChildIds = new int[] { 3 }, Properties = new Collection <IPublishedProperty> { prop3 } }; var prop4 = new SolidPublishedPropertyWithLanguageVariants { Alias = "prop3", PropertyType = contentType2.GetPropertyType("prop3") }; prop4.SetSourceValue("en-US", "Oxxo", true); prop4.SetValue("en-US", "Oxxo", true); var item3 = new SolidPublishedContent(contentType2) { Id = 3, SortOrder = 0, Name = "Content 3", UrlSegment = "content-3", Path = "/1/2/3", Level = 3, Url = "/content-1/content-2/content-3", ParentId = 2, ChildIds = new int[] { }, Properties = new Collection <IPublishedProperty> { prop4 } }; item1.Children = new List <IPublishedContent> { item2 }; item2.Parent = item1; item2.Children = new List <IPublishedContent> { item3 }; item3.Parent = item2; cache.Add(item1); cache.Add(item2); cache.Add(item3); }
private (IPublishedContentType, IPublishedContentType) CreateContentTypes() { var logger = Mock.Of <ILogger <ProfilingLogger> >(); var loggerFactory = NullLoggerFactory.Instance; var profiler = Mock.Of <IProfiler>(); var proflog = new ProfilingLogger(logger, profiler); var localizationService = Mock.Of <ILocalizationService>(); PropertyEditorCollection editors = null; var editor = new NestedContentPropertyEditor(Mock.Of <IDataValueEditorFactory>(), Mock.Of <IIOHelper>(), Mock.Of <IEditorConfigurationParser>()); editors = new PropertyEditorCollection(new DataEditorCollection(() => new DataEditor[] { editor })); var serializer = new ConfigurationEditorJsonSerializer(); var dataType1 = new DataType(editor, serializer) { Id = 1, Configuration = new NestedContentConfiguration { MinItems = 1, MaxItems = 1, ContentTypes = new[] { new NestedContentConfiguration.ContentType { Alias = "contentN1" } }, }, }; var dataType2 = new DataType(editor, serializer) { Id = 2, Configuration = new NestedContentConfiguration { MinItems = 1, MaxItems = 99, ContentTypes = new[] { new NestedContentConfiguration.ContentType { Alias = "contentN1" } }, }, }; var dataType3 = new DataType( new TextboxPropertyEditor(Mock.Of <IDataValueEditorFactory>(), Mock.Of <IIOHelper>(), Mock.Of <IEditorConfigurationParser>()), serializer) { Id = 3 }; // mocked dataservice returns nested content preValues var dataTypeServiceMock = new Mock <IDataTypeService>(); dataTypeServiceMock.Setup(x => x.GetAll()).Returns(new[] { dataType1, dataType2, dataType3 }); var publishedModelFactory = new Mock <IPublishedModelFactory>(); // mocked model factory returns model type var modelTypes = new Dictionary <string, Type> { { "contentN1", typeof(TestElementModel) } }; publishedModelFactory .Setup(x => x.MapModelType(It.IsAny <Type>())) .Returns((Type type) => ModelType.Map(type, modelTypes)); // mocked model factory creates models publishedModelFactory .Setup(x => x.CreateModel(It.IsAny <IPublishedElement>())) .Returns((IPublishedElement element) => { if (element.ContentType.Alias.InvariantEquals("contentN1")) { return(new TestElementModel(element, Mock.Of <IPublishedValueFallback>())); } return(element); }); // mocked model factory creates model lists publishedModelFactory .Setup(x => x.CreateModelList(It.IsAny <string>())) .Returns((string alias) => alias == "contentN1" ? new List <TestElementModel>() : new List <IPublishedElement>()); var contentCache = new Mock <IPublishedContentCache>(); var publishedSnapshot = new Mock <IPublishedSnapshot>(); // mocked published snapshot returns a content cache publishedSnapshot .Setup(x => x.Content) .Returns(contentCache.Object); var publishedSnapshotAccessor = new Mock <IPublishedSnapshotAccessor>(); // mocked published snapshot accessor returns a facade var localPublishedSnapshot = publishedSnapshot.Object; publishedSnapshotAccessor .Setup(x => x.TryGetPublishedSnapshot(out localPublishedSnapshot)) .Returns(true); var converters = new PropertyValueConverterCollection(() => new IPropertyValueConverter[] { new NestedContentSingleValueConverter(publishedSnapshotAccessor.Object, publishedModelFactory.Object, proflog), new NestedContentManyValueConverter(publishedSnapshotAccessor.Object, publishedModelFactory.Object, proflog), }); var factory = new PublishedContentTypeFactory(publishedModelFactory.Object, converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes1(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "property1", 1)); } IEnumerable <IPublishedPropertyType> CreatePropertyTypes2(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "property2", 2)); } IEnumerable <IPublishedPropertyType> CreatePropertyTypesN1(IPublishedContentType contentType) { yield return(factory.CreatePropertyType(contentType, "propertyN1", 3)); } var contentType1 = factory.CreateContentType(Guid.NewGuid(), 1, "content1", CreatePropertyTypes1); var contentType2 = factory.CreateContentType(Guid.NewGuid(), 2, "content2", CreatePropertyTypes2); var contentTypeN1 = factory.CreateContentType(Guid.NewGuid(), 2, "contentN1", CreatePropertyTypesN1, isElement: true); // mocked content cache returns content types contentCache .Setup(x => x.GetContentType(It.IsAny <string>())) .Returns((string alias) => { if (alias.InvariantEquals("contentN1")) { return(contentTypeN1); } return(null); }); return(contentType1, contentType2); }