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 CacheLevelTest(PropertyCacheLevel cacheLevel, int interConverts)
{
var converter = new CacheConverter1(cacheLevel);
var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
{
converter,
});
var dataTypeService = new TestObjects.TestDataTypeService(
new DataType(new VoidEditor(Mock.Of <ILogger>()))
{
Id = 1
});
var publishedContentTypeFactory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), converters, dataTypeService);
var setType1 = publishedContentTypeFactory.CreateContentType(1000, "set1", new[]
{
publishedContentTypeFactory.CreatePropertyType("prop1", 1),
});
// PublishedElementPropertyBase.GetCacheLevels:
//
// if property level is > reference level, or both are None
// use None for property & new reference
// else
// use Content for property, & keep reference
//
// PublishedElement creates properties with reference being None
// if converter specifies None, keep using None
// anything else is not > None, use Content
//
// for standalone elements, it's only None or Content
var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary <string, object> {
{ "prop1", "1234" }
}, false);
Assert.AreEqual(1234, set1.Value("prop1"));
Assert.AreEqual(1, converter.SourceConverts);
Assert.AreEqual(1, converter.InterConverts);
// source is always converted once and cached per content
// inter conversion depends on the specified cache level
Assert.AreEqual(1234, set1.Value("prop1"));
Assert.AreEqual(1, converter.SourceConverts);
Assert.AreEqual(interConverts, converter.InterConverts);
}
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"));
}
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"));
}
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"));
}
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);
}
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);
}