public void Nested_Enumerable_PublishedContent_Property_Value()
{
var value = "My Inner Property Value";
var contentList = new List <IPublishedContent>();
for (var i = 0; i < 5; i++)
{
contentList.Add(new MockPublishedContent
{
Id = i,
Name = string.Concat("Node ", i),
Properties = new[] { new MockPublishedContentProperty("myProperty", value) }
});
}
var content2 = new MockPublishedContent
{
Properties = new[] { new MockPublishedContentProperty("myContentList", contentList) }
};
var model = content2.As <MyModel>();
Assert.That(model.MyContentList.Count(), Is.EqualTo(5));
Assert.That(model.MyContentList.All(x => x.MyProperty == value), Is.True);
}
public void PropertySource_Attributed_Properties_Map()
{
var instanceName = "Instance Name";
var instanceUrl = "/instance/url";
var customName = "Custom Name";
var customProp = "Custom Prop";
// Create a hidden mapping
var content = new MockPublishedContent
{
Name = instanceName,
Url = instanceUrl,
Properties = new[]
{
new MockPublishedContentProperty("name", customName),
new MockPublishedContentProperty("custom", customProp)
}
};
var model = content.As <BasicModelProperty2>();
Assert.AreEqual(customName, model.Name);
Assert.AreEqual(instanceUrl, model.Url);
Assert.AreEqual(customProp, model.Custom);
}
public void MultiProcessor_EmptyConstructor_Test()
{
// In this test, the `MyProperty` property gets a `string` value
// via the `UmbracoProperty`. The `string` type/value is passed
// to the `MyCustomConverter` so to convert the `string` to a
// `MyCustomModel` type/object.
// Then a second class which uses the `MyModel2` and the `MyEmptyBaseConstructorMultiProcessorAttribute` calling similar code.
// It then asserts that the output of `MyProperty` for `MyModel` is equal to thw value of `MyProperty` of `MyModel2`.
var content = new MockPublishedContent()
{
Name = "MyName"
};
var model = content.As <MyModel>();
var model2 = content.As <MyModel2>();
Assert.That(model, Is.Not.Null);
Assert.That(model, Is.InstanceOf <MyModel>());
Assert.That(model2, Is.Not.Null);
Assert.That(model2, Is.InstanceOf <MyModel2>());
Assert.That(model.MyProperty, Is.Not.Null);
Assert.That(model2.MyProperty, Is.Not.Null);
Assert.That(model.MyProperty, Is.EqualTo(model2.MyProperty));
}
public void ChanedProcessor_MultiUmbracoPropertyProcessors()
{
// In this test, we are checking that we can chain multiple
// UmbracoPropertyAttributes. To test we have the first property
// returning an IPublishedContent for the initial property alias
// allowing the second UmbracoPropertyAttribute able to run on
// the inner model.
var content = new MockPublishedContent()
{
Name = "MyName",
Properties = new [] {
new MockPublishedContentProperty("myProp", new MockPublishedContent
{
Name = "MyInnerName",
Properties = new[]
{
new MockPublishedContentProperty("myInnerProp", "Test"),
}
})
}
};
var model = content.As <MyModel4>();
Assert.IsNotNull(model);
Assert.IsInstanceOf <MyModel4>(model);
Assert.IsNotNull(model.MyProperty);
Assert.AreEqual(model.MyProperty, "Test");
}
public void XPath_Processes_PublishedContent()
{
var parent = new MockPublishedContent {
Id = 1111, Path = "-1,1111"
};
var content = new MockPublishedContent {
Id = 2222, Path = "-1,1111,2222", Parent = parent
};
var model = content.As <MyModel>();
Assert.That(model, Is.Not.Null);
Assert.That(model.Self, Is.Not.Null);
Assert.That(model.Self.Id, Is.EqualTo(content.Id));
Assert.That(model.Parent, Is.Not.Null);
Assert.That(model.Parent.Id, Is.EqualTo(parent.Id));
Assert.That(model.Site, Is.Not.Null);
Assert.That(model.Site.Id, Is.EqualTo(parent.Id));
Assert.That(model.Root, Is.Not.Null);
Assert.That(model.Root.Id, Is.EqualTo(parent.Id));
}
public void CurrentContent_InfineLoop_Check()
{
var content = new MockPublishedContent();
TestDelegate code = () => { content.As <MyCircularReferenceModel>(); };
Assert.Throws <InvalidOperationException>(code);
}
public void MockValue_Property_Resolved()
{
var content = new MockPublishedContent();
var model = content.As <MyMockValueModel>();
Assert.That(model.MyProperty, Is.EqualTo("Mock Property Value"));
}
public void AppSetting_Property_Returned()
{
var value = "MyAppSettingValue";
var content = new MockPublishedContent();
var model = content.As <MyAppSettingsModel>();
Assert.That(model.MyProperty, Is.EqualTo(value));
}
public void PocoConstructor_Tests(Type modelType)
{
var content = new MockPublishedContent();
var model = content.As(modelType);
Assert.That(model, Is.Not.Null);
Assert.That(model, Is.InstanceOf(modelType));
}
public void ProcessorContext_Resolves_Without_Registered_Context()
{
var content = new MockPublishedContent();
var model = content.As <MyValueResolverModel>();
Assert.That(model.MyProperty, Is.EqualTo("Default value"));
Assert.That(model.MyLazyProperty, Is.EqualTo(model.MyProperty));
}
public void PropertySource_Properties_Map()
{
var instanceName = "Instance Name";
var instanceUrl = "/instance/url";
var customName = "Custom Name";
var customProp = "Custom Prop";
// Create a hidden mapping
var content = new MockPublishedContent
{
Name = instanceName,
Url = instanceUrl,
Properties = new[]
{
new MockPublishedContentProperty("name", customName),
new MockPublishedContentProperty("custom", customProp)
}
};
Ditto.DefaultPropertySource = PropertySource.InstanceThenUmbracoProperties;
DittoTypeInfoCache.Clear <BasicModelProperty>();
var model = content.As <BasicModelProperty>();
Assert.AreEqual(instanceName, model.Name);
Assert.AreEqual(instanceUrl, model.Url);
Assert.AreEqual(customProp, model.Custom);
Ditto.DefaultPropertySource = PropertySource.UmbracoThenInstanceProperties;
DittoTypeInfoCache.Clear <BasicModelProperty>();
model = content.As <BasicModelProperty>();
Assert.AreEqual(customName, model.Name);
Assert.AreEqual(instanceUrl, model.Url);
Assert.AreEqual(customProp, model.Custom);
Ditto.DefaultPropertySource = PropertySource.InstanceProperties;
DittoTypeInfoCache.Clear <BasicModelProperty>();
model = content.As <BasicModelProperty>();
Assert.AreEqual(instanceName, model.Name);
Assert.AreEqual(instanceUrl, model.Url);
Assert.IsNull(model.Custom);
Ditto.DefaultPropertySource = PropertySource.UmbracoProperties;
DittoTypeInfoCache.Clear <BasicModelProperty>();
model = content.As <BasicModelProperty>();
Assert.AreEqual(customName, model.Name);
Assert.IsNull(model.Url);
Assert.AreEqual(customProp, model.Custom);
// Reset
Ditto.DefaultPropertySource = PropertySource.InstanceThenUmbracoProperties;
DittoTypeInfoCache.Clear <BasicModelProperty>();
}
public void MapperCanMapRelatedLinks()
{
MockPublishedContent content = this.support.Content;
PublishedItem result = content.MapTo <PublishedItem>();
Assert.NotNull(result.RelatedLink);
Assert.NotNull(result.RelatedLinks);
Assert.True(result.RelatedLinks.GetType().IsEnumerableOfType(typeof(RelatedLink)));
}
public void CreateDate_Returned()
{
var date = DateTime.Now;
var content = new MockPublishedContent {
CreateDate = date
};
var model = content.As <MyModel>();
Assert.That(model.MyProperty1, Is.EqualTo(date));
}
public void ValueTypes_With_DefaultValue()
{
var content = new MockPublishedContent();
var model = content.As <MyModel>();
Assert.That(model, Is.Not.Null);
Assert.That(model.Boolean, Is.TypeOf <bool>());
Assert.That(model.Integer, Is.TypeOf <int>());
Assert.That(model.NullableInteger, Is.Null);
}
public void Custom_Processor_Processes()
{
var content = new MockPublishedContent()
{
Name = "MyName"
};
var model = content.As <MyModel>();
Assert.That(model.Name, Is.EqualTo("MyName Test"));
}
public void Multiple_Conversion_Handlers_Registered_Same_Type()
{
Ditto.RegisterConversionHandler <MyModel, MyModelConversionHandler>();
Ditto.RegisterConversionHandler <MyModel, MyModelConversionHandler2>();
var content = new MockPublishedContent();
var model = content.As <MyModel>();
Assert.That(model, Is.Not.Null);
Assert.That(model.Name, Is.EqualTo("foo bar"));
}
public void DictionaryValue_Returned()
{
// Create mock content
var content = new MockPublishedContent();
// Run conversion
var model = content.As <MyModel>();
// Assert checks
Assert.That(model.MyProperty, Is.EqualTo("world"));
Assert.That(model.Foo, Is.EqualTo("bar"));
}
public void Basic_String_Property_IsMapped()
{
var value = "myValue";
var content = new MockPublishedContent
{
Properties = new[] { new MockPublishedContentProperty("myProperty", value) }
};
var model = content.As <BasicModelWithStringProperty>();
Assert.That(model.MyProperty, Is.EqualTo(value));
}
public void Basic_Name_IsMapped()
{
var name = "MyCustomName";
var content = new MockPublishedContent
{
Name = name
};
var model = content.As <BasicModel>();
Assert.That(model.Name, Is.EqualTo(name));
}
public void Basic_Content_Item_Property_IsMapped()
{
var value = "myValue";
var content = new MockPublishedContent
{
Properties = new[] { new MockPublishedContentProperty("item", value) }
};
var model = content.As <BasicModelWithItemProperty>();
Assert.That(model.Item, Is.EqualTo(value));
}
public void InheritedClassWithPrefixedProperty_Mapping()
{
var value = "foo bar";
var content = new MockPublishedContent()
{
Properties = new[] { new MockPublishedContentProperty("inherited_myProperty", value) }
};
var model = content.As <InheritedModel>();
Assert.That(model, Is.Not.Null);
Assert.That(model.MyProperty, Is.EqualTo(value));
}
public void GenericDictionaryPropertyIsNotDetectedAsCastableEnumerable()
{
var content = new MockPublishedContent
{
Properties = new[] { new MockPublishedContentProperty("myProperty", "myValue") }
};
var result = content.As <MyModel>();
Assert.That(result.MyProperty, Is.Not.Null);
Assert.That(result.MyProperty.Any(), Is.True);
Assert.That(result.MyProperty["hello"], Is.EqualTo("world"));
}
public void ProcessorContext_Resolves_Nested_Context()
{
var value = "Test";
var content = new MockPublishedContent();
var context = new MyProcessorContext {
MyContextProperty = value
};
var model = content.As <MyValueResolverModel>(processorContexts: new[] { context });
Assert.That(model.MyNestedProperty, Is.Not.Null);
Assert.That(model.MyNestedProperty.MyProperty, Is.EqualTo(model.MyProperty));
}
public void Castable_Interface_Can_Map()
{
var content = new MockPublishedContent
{
Id = 123,
Name = "Test"
};
var content2 = content.As <IPublishedContent>();
Assert.That(content2.Id, Is.EqualTo(content.Id));
Assert.That(content2.Name, Is.EqualTo(content.Name));
}
public void MapperCanMapBaseAlternativeProperties()
{
var created = new DateTime(2017, 1, 1);
MockPublishedContent content = this.support.Content;
content.CreateDate = created;
PublishedItem result = content.MapTo <PublishedItem>();
Assert.Equal(created, result.CreateDate);
Assert.Equal(created, result.UpdateDate);
}
public void Basic_Id_And_Property_IsMapped()
{
var id = 1234;
var content = new MockPublishedContent
{
Id = id
};
var model = content.As <BasicModelWithId>();
Assert.That(model.Id, Is.EqualTo(id));
Assert.That(model.MyProperty, Is.EqualTo(id));
}
public void Basic_Content_To_String_Exception()
{
var content = new MockPublishedContent();
TestDelegate code = () =>
{
// Since a `string` does not have a parameterless constructor,
// Ditto can not map the `IPublishedContent` object,
// which will throw an `InvalidOperationException` exception.
var model = content.As <string>();
};
Assert.Throws <InvalidOperationException>(code);
}
public void MapperReturnsCorrectEnumFromString()
{
const PlaceOrder placeOrder = PlaceOrder.Fourth;
MockPublishedContent content = this.support.Content;
content.Properties = new List <IPublishedProperty>
{
new MockPublishedContentProperty(nameof(PublishedItem.PlaceOrder), placeOrder.ToString())
};
PublishedItem result = content.MapTo <PublishedItem>();
Assert.Equal(placeOrder, result.PlaceOrder);
}
public void CaseSensitivePropertyName_Mapped()
{
var name = "MyCustomName";
var content = new MockPublishedContent {
Name = name
};
var model = content.As <MyModel>();
Assert.That(model.Name, Is.EqualTo(name));
Assert.That(model.Name_PascalCase, Is.EqualTo(name));
Assert.That(model.Name_UpperCase, Is.EqualTo(name));
Assert.That(model.Name_LowerCase, Is.EqualTo(name));
Assert.That(model.Name_MixedCase, Is.EqualTo(name));
}
public void Cache_Caches()
{
var cacheHelper = new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new NullCacheProvider());
var logger = new ProfilingLogger(Mock.Of <ILogger>(), Mock.Of <IProfiler>());
var appCtx = new ApplicationContext(cacheHelper, logger);
ApplicationContext.EnsureContext(appCtx, true);
var prop1 = new MockPublishedContentProperty("myProperty1", "Test1");
var prop2 = new MockPublishedContentProperty("myProperty2", "Test1");
var prop3 = new MockPublishedContentProperty("myProperty3", "Test1");
var content = new MockPublishedContent
{
Id = 1,
Properties = new[] { prop1, prop2, prop3 }
};
var model1 = content.As <MyValueResolverModel1>();
var model2 = content.As <MyValueResolverModel2>();
Assert.That(model1.MyProperty1, Is.EqualTo("Test1"));
Assert.That(model1.MyProperty2, Is.EqualTo("Test1"));
Assert.That(model1.MyProperty3, Is.EqualTo("Test1"));
Assert.That(model2.MyProperty1, Is.EqualTo("Test1"));
Assert.That(model2.MyProperty2, Is.EqualTo("Test1"));
Assert.That(model2.MyProperty3, Is.EqualTo("Test1"));
prop1.Value = "Test2";
prop2.Value = "Test2";
prop3.Value = "Test2";
model1 = content.As <MyValueResolverModel1>();
model2 = content.As <MyValueResolverModel2>();
Assert.That(model1.MyProperty1, Is.EqualTo("Test1"));
Assert.That(model1.MyProperty2, Is.EqualTo("Test1"));
Assert.That(model1.MyProperty3, Is.EqualTo("Test2")); // This one doesn't cache
Assert.That(model2.MyProperty1, Is.EqualTo("Test1"));
Assert.That(model2.MyProperty2, Is.EqualTo("Test1"));
Assert.That(model2.MyProperty3, Is.EqualTo("Test1"));
}
