private static PropertyValidationService GetPropertyValidationService() { IIOHelper ioHelper = Mock.Of <IIOHelper>(); IDataTypeService dataTypeService = Mock.Of <IDataTypeService>(); ILocalizedTextService localizedTextService = Mock.Of <ILocalizedTextService>(); IEditorConfigurationParser editorConfigurationParser = Mock.Of <IEditorConfigurationParser>(); var attribute = new DataEditorAttribute("a", "a", "a"); IDataValueEditorFactory dataValueEditorFactory = Mock.Of <IDataValueEditorFactory>(x => x.Create <TextOnlyValueEditor>(It.IsAny <DataEditorAttribute>()) == new TextOnlyValueEditor(attribute, localizedTextService, Mock.Of <IShortStringHelper>(), new JsonNetSerializer(), Mock.Of <IIOHelper>())); var textBoxEditor = new TextboxPropertyEditor( dataValueEditorFactory, ioHelper, editorConfigurationParser); var serializer = new ConfigurationEditorJsonSerializer(); var mockDataTypeService = new Mock <IDataTypeService>(); Mock.Get(dataTypeService).Setup(x => x.GetDataType(It.Is <int>(y => y == Constants.DataTypes.Textbox))) .Returns(new DataType(textBoxEditor, serializer)); var propertyEditorCollection = new PropertyEditorCollection(new DataEditorCollection(() => new[] { textBoxEditor })); return(new PropertyValidationService( propertyEditorCollection, dataTypeService, localizedTextService, new ValueEditorCache())); }
private IPublishedContent GetContent(bool createChildren, int indexVals) { var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(DataValueEditorFactory), serializer) { Id = 1 }); var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); var contentTypeAlias = createChildren ? "Parent" : "Child"; var contentType = new PublishedContentType(Guid.NewGuid(), 22, contentTypeAlias, PublishedItemType.Content, Enumerable.Empty <string>(), Enumerable.Empty <PublishedPropertyType>(), ContentVariation.Nothing); var d = new SolidPublishedContent(contentType) { CreateDate = DateTime.Now, CreatorId = 1, Id = 3, SortOrder = 4, TemplateId = 5, UpdateDate = DateTime.Now, Path = "-1,3", UrlSegment = "home-page", Name = "Page" + Guid.NewGuid(), Version = Guid.NewGuid(), WriterId = 1, 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))); } return(d); }
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")); }
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); }
public void DropDownMultipleValueEditor_Format_Data_For_Cache() { var dataValueEditorFactoryMock = new Mock <IDataValueEditorFactory>(); var serializer = new ConfigurationEditorJsonSerializer(); var checkBoxListPropertyEditor = new CheckBoxListPropertyEditor(dataValueEditorFactoryMock.Object, Mock.Of <ILocalizedTextService>(), Mock.Of <IIOHelper>(), Mock.Of <IEditorConfigurationParser>()); var dataType = new DataType(checkBoxListPropertyEditor, serializer) { Configuration = new ValueListConfiguration { Items = new List <ValueListConfiguration.ValueListItem> { new ValueListConfiguration.ValueListItem { Id = 4567, Value = "Value 1" }, new ValueListConfiguration.ValueListItem { Id = 1234, Value = "Value 2" }, new ValueListConfiguration.ValueListItem { Id = 8910, Value = "Value 3" } } }, Id = 1 }; var dataTypeServiceMock = new Mock <IDataTypeService>(); dataTypeServiceMock .Setup(x => x.GetDataType(It.IsAny <int>())) .Returns(dataType); //TODO use builders instead of this mess var multipleValueEditor = new MultipleValueEditor(Mock.Of <ILocalizedTextService>(), Mock.Of <IShortStringHelper>(), Mock.Of <IJsonSerializer>(), Mock.Of <IIOHelper>(), new DataEditorAttribute(Constants.PropertyEditors.Aliases.TextBox, "Test Textbox", "textbox")); dataValueEditorFactoryMock .Setup(x => x.Create <MultipleValueEditor>(It.IsAny <DataEditorAttribute>())) .Returns(multipleValueEditor); var prop = new Property(1, new PropertyType(Mock.Of <IShortStringHelper>(), dataType)); prop.SetValue("Value 1,Value 2,Value 3"); IDataValueEditor valueEditor = dataType.Editor.GetValueEditor(); ((DataValueEditor)valueEditor).Configuration = dataType.Configuration; var result = valueEditor.ConvertDbToString(prop.PropertyType, prop.GetValue()); Assert.AreEqual("Value 1,Value 2,Value 3", result); }
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); }
private SolidPublishedSnapshot CreatePublishedSnapshot() { var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(DataValueEditorFactory), serializer) { 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 override void Setup() { base.Setup(); var dataTypes = GetDefaultDataTypes().ToList(); var serializer = new ConfigurationEditorJsonSerializer(); var rteDataType = new DataType(new VoidEditor("RTE", Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 4 }; dataTypes.Add(rteDataType); _dataTypes = dataTypes.ToArray(); _propertyDataTypes = new() {
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 GetAllReferences_All_Variants_With_IDataValueReference_Editor() { var collection = new DataValueReferenceFactoryCollection(() => Enumerable.Empty <IDataValueReferenceFactory>()); // mediaPicker does implement IDataValueReference var mediaPicker = new MediaPickerPropertyEditor( DataValueEditorFactory, IOHelper, EditorConfigurationParser); var propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => mediaPicker.Yield())); var trackedUdi1 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var trackedUdi2 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var trackedUdi3 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var trackedUdi4 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var serializer = new ConfigurationEditorJsonSerializer(); var property = new Property( new PropertyType(ShortStringHelper, new DataType(mediaPicker, serializer)) { Variations = ContentVariation.CultureAndSegment, }) { Values = new List <PropertyValue> { // Ignored (no culture) new() { EditedValue = trackedUdi1 }, new() { Culture = "en-US", EditedValue = trackedUdi2 }, new() { Culture = "en-US", Segment = "A", EditedValue = trackedUdi3 }, // Ignored (no culture) new() { Segment = "A", EditedValue = trackedUdi4 }, // Duplicate new() { Culture = "en-US", Segment = "B", EditedValue = trackedUdi3 }, }, }; var properties = new PropertyCollection { property }; var result = collection.GetAllReferences(properties, propertyEditors).ToArray(); Assert.AreEqual(2, result.Count()); Assert.AreEqual(trackedUdi2, result.ElementAt(0).Udi.ToString()); Assert.AreEqual(trackedUdi3, result.ElementAt(1).Udi.ToString()); }
protected override void Initialize() { base.Initialize(); // need to specify a custom callback for unit tests // AutoPublishedContentTypes generates properties automatically var serializer = new ConfigurationEditorJsonSerializer(); var dataTypeService = new TestObjects.TestDataTypeService( new DataType(new VoidEditor(DataValueEditorFactory), serializer) { 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 DropDownMultipleValueEditor_Format_Data_For_Cache() { var dataValueEditorFactoryMock = new Mock <IDataValueEditorFactory>(); var serializer = new ConfigurationEditorJsonSerializer(); var checkBoxListPropertyEditor = new CheckBoxListPropertyEditor( dataValueEditorFactoryMock.Object, Mock.Of <ILocalizedTextService>(), Mock.Of <IIOHelper>(), Mock.Of <IEditorConfigurationParser>()); var dataType = new DataType(checkBoxListPropertyEditor, serializer) { Configuration = new ValueListConfiguration { Items = new List <ValueListConfiguration.ValueListItem> { new() { Id = 4567, Value = "Value 1" }, new() { Id = 1234, Value = "Value 2" }, new() { Id = 8910, Value = "Value 3" }, }, },
public override void Setup() { base.Setup(); var dataTypes = GetDefaultDataTypes().ToList(); var serializer = new ConfigurationEditorJsonSerializer(); var rteDataType = new DataType(new VoidEditor("RTE", Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 4 }; dataTypes.Add(rteDataType); _dataTypes = dataTypes.ToArray(); _propertyDataTypes = new Dictionary <string, IDataType> { // defaults will just use the first one [string.Empty] = _dataTypes[0], // content uses the RTE ["content"] = _dataTypes[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); }
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 void Init() { var factory = Mock.Of <IServiceProvider>(); Current.Factory = factory; var publishedModelFactory = new NoopPublishedModelFactory(); Mock.Get(factory).Setup(x => x.GetService(typeof(IPublishedModelFactory))).Returns(publishedModelFactory); Mock.Get(factory).Setup(x => x.GetService(typeof(IPublishedValueFallback))).Returns(new NoopPublishedValueFallback()); // 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); _contentNestedDataSerializerFactory = new JsonContentNestedDataSerializerFactory(); var runtime = Mock.Of <IRuntimeState>(); Mock.Get(runtime).Setup(x => x.Level).Returns(RuntimeLevel.Run); var serializer = new ConfigurationEditorJsonSerializer(); // create data types, property types and content types var dataType = new DataType(new VoidEditor("Editor", Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 3 }; var dataTypes = new[] { dataType }; _propertyType = new PropertyType(TestHelper.ShortStringHelper, "Umbraco.Void.Editor", ValueStorageType.Nvarchar) { Alias = "prop", DataTypeId = 3, Variations = ContentVariation.Culture }; _contentType = new ContentType(TestHelper.ShortStringHelper, -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( publishedModelFactory, new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService); // create a variation accessor _variationAccesor = new TestVariationContextAccessor(); var typeFinder = TestHelper.GetTypeFinder(); var globalSettings = new GlobalSettings(); var nuCacheSettings = new NuCacheSettings(); // at last, create the complete NuCache snapshot service! var options = new PublishedSnapshotServiceOptions { IgnoreLocalDb = true }; _snapshotService = new PublishedSnapshotService( options, null, serviceContext, contentTypeFactory, new TestPublishedSnapshotAccessor(), _variationAccesor, Mock.Of <IProfilingLogger>(), NullLoggerFactory.Instance, scopeProvider, dataSource, new TestDefaultCultureAccessor(), Microsoft.Extensions.Options.Options.Create(globalSettings), Mock.Of <IEntityXmlSerializer>(), publishedModelFactory, TestHelper.GetHostingEnvironment(), Microsoft.Extensions.Options.Options.Create(nuCacheSettings), _contentNestedDataSerializerFactory); // invariant is the current default _variationAccesor.VariationContext = new VariationContext(); Mock.Get(factory).Setup(x => x.GetService(typeof(IVariationContextAccessor))).Returns(_variationAccesor); }
public void GetAllReferences_All_Variants_With_IDataValueReferenceFactory() { var collection = new DataValueReferenceFactoryCollection(() => new TestDataValueReferenceFactory().Yield()); // label does not implement IDataValueReference var labelEditor = new LabelPropertyEditor( DataValueEditorFactory, IOHelper); var propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => labelEditor.Yield())); var trackedUdi1 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var trackedUdi2 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var trackedUdi3 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var trackedUdi4 = Udi.Create(Constants.UdiEntityType.Media, Guid.NewGuid()).ToString(); var serializer = new ConfigurationEditorJsonSerializer(); var property = new Property(new PropertyType(ShortStringHelper, new DataType(labelEditor, serializer)) { Variations = ContentVariation.CultureAndSegment }) { Values = new List <PropertyValue> { // Ignored (no culture) new PropertyValue { EditedValue = trackedUdi1 }, new PropertyValue { Culture = "en-US", EditedValue = trackedUdi2 }, new PropertyValue { Culture = "en-US", Segment = "A", EditedValue = trackedUdi3 }, // Ignored (no culture) new PropertyValue { Segment = "A", EditedValue = trackedUdi4 }, // Duplicate new PropertyValue { Culture = "en-US", Segment = "B", EditedValue = trackedUdi3 } } }; var properties = new PropertyCollection { property }; IEnumerable <UmbracoEntityReference> result = collection.GetAllReferences(properties, propertyEditors); Assert.AreEqual(2, result.Count()); Assert.AreEqual(trackedUdi2, result.ElementAt(0).Udi.ToString()); Assert.AreEqual(trackedUdi3, result.ElementAt(1).Udi.ToString()); }
/// <summary> /// Generate a collection of <see cref="ContentNodeKit"/> based on legacy umbraco XML /// </summary> /// <param name="xml">The legacy umbraco XML</param> /// <param name="shortStringHelper"></param> /// <param name="contentTypes">Dynamically generates a list of <see cref="ContentType"/>s based on the XML data</param> /// <param name="dataTypes">Dynamically generates a list of <see cref="DataType"/> for tests</param> /// <returns></returns> public static IEnumerable <ContentNodeKit> GetContentNodeKits( string xml, IShortStringHelper shortStringHelper, out ContentType[] contentTypes, out DataType[] dataTypes) { // use the label data type for all data for these tests except in the case // where a property is named 'content', in which case use the RTE. var serializer = new ConfigurationEditorJsonSerializer(); var labelDataType = new DataType(new VoidEditor("Label", Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 3 }; var rteDataType = new DataType(new VoidEditor("RTE", Mock.Of <IDataValueEditorFactory>()), serializer) { Id = 4 }; dataTypes = new[] { labelDataType, rteDataType }; var kitsAndXml = new List <(ContentNodeKit kit, XElement node)>(); var xDoc = XDocument.Parse(xml); IEnumerable <XElement> nodes = xDoc.XPathSelectElements("//*[@isDoc]"); foreach (XElement node in nodes) { var id = node.AttributeValue <int>("id"); Guid key = node.AttributeValue <Guid?>("key") ?? id.ToGuid(); var propertyElements = node.Elements().Where(x => x.Attribute("id") == null); var properties = new Dictionary <string, PropertyData[]>(); foreach (XElement propertyElement in propertyElements) { properties[propertyElement.Name.LocalName] = new[] { // TODO: builder? new PropertyData { Culture = string.Empty, Segment = string.Empty, Value = propertyElement.Value } }; } var contentData = new ContentDataBuilder() .WithName(node.AttributeValue <string>("nodeName")) .WithProperties(properties) .WithPublished(true) .WithTemplateId(node.AttributeValue <int>("template")) .WithUrlSegment(node.AttributeValue <string>("urlName")) .WithVersionDate(node.AttributeValue <DateTime>("updateDate")) .WithWriterId(node.AttributeValue <int>("writerID")) .Build(); ContentNodeKit kit = ContentNodeKitBuilder.CreateWithContent( node.AttributeValue <int>("nodeType"), id, node.AttributeValue <string>("path"), node.AttributeValue <int>("sortOrder"), node.AttributeValue <int>("level"), node.AttributeValue <int>("parentID"), node.AttributeValue <int>("creatorID"), key, node.AttributeValue <DateTime>("createDate"), contentData, contentData); kitsAndXml.Add((kit, node)); } // put together the unique content types var contentTypesIdToType = new Dictionary <int, ContentType>(); foreach ((ContentNodeKit kit, XElement node) in kitsAndXml) { if (!contentTypesIdToType.TryGetValue(kit.ContentTypeId, out ContentType contentType)) { contentType = new ContentType(shortStringHelper, -1) { Id = kit.ContentTypeId, Alias = node.Name.LocalName }; SetContentTypeProperties(shortStringHelper, labelDataType, rteDataType, kit, contentType); contentTypesIdToType[kit.ContentTypeId] = contentType; } else { // we've already created it but might need to add properties SetContentTypeProperties(shortStringHelper, labelDataType, rteDataType, kit, contentType); } } contentTypes = contentTypesIdToType.Values.ToArray(); return(kitsAndXml.Select(x => x.kit)); }