public void Basic_Property_To_String_Exception()
{
// The source is an `IPublishedContent`, the target is a `string`, type mismatch exception
var value = new PublishedContentMock();
var property = new PublishedContentPropertyMock
{
Alias = "myProperty",
Value = value
};
var content = new PublishedContentMock
{
Properties = new[] { property }
};
TestDelegate code = () =>
{
// We are passing an `IPublishedContent` object to a property (of type `string`),
// so we know that internally Ditto will try calling `content.As<string>()`,
// which will throw an `InvalidOperationException` exception.
var model = content.As <BasicModelWithStringProperty>();
};
Assert.Throws <InvalidOperationException>(code);
}
public void Conversion_Handlers_Can_Run_Global()
{
var content = new PublishedContentMock
{
Properties = new[]
{
new PublishedContentPropertyMock
{
Alias = "prop1",
Value = "Test1"
},
new PublishedContentPropertyMock
{
Alias = "prop2",
Value = "Test2"
}
}
};
Ditto.RegisterConversionHandler <CalculatedModel2, CalculatedModel2ConversionHandler>();
var model = content.As <CalculatedModel2>();
Assert.That(model.AltText2, Is.EqualTo("Test1 Test2"));
}
public void Nested_PublishedContent_Property_Value()
{
var value = "My Inner Property Value";
var content1 = new PublishedContentMock
{
Properties = new[]
{
new PublishedContentPropertyMock
{
Alias = "myProperty",
Value = value
}
}
};
var content2 = new PublishedContentMock
{
Properties = new[]
{
new PublishedContentPropertyMock
{
Alias = "myContent",
Value = content1
}
}
};
var model = content2.As <MyModel>();
Assert.That(model.MyContent.MyProperty, Is.EqualTo(value));
}
public void EnumerablesCast()
{
var content = new PublishedContentMock
{
Properties = new[] {
new PublishedContentPropertyMock
{
Alias = "enumerableToSingle",
Value = new[] { "myVal", "myOtherVal" }
},
new PublishedContentPropertyMock
{
Alias = "singleToEnumerable",
Value = "myVal"
}
}
};
var result = content.As <MyModel>();
Assert.NotNull(result.EnumerableToSingle);
Assert.AreEqual(result.EnumerableToSingle, "myVal");
Assert.NotNull(result.SingleToEnumerable);
Assert.IsTrue(result.SingleToEnumerable.Any());
Assert.AreEqual(result.SingleToEnumerable.First(), "myVal");
}
public void Prefixed_Properties_Can_Resolve()
{
var prop1 = new PublishedContentPropertyMock
{
Alias = "siteName",
Value = "Name"
};
var prop2 = new PublishedContentPropertyMock
{
Alias = "siteDescription",
Value = "Description"
};
var prop3 = new PublishedContentPropertyMock
{
Alias = "fallback",
Value = "Fallback"
};
var content = new PublishedContentMock
{
Properties = new[] { prop1, prop2, prop3 }
};
var converted = content.As <MyModel>();
Assert.That(converted.Name, Is.EqualTo("Name"));
Assert.That(converted.Description, Is.EqualTo("Description"));
Assert.That(converted.Fallback, Is.EqualTo("Fallback"));
}
public void Prefixed_Properties_Can_Resolve_Recursive()
{
var childContent = new PublishedContentMock();
var parentContent = new PublishedContentMock
{
Properties = new[]
{
new PublishedContentPropertyMock
{
Alias = "siteDescription",
Value = "Description"
}
},
Children = new[]
{
childContent
}
};
childContent.Parent = parentContent;
var converted = childContent.As <MyModel>();
Assert.That(converted.Description, Is.EqualTo("Description"));
}
public void Conversion_Handlers_Can_Run()
{
var content = new PublishedContentMock
{
Properties = new[]
{
new PublishedContentPropertyMock
{
Alias = "prop1",
Value = "Test1"
},
new PublishedContentPropertyMock
{
Alias = "prop2",
Value = "Test2"
}
}
};
var model = content.As <CalculatedModel>();
Assert.That(model.Name, Is.EqualTo("Test"));
Assert.That(model.AltText, Is.EqualTo("Test1 Test2"));
Assert.That(model.AltText2, Is.EqualTo("Test1 Test2"));
}
public void CurrentContent_Property_Mapped()
{
var metaTitle = new PublishedContentPropertyMock
{
Alias = "metaTitle",
Value = "This is the meta title"
};
var metaDescription = new PublishedContentPropertyMock
{
Alias = "metaDescription",
Value = "This is the meta description"
};
var metaKeywords = new PublishedContentPropertyMock
{
Alias = "metaKeywords",
Value = "these,are,meta,keywords"
};
var content = new PublishedContentMock
{
Properties = new[] { metaTitle, metaDescription, metaKeywords }
};
var model = content.As <MyModel>();
Assert.That(model, Is.Not.Null);
Assert.That(model.MetaData1, Is.Not.Null, "We expect the property to be populated.");
Assert.That(model.MetaData1, Is.TypeOf <MyMetaDataModel>());
Assert.That(model.MetaData2, Is.Null, "We expect the property not to be populated.");
}
public void CurrentContent_InfineLoop_Check()
{
var content = new PublishedContentMock();
TestDelegate code = () => { content.As <MyCircularReferenceModel>(); };
Assert.Throws <InvalidOperationException>(code);
}
public void MockValue_Property_Resolved()
{
var content = new PublishedContentMock();
var model = content.As <MyMockValueModel>();
Assert.That(model.MyProperty, Is.EqualTo("Mock Property Value"));
}
public void ValueResolverContext_Resolves_Without_Registered_Context()
{
var content = new PublishedContentMock();
var model = content.As <MyValueResolverModel>();
Assert.That(model.MyProperty, Is.EqualTo("Default value"));
}
public void AppSetting_Property_Returned()
{
var value = "MyAppSettingValue";
var content = new PublishedContentMock();
var model = content.As <MyAppSettingsModel>();
Assert.That(model.MyProperty, Is.EqualTo(value));
}
public void ValueTypes_With_DefaultValue()
{
var content = new PublishedContentMock();
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_ValueResolver_Resolves()
{
var content = new PublishedContentMock()
{
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 PublishedContentMock();
var model = content.As <MyModel>();
Assert.That(model, Is.Not.Null);
Assert.That(model.Name, Is.EqualTo("foo bar"));
}
public void Cache_Caches()
{
var cacheHelper = new CacheHelper(
new ObjectCacheRuntimeCacheProvider(),
new StaticCacheProvider(),
new NullCacheProvider());
var appCtx = new ApplicationContext(cacheHelper);
ApplicationContext.EnsureContext(appCtx, true);
var prop1 = new PublishedContentPropertyMock {
Alias = "myProperty1", Value = "Test1"
};
var prop2 = new PublishedContentPropertyMock {
Alias = "myProperty2", Value = "Test1"
};
var prop3 = new PublishedContentPropertyMock {
Alias = "myProperty3", Value = "Test1"
};
var content = new PublishedContentMock
{
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 ValueResolverContext_Resolves()
{
var content = new PublishedContentMock();
var context = new MyValueResolverContext
{
MyContextProperty = "Test"
};
var model = content.As <MyValueResolverModel>(valueResolverContexts: new[] { context });
Assert.That(model.MyProperty, Is.EqualTo("Test"));
}
public void GetNodeHtml_OnExecuteWithPublishedContentWithId_ReturnsNull()
{
var publishedContent = new PublishedContentMock()
{
TemplateId = 1,
Id = 0
};
var contentHelper = new TemplateHelper(_umbracoHelper);
contentHelper.GetNodeHtml(publishedContent);
}
public void CreateDate_Returned()
{
var date = DateTime.Now;
var content = new PublishedContentMock {
CreateDate = date
};
var model = content.As <MyModel>();
Assert.That(model.MyProperty1, Is.EqualTo(date));
}
public void GetFocusKeywordReturnsNullWithNoProperties()
{
var mockedIPublishedContent = new PublishedContentMock();
mockedIPublishedContent.Properties = new List <IPublishedProperty>()
{
};
var focusKeywordHelper = new FocusKeywordHelper();
var result = focusKeywordHelper.GetFocusKeyword(mockedIPublishedContent);
Assert.IsNull(result);
}
public void Castable_Interface_Can_Map()
{
var content = new PublishedContentMock
{
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 PublishedContentMock
{
Name = name
};
var model = content.As <BasicModel>();
Assert.That(model.Name, Is.EqualTo(name));
}
public void Custom_TypeConverter_Converts()
{
var id = 1234;
var content = new PublishedContentMock()
{
Id = id
};
var model = content.As <MyModel>();
Assert.That(model.MyProperty, Is.InstanceOf <IPublishedContent>());
Assert.That(model.MyProperty.Id, Is.EqualTo(id));
}
public void Global_Value_Converter_Resolves()
{
Ditto.RegisterValueResolver <MyStringModel, MyStrValueResolver>();
Ditto.RegisterValueResolverAttribute <MyIntModel, MyIntValueResolverAttr>(new MyIntValueResolverAttr {
AttrProp = 5
});
var content = new PublishedContentMock();
var model = content.As <MyValueResolverModel>();
Assert.That(model.MyStrProperty.Value, Is.EqualTo("Test"));
Assert.That(model.MyIntProperty.Value, Is.EqualTo(5));
}
public void Basic_Id_And_Property_IsMapped()
{
var id = 1234;
var content = new PublishedContentMock
{
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 PublishedContentMock();
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 Custom_TypeConverter_Serializes()
{
var id = 1234;
var content = new PublishedContentMock()
{
Id = id
};
var model = content.As <MyModel>();
var serialized = Newtonsoft.Json.JsonConvert.SerializeObject(model);
Assert.That(serialized, Is.Not.Null);
Assert.That(serialized.IndexOf("\"Id\":1234", StringComparison.Ordinal), Is.GreaterThan(-1));
}
public void GetNodeHtml_WithPublishedContentWithId_ReturnsObject()
{
var publishedContent = new PublishedContentMock()
{
TemplateId = 1,
Id = 1
};
var contentHelper = new TemplateHelper(_umbracoHelper);
var result = contentHelper.GetNodeHtml(publishedContent);
Assert.IsInstanceOfType(result, typeof(string));
Assert.AreEqual("<html>test</html>", result);
}
public void Existing_Object_Mapped()
{
var content = new PublishedContentMock();
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 SetMethod_Test()
{
var value = "foo";
var content = new PublishedContentMock
{
Properties = new[] { new PublishedContentPropertyMock("myProperty", value, true) }
};
var model = content.As <MyModel>();
Assert.That(model.PropertyOmittedSetter, Is.Null);
Assert.That(model.PropertyPublicSetter, Is.EqualTo(value));
Assert.That(model.PropertyInternalSetter, Is.Null);
Assert.That(model.PropertyVirtualOmittedSetter, Is.Null);
Assert.That(model.PropertyVirtualPublicSetter, Is.EqualTo(value));
Assert.That(model.PropertyVirtualInternalSetter, Is.Null);
}
