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 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); }); }
public void DropDownValueEditor_Format_Data_For_Cache() { var dataType = new DataType(new CheckBoxListPropertyEditor(Mock.Of <ILogger>(), Mock.Of <ILocalizedTextService>())) { Configuration = new ValueListConfiguration { Items = new List <ValueListConfiguration.ValueListItem> { new ValueListConfiguration.ValueListItem { Id = 10, Value = "Value 1" }, new ValueListConfiguration.ValueListItem { Id = 1234, Value = "Value 2" }, new ValueListConfiguration.ValueListItem { Id = 11, Value = "Value 3" } } }, Id = 1 }; var dataTypeService = new TestObjects.TestDataTypeService(dataType); var prop = new Property(1, new PropertyType(dataType)); prop.SetValue("Value 2"); var result = dataType.Editor.GetValueEditor().ConvertDbToString(prop.PropertyType, prop.GetValue(), dataTypeService); Assert.AreEqual("Value 2", result); }
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; }
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; }
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(); } }
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 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); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType) { yield return(publishedContentTypeFactory.CreatePropertyType(contentType, "prop1", 1)); } var setType1 = publishedContentTypeFactory.CreateContentType(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("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); }
protected override void Compose() { base.Compose(); _publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>(); Builder.Services.AddUnique <IPublishedSnapshotAccessor>(_publishedSnapshotAccessorMock.Object); Builder.Services.AddUnique <IPublishedModelFactory>(f => new PublishedModelFactory(f.GetRequiredService <TypeLoader>().GetTypes <PublishedContentModel>(), f.GetRequiredService <IPublishedValueFallback>())); Builder.Services.AddUnique <IPublishedContentTypeFactory, PublishedContentTypeFactory>(); Builder.Services.AddUnique <IPublishedValueFallback, PublishedValueFallback>(); var loggerFactory = NullLoggerFactory.Instance; var mediaService = Mock.Of <IMediaService>(); var contentTypeBaseServiceProvider = Mock.Of <IContentTypeBaseServiceProvider>(); var umbracoContextAccessor = Mock.Of <IUmbracoContextAccessor>(); var backOfficeSecurityAccessor = Mock.Of <IBackOfficeSecurityAccessor>(); var publishedUrlProvider = Mock.Of <IPublishedUrlProvider>(); var imageSourceParser = new HtmlImageSourceParser(publishedUrlProvider); var serializer = new ConfigurationEditorJsonSerializer(); var mediaFileService = new MediaFileManager(Mock.Of <IFileSystem>(), Mock.Of <IMediaPathScheme>(), loggerFactory.CreateLogger <MediaFileManager>(), Mock.Of <IShortStringHelper>()); var pastedImages = new RichTextEditorPastedImages(umbracoContextAccessor, loggerFactory.CreateLogger <RichTextEditorPastedImages>(), HostingEnvironment, mediaService, contentTypeBaseServiceProvider, mediaFileService, ShortStringHelper, publishedUrlProvider, serializer); var linkParser = new HtmlLocalLinkParser(umbracoContextAccessor, publishedUrlProvider); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(DataValueEditorFactory), serializer) { Id = 1 }, new DataType(new TrueFalsePropertyEditor(DataValueEditorFactory, IOHelper), serializer) { Id = 1001 }, new DataType(new RichTextPropertyEditor(DataValueEditorFactory, backOfficeSecurityAccessor, imageSourceParser, linkParser, pastedImages, IOHelper, Mock.Of <IImageUrlGenerator>()), serializer) { Id = 1002 }, new DataType(new IntegerPropertyEditor(DataValueEditorFactory), serializer) { Id = 1003 }, new DataType(new TextboxPropertyEditor(DataValueEditorFactory, IOHelper), serializer) { Id = 1004 }, new DataType(new MediaPickerPropertyEditor(DataValueEditorFactory, IOHelper), serializer) { Id = 1005 }); Builder.Services.AddUnique <IDataTypeService>(f => dataTypeService); }
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); }
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")); }
protected override void Compose() { base.Compose(); _publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>(); Composition.RegisterUnique <IPublishedSnapshotAccessor>(_publishedSnapshotAccessorMock.Object); Composition.RegisterUnique <IPublishedModelFactory>(f => new PublishedModelFactory(f.GetInstance <TypeLoader>().GetTypes <PublishedContentModel>())); Composition.RegisterUnique <IPublishedContentTypeFactory, PublishedContentTypeFactory>(); Composition.RegisterUnique <IPublishedValueFallback, PublishedValueFallback>(); var logger = Mock.Of <ILogger>(); var mediaService = Mock.Of <IMediaService>(); var contentTypeBaseServiceProvider = Mock.Of <IContentTypeBaseServiceProvider>(); var umbracoContextAccessor = Mock.Of <IUmbracoContextAccessor>(); var imageSourceParser = new HtmlImageSourceParser(umbracoContextAccessor); var pastedImages = new RichTextEditorPastedImages(umbracoContextAccessor, logger, mediaService, contentTypeBaseServiceProvider); var linkParser = new HtmlLocalLinkParser(umbracoContextAccessor); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(logger)) { Id = 1 }, new DataType(new TrueFalsePropertyEditor(logger)) { Id = 1001 }, new DataType(new RichTextPropertyEditor(logger, umbracoContextAccessor, imageSourceParser, linkParser, pastedImages, Mock.Of <IImageUrlGenerator>())) { Id = 1002 }, new DataType(new IntegerPropertyEditor(logger)) { Id = 1003 }, new DataType(new TextboxPropertyEditor(logger)) { Id = 1004 }, new DataType(new MediaPickerPropertyEditor(logger)) { Id = 1005 }); Composition.RegisterUnique <IDataTypeService>(f => dataTypeService); }
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; }
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")); }
protected override void Compose() { base.Compose(); _publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>(); Composition.RegisterUnique <IPublishedSnapshotAccessor>(_publishedSnapshotAccessorMock.Object); Composition.RegisterUnique <IPublishedModelFactory>(f => new PublishedModelFactory(f.GetInstance <TypeLoader>().GetTypes <PublishedContentModel>())); Composition.RegisterUnique <IPublishedContentTypeFactory, PublishedContentTypeFactory>(); Composition.RegisterUnique <IPublishedValueFallback, PublishedValueFallback>(); var logger = Mock.Of <ILogger>(); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(logger)) { Id = 1 }, new DataType(new TrueFalsePropertyEditor(logger)) { Id = 1001 }, new DataType(new RichTextPropertyEditor(logger)) { Id = 1002 }, new DataType(new IntegerPropertyEditor(logger)) { Id = 1003 }, new DataType(new TextboxPropertyEditor(logger)) { Id = 1004 }, new DataType(new MediaPickerPropertyEditor(logger)) { Id = 1005 }); Composition.RegisterUnique <IDataTypeService>(f => dataTypeService); }
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); }
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); }
public void SimpleConverter3Test() { Current.Reset(); var register = RegisterFactory.Create(); var composition = new Composition(register, new TypeLoader(), Mock.Of <IProfilingLogger>(), ComponentTests.MockRuntimeState(RuntimeLevel.Run)); composition.WithCollectionBuilder <PropertyValueConverterCollectionBuilder>() .Append <SimpleConverter3A>() .Append <SimpleConverter3B>(); IPublishedModelFactory factory = new PublishedModelFactory(new[] { typeof(PublishedSnapshotTestObjects.TestElementModel1), typeof(PublishedSnapshotTestObjects.TestElementModel2), typeof(PublishedSnapshotTestObjects.TestContentModel1), typeof(PublishedSnapshotTestObjects.TestContentModel2), }); register.Register(f => factory); Current.Factory = composition.CreateFactory(); 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); register.Register(f => publishedSnapshotAccessorMock.Object); var converters = Current.Factory.GetInstance <PropertyValueConverterCollection>(); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(Mock.Of <ILogger>())) { Id = 1 }, new DataType(new VoidEditor("2", Mock.Of <ILogger>())) { Id = 2 }); var contentTypeFactory = new PublishedContentTypeFactory(factory, converters, dataTypeService); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType, int i) { yield return(contentTypeFactory.CreatePropertyType(contentType, "prop" + i, i)); } var elementType1 = contentTypeFactory.CreateContentType(1000, "element1", t => CreatePropertyTypes(t, 1)); var elementType2 = contentTypeFactory.CreateContentType(1001, "element2", t => CreatePropertyTypes(t, 2)); var contentType1 = contentTypeFactory.CreateContentType(1002, "content1", t => CreatePropertyTypes(t, 1)); var contentType2 = contentTypeFactory.CreateContentType(1003, "content2", t => CreatePropertyTypes(t, 2)); var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary <string, object> { { "prop1", "val1" } }, false); var element2 = new PublishedElement(elementType2, Guid.NewGuid(), new Dictionary <string, object> { { "prop2", "1003" } }, false); var cnt1 = new SolidPublishedContent(contentType1) { Id = 1003, Properties = new[] { new SolidPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = "val1" } } }; var cnt2 = new SolidPublishedContent(contentType1) { Id = 1004, Properties = new[] { new SolidPublishedProperty { Alias = "prop2", SolidHasValue = true, SolidValue = "1003" } } }; cacheContent[cnt1.Id] = cnt1.CreateModel(); cacheContent[cnt2.Id] = cnt2.CreateModel(); // can get the actual property Clr type // ie ModelType gets properly mapped by IPublishedContentModelFactory // must test ModelClrType with special equals 'cos they are not ref-equals Assert.IsTrue(ModelType.Equals(typeof(IEnumerable <>).MakeGenericType(ModelType.For("content1")), contentType2.GetPropertyType("prop2").ModelClrType)); Assert.AreEqual(typeof(IEnumerable <PublishedSnapshotTestObjects.TestContentModel1>), contentType2.GetPropertyType("prop2").ClrType); // can create a model for an element var model1 = factory.CreateModel(element1); Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestElementModel1>(model1); Assert.AreEqual("val1", ((PublishedSnapshotTestObjects.TestElementModel1)model1).Prop1); // can create a model for a published content var model2 = factory.CreateModel(element2); Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestElementModel2>(model2); var mmodel2 = (PublishedSnapshotTestObjects.TestElementModel2)model2; // and get direct property Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestContentModel1[]>(model2.Value("prop2")); Assert.AreEqual(1, ((PublishedSnapshotTestObjects.TestContentModel1[])model2.Value("prop2")).Length); // and get model property Assert.IsInstanceOf <IEnumerable <PublishedSnapshotTestObjects.TestContentModel1> >(mmodel2.Prop2); Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestContentModel1[]>(mmodel2.Prop2); var mmodel1 = mmodel2.Prop2.First(); // and we get what we want Assert.AreSame(cacheContent[mmodel1.Id], mmodel1); }