public void NewsList_IsAllowed_OnNewsPageRightZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionNewsPage));
var childDefinitions = definitions.GetAllowedChildren(new DefinitionNewsPage(), "Right", user);
EnumerableAssert.Contains(childDefinitions, definitions.GetDefinition(typeof(DefinitionNewsList)));
}
public void Contains_Predicate_CollectionEmpty_ThrowsException()
{
var collection = new List <string>();
var ex = Assert.ThrowsException <AssertFailedException>(() => EnumerableAssert.Contains(collection, s => s.IndexOf("e") == 0));
Assert.AreEqual("EnumerableAssert.Contains failed. Collection is empty.", ex.Message);
}
public void AnyEnumDetail()
{
IList <ContentItem> items = finder.Where.Detail().Eq(AppDomainManagerInitializationOptions.RegisterWithHost).Select();
Assert.AreEqual(1, items.Count);
EnumerableAssert.Contains(items, startPage);
}
public void NewsList_HasTwo_AllowedZones()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionNewsList));
EnumerableAssert.Contains(definition.AllowedZoneNames, "Right");
EnumerableAssert.Contains(definition.AllowedZoneNames, "");
}
public void CanAssociateItems()
{
ContentItem english1 = CreateOneItem <Items.TranslatedPage>(0, "english1", english);
engine.Persister.Save(english1);
ContentItem swedish1 = CreateOneItem <Items.TranslatedPage>(0, "swedish1", swedish);
engine.Persister.Save(swedish1);
ContentItem italian1 = CreateOneItem <Items.TranslatedPage>(0, "italian1", italian);
engine.Persister.Save(italian1);
ILanguageGateway gateway = engine.Resolve <ILanguageGateway>();
gateway.Associate(new ContentItem[] { english1, swedish1, italian1 });
var translations = gateway.FindTranslations(english1);
EnumerableAssert.Count(3, translations);
EnumerableAssert.Contains(translations, english1);
EnumerableAssert.Contains(translations, swedish1);
EnumerableAssert.Contains(translations, italian1);
}
public void CanRead_DetailCollection(IEnumerable values)
{
XmlableItem item = CreateOneItem <XmlableItem>(1, "item", null);
DetailCollection dc = item.GetDetailCollection("Details", true);
foreach (object detail in values)
{
dc.Add(detail);
}
ContentItem readItem = Mangle(item);
DetailCollection readCollection = readItem.GetDetailCollection("Details", false);
Assert.IsNotNull(readCollection);
foreach (object detail in values)
{
if (detail is string)
{
EnumerableAssert.Contains(readCollection, HttpUtility.HtmlEncode((string)detail));
}
else
{
EnumerableAssert.Contains(readCollection, detail);
}
}
}
public void NewsList_IsAllowed_OnNewsPageEmptyZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionNewsPage));
IEnumerable <ItemDefinition> childDefinitions = definitions.GetAllowedChildren(new DefinitionNewsPage(), string.Empty, user);
EnumerableAssert.Contains(childDefinitions, definitions.GetDefinition(typeof(DefinitionNewsList)));
}
public void TextItem_IsAllowed_OnStartPage_LeftAndCenterZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionStartPage));
var childDefinitions = definitions.GetAllowedChildren(new DefinitionStartPage(), "LeftAndCenter", user);
EnumerableAssert.Contains(childDefinitions, definitions.GetDefinition(typeof(DefinitionTextItem)));
}
public void AddsAllSiblings()
{
ItemHierarchyNavigator ih = new ItemHierarchyNavigator(new BranchHierarchyBuilder(a_a_a, null));
EnumerableAssert.Contains(ih.EnumerateAllItems(), a_a_a);
EnumerableAssert.Contains(ih.EnumerateAllItems(), a_a_b);
}
public void TextPage_HasRightZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionTextPage));
IList <AvailableZoneAttribute> availableZones = definition.AvailableZones;
EnumerableAssert.Contains(availableZones, new AvailableZoneAttribute("Right", "Right"));
}
public void TextPage_IsAllowed_BelowStartPage()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionStartPage));
var childDefinitions = definitions.GetAllowedChildren(new DefinitionStartPage(), string.Empty, user);
EnumerableAssert.Contains(childDefinitions, definitions.GetDefinition(typeof(DefinitionTextPage)));
}
public void Teaser_IsAllowed_InTextPage_RightZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionTextPage));
var childDefinitions = definitions.GetAllowedChildren(new DefinitionTextPage(), "Right", user);
EnumerableAssert.Contains(childDefinitions, definitions.GetDefinition(typeof(DefinitionRightColumnTeaser)));
}
public void Contains_CollectionEmpty_ThrowsException()
{
var collection = new List <string>();
var ex = Assert.ThrowsException <AssertFailedException>(() => EnumerableAssert.Contains(collection, "test"));
Assert.AreEqual("EnumerableAssert.Contains failed. Collection is empty.", ex.Message);
}
public void StartPageHas_LeftAndCenter_AndRightZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionStartPage));
IList <AvailableZoneAttribute> availableZones = definition.AvailableZones;
EnumerableAssert.Contains(availableZones, new AvailableZoneAttribute("Right", "Right"));
EnumerableAssert.Contains(availableZones, new AvailableZoneAttribute("Left and Center", "LeftAndCenter"));
}
public void ReplacingDefinition_ShowsUp_InAllowedChildDefinitions()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionTextPage));
ItemDefinition replacingDefinition = definitions.GetDefinition(typeof(DefinitionReplacement));
IList <ItemDefinition> allowedChildren = definitions.GetAllowedChildren(new DefinitionTextPage(), null, null);
EnumerableAssert.Contains(allowedChildren, replacingDefinition);
}
public void All()
{
IList <ContentItem> items = finder.All.Select();
Assert.AreEqual(5, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
public void CanSelectByPropertyNameIn()
{
IList <ContentItem> items = finder.Where.Name.In(rootItem.Name, startPage.Name).Select();
Assert.AreEqual(2, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
public void Contains_Predicate_OneElementMatches_MultipleElementsInList()
{
var collection = new List <string> {
"expected", "notexpected", "also not expected"
};
EnumerableAssert.Contains(collection, s => s.IndexOf("e") == 0);
}
public void RightColumnTeaser_AllowsRightZone()
{
ItemDefinition definition = definitions.GetDefinition(typeof(DefinitionRightColumnTeaser));
IEnumerable <string> zones = definition.AllowedZoneNames;
EnumerableAssert.Count(1, zones);
EnumerableAssert.Contains(zones, "Right");
}
public void AvailableZonesAreCorrect()
{
ItemDefinition definition = engine.Definitions.GetDefinition(typeof(ItemWithDetails));
Assert.AreEqual(2, definition.AvailableZones.Count);
EnumerableAssert.Contains(definition.AvailableZones, new AvailableZoneAttribute("Zone1", "Zone1"));
EnumerableAssert.Contains(definition.AvailableZones, new AvailableZoneAttribute("Zone2", "Zone2"));
}
public void CanSelectByDetailIn()
{
IList <ContentItem> items = finder.Where.Detail().In(43, 45).Select();
Assert.AreEqual(2, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
public void DoesntAddItemsInOffPaths()
{
ItemHierarchyNavigator ih = new ItemHierarchyNavigator(new BranchHierarchyBuilder(a_a_a, null));
EnumerableAssert.Count(5, ih.EnumerateAllItems());
EnumerableAssert.Contains(ih.EnumerateAllItems(), a_a_a);
EnumerableAssert.DoesntContain(ih.EnumerateAllItems(), a_b_a);
}
public void Contains_Predicate_OneElementMatches_Size1()
{
var collection = new List <string> {
"expected"
};
EnumerableAssert.Contains(collection, s => s.IndexOf("e") == 0);
}
public void Contains_MultipleElementsMatch()
{
var collection = new List <string> {
"expected", "notexpected", "expected"
};
EnumerableAssert.Contains(collection, "expected");
}
public void Contains_Predicate_MultipleElementsMatch()
{
var collection = new List <string> {
"expected", "notexpected", "expected as well"
};
EnumerableAssert.Contains(collection, s => s.IndexOf("e") == 0);
}
public void FilterByTypeNotEqual()
{
IList <ContentItem> items = finder.Where.Type.NotEq(typeof(PersistableItem2)).Select();
Assert.AreEqual(2, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
public void Contains_OneElementMatches_Size1()
{
var collection = new List <string> {
"expected"
};
EnumerableAssert.Contains(collection, "expected");
}
public void AnyStringDetail()
{
IList <ContentItem> items = finder.Where.Detail().Eq("just a string").Select();
Assert.AreEqual(2, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
public void TwoItems_ByNameOrTitle()
{
IList <ContentItem> items = finder.Where.Name.Eq("root").Or.Title.Eq("start page").Select();
Assert.AreEqual(2, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
public void StringDetailWithLike2()
{
IList <ContentItem> items = finder.Where.Detail("StringDetail").Like("% string").Select();
Assert.AreEqual(2, items.Count);
EnumerableAssert.Contains(items, rootItem);
EnumerableAssert.Contains(items, startPage);
}
