public void ReadingElementSetsName()
{
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo"), builder);
var type = builder.Build();
Assert.That(type.Name, Is.EqualTo("foo"));
}
public static void AlterTypeDefinition(this IContentDefinitionManager manager, string name, Action<ContentTypeDefinitionBuilder> alteration)
{
var typeDefinition = manager.GetTypeDefinition(name) ?? new ContentTypeDefinition(name, name.CamelFriendly());
var builder = new ContentTypeDefinitionBuilder(typeDefinition);
alteration(builder);
manager.StoreTypeDefinition(builder.Build());
}
public void AttributesAreAppliedAsSettings()
{
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo", new XAttribute("x", "1")), builder);
var type = builder.Build();
Assert.That(type.Settings["x"], Is.EqualTo("1"));
}
public void CanAlterPartSettingsByNameDuringRebuild()
{
var contentTypeDefinition1 = new ContentTypeDefinitionBuilder()
.Named("alpha")
.WithPart("foo", pb => pb.WithSetting("x", "10").WithSetting("y", "11"))
.Build();
var contentTypeDefinition2 = new ContentTypeDefinitionBuilder(contentTypeDefinition1)
.WithPart("foo", pb => pb.WithSetting("x", "12").WithSetting("z", "13"))
.Build();
Assert.That(contentTypeDefinition1.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition1.Parts.Count(), Is.EqualTo(1));
Assert.That(contentTypeDefinition1.Parts.Single().PartDefinition.Name, Is.EqualTo("foo"));
Assert.That(contentTypeDefinition1.Parts.Single().Settings.Count(), Is.EqualTo(2));
Assert.That(contentTypeDefinition1.Parts.Single().Settings["x"], Is.EqualTo("10"));
Assert.That(contentTypeDefinition1.Parts.Single().Settings["y"], Is.EqualTo("11"));
Assert.That(contentTypeDefinition2.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition2.Parts.Count(), Is.EqualTo(1));
Assert.That(contentTypeDefinition2.Parts.Single().PartDefinition.Name, Is.EqualTo("foo"));
Assert.That(contentTypeDefinition2.Parts.Single().Settings.Count(), Is.EqualTo(3));
Assert.That(contentTypeDefinition2.Parts.Single().Settings["x"], Is.EqualTo("12"));
Assert.That(contentTypeDefinition2.Parts.Single().Settings["y"], Is.EqualTo("11"));
Assert.That(contentTypeDefinition2.Parts.Single().Settings["z"], Is.EqualTo("13"));
}
public void ChildElementsAreAddedAsPartsWithSettings()
{
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo", new XElement("bar", new XAttribute("y", "2"))), builder);
var type = builder.Build();
Assert.That(type.Parts.Single().PartDefinition.Name, Is.EqualTo("bar"));
Assert.That(type.Parts.Single().Settings["y"], Is.EqualTo("2"));
}
public static IUser Create(string role)
{
var simulationType = new ContentTypeDefinitionBuilder().Named("User").Build();
var simulation = new ContentItemBuilder(simulationType)
.Weld<SimulatedUser>()
.Weld<SimulatedUserRoles>()
.Build();
simulation.As<SimulatedUserRoles>().Roles = new[] {role};
return simulation.As<IUser>();
}
public void TypeAndTypePartSettingsAreAttributes()
{
var alpha = new ContentTypeDefinitionBuilder()
.Named("alpha")
.WithSetting("x", "1")
.WithPart("beta", part => part.WithSetting(" y ", "2"))
.Build();
var alphaInfoset = _writer.Export(alpha);
Assert.That(alphaInfoset.Attributes("x").Single().Value, Is.EqualTo("1"));
Assert.That(alphaInfoset.Elements("beta").Attributes(XmlConvert.EncodeLocalName(" y ")).Single().Value, Is.EqualTo("2"));
}
public void PartsCanBeRemovedByNameWhenImporting()
{
const string partToBeRemoved = "alpha";
var builder = new ContentTypeDefinitionBuilder();
_reader.Merge(new XElement("foo",
new XElement(partToBeRemoved),
new XElement("remove", new XAttribute("name", partToBeRemoved))
), builder);
var type = builder.Build();
Assert.That(type.Parts.FirstOrDefault(part => part.PartDefinition.Name == partToBeRemoved), Is.Null);
}
public void AddingPartWithSettings()
{
var contentTypeDefinition = new ContentTypeDefinitionBuilder()
.Named("alpha")
.WithSetting("a", "1")
.WithSetting("b", "2")
.WithPart("foo", pb => pb.WithSetting("x", "10").WithSetting("y", "11"))
.Build();
Assert.That(contentTypeDefinition.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition.Parts.Count(), Is.EqualTo(1));
Assert.That(contentTypeDefinition.Parts.Single().PartDefinition.Name, Is.EqualTo("foo"));
Assert.That(contentTypeDefinition.Parts.Single().Settings.Count(), Is.EqualTo(2));
Assert.That(contentTypeDefinition.Parts.Single().Settings["x"], Is.EqualTo("10"));
Assert.That(contentTypeDefinition.Parts.Single().Settings["y"], Is.EqualTo("11"));
}
/// <summary>
/// Merges a given content type definition provided in a XML format into a content type definition builder.
/// </summary>
/// <param name="element">The XML content type definition.</param>
/// <param name="contentTypeDefinitionBuilder">The content type definition builder.</param>
public void Merge(XElement element, ContentTypeDefinitionBuilder contentTypeDefinitionBuilder)
{
Argument.ThrowIfNull(element, "element");
Argument.ThrowIfNull(contentTypeDefinitionBuilder, "contentTypeDefinitionBuilder");
// Merge name
contentTypeDefinitionBuilder.Named(XmlConvert.DecodeName(element.Name.LocalName));
// Merge display name
if (element.Attribute("DisplayName") != null) {
contentTypeDefinitionBuilder.DisplayedAs(element.Attribute("DisplayName").Value);
}
// Merge settings
foreach (var setting in _settingsFormatter.Map(element)) {
contentTypeDefinitionBuilder.WithSetting(setting.Key, setting.Value);
}
// Merge parts
foreach (var iter in element.Elements()) {
var partElement = iter;
var partName = XmlConvert.DecodeName(partElement.Name.LocalName);
if (partName == "remove") {
var nameAttribute = partElement.Attribute("name");
if (nameAttribute != null) {
contentTypeDefinitionBuilder.RemovePart(nameAttribute.Value);
}
}
else {
contentTypeDefinitionBuilder.WithPart(
partName,
partBuilder => {
foreach (var setting in _settingsFormatter.Map(partElement)) {
partBuilder.WithSetting(setting.Key, setting.Value);
}
});
}
}
}
public void GetContentTypesShouldReturnAllTypes()
{
// Register the types and obtain them
ContentTypeDefinition alphaType = new ContentTypeDefinitionBuilder()
.Named(DefaultAlphaName)
.Build();
ContentTypeDefinition betaType = new ContentTypeDefinitionBuilder()
.Named(DefaultBetaName)
.Build();
ContentTypeDefinition gammaType = new ContentTypeDefinitionBuilder()
.Named(DefaultGammaName)
.Build();
ContentTypeDefinition deltaType = new ContentTypeDefinitionBuilder()
.Named(DefaultDeltaName)
.Build();
_contentDefinitionManager.Setup(contentDefinitionManager => contentDefinitionManager.ListTypeDefinitions())
.Returns(new List<ContentTypeDefinition> { alphaType, betaType, gammaType, deltaType });
var types = _manager.GetContentTypeDefinitions();
// Validate that the expected types were obtained
Assert.That(types.Count(), Is.EqualTo(4));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultAlphaName));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultBetaName));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultGammaName));
Assert.That(types, Has.Some.With.Property("Name").EqualTo(DefaultDeltaName));
}
public void ExistingTypeAndPartDefinitionShouldBeUsed()
{
var alphaType = new ContentTypeDefinitionBuilder()
.Named(DefaultAlphaName)
.WithSetting("x", "1")
.WithPart("foo")
.WithPart("FlavoredPart", part => part.WithSetting("spin", "clockwise"))
.Build();
_contentDefinitionManager
.Setup(x => x.GetTypeDefinition(DefaultAlphaName))
.Returns(alphaType);
var contentItem = _manager.New(DefaultAlphaName);
Assert.That(contentItem.ContentType, Is.EqualTo(DefaultAlphaName));
Assert.That(contentItem.TypeDefinition, Is.Not.Null);
Assert.That(contentItem.TypeDefinition, Is.SameAs(alphaType));
var flavored = contentItem.As<FlavoredPart>();
Assert.That(flavored, Is.Not.Null);
Assert.That(flavored.TypePartDefinition, Is.Not.Null);
Assert.That(flavored.TypePartDefinition.Settings["spin"], Is.EqualTo("clockwise"));
}
public void ContentRebuildWithModification()
{
var contentTypeDefinition1 = new ContentTypeDefinitionBuilder()
.Named("alpha")
.WithSetting("a", "1")
.WithSetting("b", "2")
.Build();
var contentTypeDefinition2 = new ContentTypeDefinitionBuilder(contentTypeDefinition1)
.Named("beta")
.WithSetting("b", "22")
.WithSetting("c", "3")
.Build();
Assert.That(contentTypeDefinition1, Is.Not.SameAs(contentTypeDefinition2));
Assert.That(contentTypeDefinition1.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition1.Settings.Count(), Is.EqualTo(2));
Assert.That(contentTypeDefinition1.Settings["a"], Is.EqualTo("1"));
Assert.That(contentTypeDefinition1.Settings["b"], Is.EqualTo("2"));
Assert.That(contentTypeDefinition2.Name, Is.EqualTo("beta"));
Assert.That(contentTypeDefinition2.Settings.Count(), Is.EqualTo(3));
Assert.That(contentTypeDefinition2.Settings["a"], Is.EqualTo("1"));
Assert.That(contentTypeDefinition2.Settings["b"], Is.EqualTo("22"));
Assert.That(contentTypeDefinition2.Settings["c"], Is.EqualTo("3"));
}
public void ContentTypeNameAndSettingsFromScratch()
{
var contentTypeDefinition = new ContentTypeDefinitionBuilder()
.Named("alpha")
.WithSetting("a", "1")
.WithSetting("b", "2")
.Build();
Assert.That(contentTypeDefinition.Name, Is.EqualTo("alpha"));
Assert.That(contentTypeDefinition.Settings.Count(), Is.EqualTo(2));
Assert.That(contentTypeDefinition.Settings["a"], Is.EqualTo("1"));
Assert.That(contentTypeDefinition.Settings["b"], Is.EqualTo("2"));
}
private ContentPart CreateContentItemPart()
{
var partDefinition = FooPartDefinition();
var typeDefinition = new ContentTypeDefinitionBuilder()
.WithPart(partDefinition, part => { })
.Build();
var contentItem = new ContentItem {
VersionRecord = new ContentItemVersionRecord {
ContentItemRecord = new ContentItemRecord()
}
};
var contentPart = new ContentPart {
TypePartDefinition = typeDefinition.Parts.Single()
};
contentItem.Weld(contentPart);
contentItem.Weld(new InfosetPart {
Infoset = contentItem.Record.Infoset,
VersionInfoset = contentItem.VersionRecord.Infoset
});
return contentPart;
}
public static ContentTypeDefinition Import(this IContentDefinitionReader reader, XElement source)
{
var target = new ContentTypeDefinitionBuilder();
reader.Merge(source, target);
return target.Build();
}
