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 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 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")); }
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 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 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 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 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 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 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 Custom_Processor_Processes() { var content = new MockPublishedContent() { Name = "MyName" }; var model = content.As <MyModel>(); Assert.That(model.Name, Is.EqualTo("MyName Test")); }
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 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 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 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 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 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 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 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 ChainedContext_Returns() { var items = Enumerable.Repeat <IPublishedContent>(new MockPublishedContent() { DocumentTypeAlias = "MyDifferentModel" }, 1); var content = new MockPublishedContent { Properties = new[] { new MockPublishedContentProperty("MyProperty", items) } }; var model = content.As <MyModel>(); Assert.That(model, Is.Not.Null); }
public void Existing_Object_Mapped() { var content = new MockPublishedContent(); var value = "Hello world"; var model = new MyBaseModel() { MyProperty1 = value, MyProperty2 = value }; content.As(instance: model); Assert.That(model.MyProperty1, Is.Not.EqualTo(value)); Assert.That(model.MyProperty2, Is.EqualTo(value)); }
public void Conversion_Handlers_Can_Run_Global() { var content = new MockPublishedContent { Properties = new[] { new MockPublishedContentProperty("prop1", "Test1"), new MockPublishedContentProperty("prop2", "Test2") } }; Ditto.RegisterConversionHandler <CalculatedModel2, CalculatedModel2ConversionHandler>(); var model = content.As <CalculatedModel2>(); Assert.That(model.AltText2, Is.EqualTo("Test1 Test2")); }