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; }
public void CanConvertImageCropperPropertyEditor(string val1, string val2, bool expected) { try { var container = RegisterFactory.Create(); var composition = new Composition(container, TestHelper.GetMockedTypeLoader(), 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 dataTypeService = new TestObjects.TestDataTypeService( new DataType(new ImageCropperPropertyEditor(Mock.Of <ILogger>(), mediaFileSystem, Mock.Of <IContentSection>(), Mock.Of <IDataTypeService>())) { Id = 1 }); 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 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 (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); }
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); }
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); }
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); }
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))))); }
public void SimpleConverter3Test() { var register = new ServiceCollection(); var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader()); composition.WithCollectionBuilder <PropertyValueConverterCollectionBuilder>() .Append <SimpleConverter3A>() .Append <SimpleConverter3B>(); IPublishedModelFactory factory = new PublishedModelFactory( new[] { typeof(PublishedSnapshotTestObjects.TestElementModel1), typeof(PublishedSnapshotTestObjects.TestElementModel2), typeof(PublishedSnapshotTestObjects.TestContentModel1), typeof(PublishedSnapshotTestObjects.TestContentModel2) }, Mock.Of <IPublishedValueFallback>()); register.AddTransient(f => factory); 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>(); var localPublishedSnapshot = publishedSnapshotMock.Object; publishedSnapshotAccessorMock.Setup(x => x.TryGetPublishedSnapshot(out localPublishedSnapshot)).Returns(true); register.AddTransient(f => publishedSnapshotAccessorMock.Object); IServiceProvider registerFactory = composition.CreateServiceProvider(); PropertyValueConverterCollection converters = registerFactory.GetRequiredService <PropertyValueConverterCollection>(); var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeServiceMock = new Mock <IDataTypeService>(); var dataType1 = new DataType( new VoidEditor( Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 1 }; var dataType2 = new DataType( new VoidEditor( "2", Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 2 }; dataTypeServiceMock.Setup(x => x.GetAll()).Returns(new[] { dataType1, dataType2 }); var contentTypeFactory = new PublishedContentTypeFactory(factory, converters, dataTypeServiceMock.Object); IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType, int i) { yield return(contentTypeFactory.CreatePropertyType(contentType, "prop" + i, i)); } IPublishedContentType elementType1 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "element1", t => CreatePropertyTypes(t, 1)); IPublishedContentType elementType2 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 1001, "element2", t => CreatePropertyTypes(t, 2)); IPublishedContentType contentType1 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 1002, "content1", t => CreatePropertyTypes(t, 1)); IPublishedContentType contentType2 = contentTypeFactory.CreateContentType(Guid.NewGuid(), 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 InternalPublishedContent(contentType1) { Id = 1003, Properties = new[] { new InternalPublishedProperty { Alias = "prop1", SolidHasValue = true, SolidValue = "val1" } } }; var cnt2 = new InternalPublishedContent(contentType1) { Id = 1004, Properties = new[] { new InternalPublishedProperty { Alias = "prop2", SolidHasValue = true, SolidValue = "1003" } } }; IPublishedModelFactory publishedModelFactory = registerFactory.GetRequiredService <IPublishedModelFactory>(); cacheContent[cnt1.Id] = cnt1.CreateModel(publishedModelFactory); cacheContent[cnt2.Id] = cnt2.CreateModel(publishedModelFactory); // 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 IPublishedElement model1 = factory.CreateModel(element1); Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestElementModel1>(model1); Assert.AreEqual("val1", ((PublishedSnapshotTestObjects.TestElementModel1)model1).Prop1); // can create a model for a published content IPublishedElement model2 = factory.CreateModel(element2); Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestElementModel2>(model2); var mmodel2 = (PublishedSnapshotTestObjects.TestElementModel2)model2; // and get direct property Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestContentModel1[]>( model2.Value(Mock.Of <IPublishedValueFallback>(), "prop2")); Assert.AreEqual( 1, ((PublishedSnapshotTestObjects.TestContentModel1[])model2.Value(Mock.Of <IPublishedValueFallback>(), "prop2")).Length); // and get model property Assert.IsInstanceOf <IEnumerable <PublishedSnapshotTestObjects.TestContentModel1> >(mmodel2.Prop2); Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestContentModel1[]>(mmodel2.Prop2); PublishedSnapshotTestObjects.TestContentModel1 mmodel1 = mmodel2.Prop2.First(); // and we get what we want Assert.AreSame(cacheContent[mmodel1.Id], mmodel1); }
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); }
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); }
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" } } }); }
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 prop1Type = factory.CreatePropertyType("prop1", 1); var welcomeType = factory.CreatePropertyType("welcomeText", 1); var welcome2Type = factory.CreatePropertyType("welcomeText2", 1); var props = new[] { prop1Type, welcomeType, welcome2Type, }; var contentType1 = factory.CreateContentType(1, "ContentType1", Enumerable.Empty <string>(), props); 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 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 } }; 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[] { }, Properties = new Collection <IPublishedProperty> { prop3 } }; item1.Children = new List <IPublishedContent> { item2 }; item2.Parent = item1; cache.Add(item1); cache.Add(item2); }