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);
}
