private static SitemapItem BuildNavigationModel(string navTaxonomyUri, Localization localization) { using (new Tracer(navTaxonomyUri, localization)) { TaxonomyFactory taxonomyFactory = new TaxonomyFactory(); Keyword taxonomyRoot = taxonomyFactory.GetTaxonomyKeywords(navTaxonomyUri, new DepthFilter(DepthFilter.UnlimitedDepth, DepthFilter.FilterDown)); NavigationFilter navFilter = new NavigationFilter(); return CreateTaxonomyNode(taxonomyRoot, -1, navFilter, localization); } }
private static TaxonomyNode CreateTaxonomyNode(Keyword keyword, int expandLevels, NavigationFilter filter, Localization localization) { string taxonomyId = keyword.TaxonomyUri.Split('-')[1]; bool isRoot = (keyword.KeywordUri == keyword.TaxonomyUri); int classifiedItemsCount = keyword.ReferencedContentCount; string taxonomyNodeUrl = null; List<SitemapItem> childItems = new List<SitemapItem>(); if (expandLevels != 0) { // Add child SitemapItems for child Taxonomy Nodes (ordered by title, including sequence prefix if any) IEnumerable<TaxonomyNode> childTaxonomyNodes = keyword.KeywordChildren.Cast<Keyword>() .Select(kw => CreateTaxonomyNode(kw, expandLevels - 1, filter, localization)); childItems.AddRange(childTaxonomyNodes); if (classifiedItemsCount > 0 && filter.DescendantLevels != 0) { // Add child SitemapItems for classified Pages (ordered by title) SitemapItem[] pageSitemapItems = ExpandClassifiedPages(keyword, taxonomyId, localization); childItems.AddRange(pageSitemapItems); // If the Taxonomy Node contains an Index Page (i.e. URL path ending with "/index"), we put the Page's SG URL on the Taxonomy Node. string indexPageUrlPath = pageSitemapItems.Select(i => i.Url).FirstOrDefault(url => url.EndsWith(Constants.IndexPageUrlSuffix, StringComparison.InvariantCultureIgnoreCase)); if (indexPageUrlPath != null) { // Strip off "/index" URL suffix so we get the Page's SG URL (except for the Site Home Page, where we use "/") taxonomyNodeUrl = (indexPageUrlPath.Equals(Constants.IndexPageUrlSuffix, StringComparison.InvariantCultureIgnoreCase)) ? "/" : indexPageUrlPath.Substring(0, indexPageUrlPath.Length - Constants.IndexPageUrlSuffix.Length); } } childItems = childItems.OrderBy(i => i.OriginalTitle).ToList(); } string sequencePrefix; TaxonomyNode result = new TaxonomyNode { Id = isRoot ? string.Format("t{0}", taxonomyId) : FormatKeywordNodeId(keyword.KeywordUri, taxonomyId), Type = SitemapItem.Types.TaxonomyNode, OriginalTitle = keyword.KeywordName, Title = StripSequencePrefix(keyword.KeywordName, out sequencePrefix), Url = taxonomyNodeUrl, Visible = !string.IsNullOrEmpty(sequencePrefix) && !string.IsNullOrEmpty(taxonomyNodeUrl), Items = childItems, Key = keyword.KeywordKey, Description = keyword.KeywordDescription, IsAbstract = keyword.IsAbstract, HasChildNodes = keyword.HasChildren || (classifiedItemsCount > 0), ClassifiedItemsCount = classifiedItemsCount }; if (childItems != null) { foreach (SitemapItem childItem in childItems) { childItem.Parent = result; } } return result; }
/// <summary> /// Gets a Navigation subtree for the given Sitemap Item. /// </summary> /// <param name="sitemapItemId">The context <see cref="SitemapItem"/> identifier. Can be <c>null</c>.</param> /// <param name="filter">The <see cref="NavigationFilter"/> used to specify which information to put in the subtree.</param> /// <param name="localization">The context <see cref="Localization"/>.</param> /// <returns>A set of Sitemap Items representing the requested subtree.</returns> public IEnumerable<SitemapItem> GetNavigationSubtree(string sitemapItemId, NavigationFilter filter, Localization localization) { using (new Tracer(sitemapItemId, filter, localization)) { if (string.IsNullOrEmpty(sitemapItemId)) { return ExpandTaxonomyRoots(filter, localization); } // Extract Taxonomy TCM UI, Keyword TCM URI and/or Page TCM URI from the Sitemap Item ID string taxonomyId; string keywordId; string pageId; ParseSitemapItemId(sitemapItemId, out taxonomyId, out keywordId, out pageId); string publicationId = localization.LocalizationId; string taxonomyUri = string.Format("tcm:{0}-{1}-512", publicationId, taxonomyId); string keywordUri = string.IsNullOrEmpty(keywordId) ? taxonomyUri : string.Format("tcm:{0}-{1}-1024", publicationId, keywordId); string pageUri = string.Format("tcm:{0}-{1}-64", publicationId, pageId); IEnumerable<SitemapItem> result = new SitemapItem[0]; if (filter.IncludeAncestors) { TaxonomyNode taxonomyRoot = null; if (!string.IsNullOrEmpty(keywordId)) { taxonomyRoot = ExpandAncestorsForKeyword(keywordUri, taxonomyUri, filter, localization); } else if (!string.IsNullOrEmpty(pageId)) { taxonomyRoot = ExpandAncestorsForPage(pageUri, taxonomyUri, filter, localization); } if (taxonomyRoot != null) { if (filter.DescendantLevels != 0) { AddDescendants(taxonomyRoot, filter, localization); } result = new[] { taxonomyRoot }; } } else if (filter.DescendantLevels != 0 && string.IsNullOrEmpty(pageId)) { result = ExpandDescendants(keywordUri, taxonomyUri, filter, localization); } return result; } }
private static void AddDescendants(TaxonomyNode taxonomyNode, NavigationFilter filter, Localization localization) { using (new Tracer(taxonomyNode, filter, localization)) { // First recurse (depth-first) IList<SitemapItem> children = taxonomyNode.Items; foreach (TaxonomyNode childNode in children.OfType<TaxonomyNode>()) { AddDescendants(childNode, filter, localization); } // Add descendants (on the way back) string taxonomyId; string keywordId; string pageId; ParseSitemapItemId(taxonomyNode.Id, out taxonomyId, out keywordId, out pageId); string publicationId = localization.LocalizationId; string taxonomyUri = string.Format("tcm:{0}-{1}-512", publicationId, taxonomyId); string keywordUri = string.IsNullOrEmpty(keywordId) ? taxonomyUri : string.Format("tcm:{0}-{1}-1024", publicationId, keywordId); IEnumerable<SitemapItem> additionalChildren = ExpandDescendants(keywordUri, taxonomyUri, filter, localization); foreach (SitemapItem additionalChildItem in additionalChildren.Where(childItem => children.All(i => i.Id != childItem.Id))) { children.Add(additionalChildItem); } // Ensure that children are ordered correctly taxonomyNode.Items = children.OrderBy(i => i.OriginalTitle).ToList(); } }
public void GetNavigationSubtree_IncludeAncestorsAndChildrenKeywordOrdered_Success() { TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(null, -1); TaxonomyNode testTopLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(testTopLevelKeyword1, "testTopLevelKeyword1"); TaxonomyNode testKeyword12 = testTopLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_2Title) as TaxonomyNode; Assert.IsNotNull(testKeyword12, "testKeyword12"); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 1 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testKeyword12.Id, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); // Result should be the Taxonomy Root only; the ancestor chain is formed using SitemapItem.Items. Assert.AreEqual(1, ancestorItems.Length, "ancestorItems.Length"); TaxonomyNode taxonomyRoot = ancestorItems[0] as TaxonomyNode; AssertExpectedTaxonomyNode(taxonomyRoot, testTaxonomyRoot.Title, 2, "taxonomyRoot"); TaxonomyNode topLevelKeyword1 = taxonomyRoot.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword1, testTopLevelKeyword1.Title, 2, "topLevelKeyword1"); // Check that the context Keyword and its siblings are ordered correctly (context Keyword should be second because of its title) AssertExpectedTaxonomyNode(topLevelKeyword1.Items[0] as TaxonomyNode, TestFixture.Keyword1_1Title, 0, "topLevelKeyword1.Items[0]"); AssertExpectedTaxonomyNode(topLevelKeyword1.Items[1] as TaxonomyNode, TestFixture.Keyword1_2Title, 3, "topLevelKeyword1.Items[1]"); }
private static TaxonomyNode GetTestTaxonomy(IEnumerable<SitemapItem> taxonomyRoots = null, int descendantLevels = 1) { if (taxonomyRoots == null) { NavigationFilter navFilter = new NavigationFilter { DescendantLevels = descendantLevels }; taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, navFilter, TestFixture.ParentLocalization); } TaxonomyNode result = taxonomyRoots.FirstOrDefault(tn => tn.Title == TestFixture.NavigationTaxonomyTitle) as TaxonomyNode; Assert.IsNotNull(result, "Test Taxonomy not found: " + TestFixture.NavigationTaxonomyTitle); return result; }
public void GetNavigationSubtree_TaxonomyRootsAndChildren_Success() { NavigationFilter testNavFilter = new NavigationFilter { DescendantLevels = 2 }; SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(taxonomyRoots, "taxonomyRoots"); OutputJson(taxonomyRoots); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots); Assert.IsNotNull(testTaxonomyRoot.Items, "testTaxonomyRoot.Items"); Assert.AreEqual(2, testTaxonomyRoot.Items.Count, "testTaxonomyRoot.Items.Count"); AssertNoChildItems(testTaxonomyRoot.Items, "testTaxonomyRoot.Items"); }
private static IEnumerable<SitemapItem> ExpandDescendants(string keywordUri, string taxonomyUri, NavigationFilter filter, Localization localization) { using (new Tracer(keywordUri, taxonomyUri, filter, localization)) { TaxonomyFactory taxonomyFactory = new TaxonomyFactory(); TaxonomyFilter taxonomyFilter = new DepthFilter(filter.DescendantLevels, DepthFilter.FilterDown); Keyword contextKeyword = taxonomyFactory.GetTaxonomyKeywords(taxonomyUri, taxonomyFilter, keywordUri); if (contextKeyword == null) { Log.Warn("Keyword '{0}' in Taxonomy '{1}' not found.", keywordUri, taxonomyUri); return new SitemapItem[0]; } TaxonomyNode contextTaxonomyNode = CreateTaxonomyNode(contextKeyword, filter.DescendantLevels, filter, localization); return contextTaxonomyNode.Items; } }
public void GetNavigationSubtree_NonExistingItem_Success() { NavigationFilter descendantsFilter = new NavigationFilter(); NavigationFilter ancestorsFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 0 }; Localization testLocalization = TestFixture.ParentLocalization; IEnumerable<SitemapItem> sitemapItems = _testOnDemandNavigationProvider.GetNavigationSubtree("t666-k666", ancestorsFilter, testLocalization); Assert.IsNotNull(sitemapItems, "sitemapItems"); Assert.IsFalse(sitemapItems.Any(), "sitemapItems.Any()"); IEnumerable<SitemapItem> sitemapItems2 = _testOnDemandNavigationProvider.GetNavigationSubtree("t666-p666", ancestorsFilter, testLocalization); Assert.IsNotNull(sitemapItems2, "sitemapItems2"); Assert.IsFalse(sitemapItems2.Any(), "sitemapItems2.Any()"); IEnumerable<SitemapItem> sitemapItems3 = _testOnDemandNavigationProvider.GetNavigationSubtree("t666", descendantsFilter, testLocalization); Assert.IsNotNull(sitemapItems3, "sitemapItems3"); Assert.IsFalse(sitemapItems3.Any(), "sitemapItems3.Any()"); }
public void GetNavigationSubtree_PageDescendants_Success() { Localization testLocalization = TestFixture.ParentLocalization; TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(); PageModel testPageModel = SiteConfiguration.ContentProvider.GetPageModel(TestFixture.TaxonomyTestPage1UrlPath, testLocalization); string testPageSitemapItemId = string.Format("{0}-p{1}", testTaxonomyRoot.Id, testPageModel.Id); NavigationFilter testNavFilter = new NavigationFilter { DescendantLevels = 1 }; SitemapItem[] childItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testPageSitemapItemId, testNavFilter, testLocalization).ToArray(); Assert.IsNotNull(childItems, "childItems"); OutputJson(childItems); Assert.AreEqual(0, childItems.Length, "childItems.Length"); }
public void GetNavigationSubtree_IncludeAncestorsUnclassifiedPage_Success() { Localization testLocalization = TestFixture.ParentLocalization; TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(); PageModel testPageModel = SiteConfiguration.ContentProvider.GetPageModel(TestFixture.ArticlePageUrlPath, testLocalization); string testPageSitemapItemId = string.Format("{0}-p{1}", testTaxonomyRoot.Id, testPageModel.Id); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 0 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testPageSitemapItemId, testNavFilter, testLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); Assert.AreEqual(0, ancestorItems.Length, "ancestorItems.Length"); }
public void GetNavigationSubtree_IncludeAncestorsKeyword_Success() { TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(null, -1); TaxonomyNode testTopLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(testTopLevelKeyword1, "testTopLevelKeyword1"); TaxonomyNode testKeyword11 = testTopLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title) as TaxonomyNode; Assert.IsNotNull(testKeyword11, "testKeyword11"); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 0 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testKeyword11.Id, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); // Result should be the Taxonomy Root only; the ancestor chain is formed using SitemapItem.Items. Assert.AreEqual(1, ancestorItems.Length, "ancestorItems.Length"); TaxonomyNode taxonomyRoot = ancestorItems[0] as TaxonomyNode; AssertExpectedTaxonomyNode(taxonomyRoot, testTaxonomyRoot.Title, 1, "taxonomyRoot"); TaxonomyNode topLevelKeyword1 = taxonomyRoot.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword1, testTopLevelKeyword1.Title, 1, "topLevelKeyword1"); // This is the context node TaxonomyNode keyword11 = topLevelKeyword1.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword11, testKeyword11.Title, 0, "keyword11"); }
public void GetNavigationSubtree_IncludeAncestorsClassifiedPage_Success() { Localization testLocalization = TestFixture.ParentLocalization; TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(null, -1); TaxonomyNode testTopLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(testTopLevelKeyword1, "testTopLevelKeyword1"); TaxonomyNode testKeyword11 = testTopLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title) as TaxonomyNode; Assert.IsNotNull(testKeyword11, "testKeyword11"); PageModel testPageModel = SiteConfiguration.ContentProvider.GetPageModel(TestFixture.TaxonomyTestPage1UrlPath, testLocalization); string testPageSitemapItemId = string.Format("{0}-p{1}", testTaxonomyRoot.Id, testPageModel.Id); NavigationFilter testNavFilter = new NavigationFilter { IncludeAncestors = true, DescendantLevels = 0 }; SitemapItem[] ancestorItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testPageSitemapItemId, testNavFilter, testLocalization).ToArray(); Assert.IsNotNull(ancestorItems, "ancestorItems"); OutputJson(ancestorItems); // Result should be the Taxonomy Root only; it acts as the subtree root for all ancestors. Assert.AreEqual(1, ancestorItems.Length, "ancestorItems.Length"); TaxonomyNode taxonomyRoot = ancestorItems[0] as TaxonomyNode; AssertExpectedTaxonomyNode(taxonomyRoot, testTaxonomyRoot.Title, 2, "taxonomyRoot"); TaxonomyNode topLevelKeyword1 = taxonomyRoot.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword1, testTopLevelKeyword1.Title, 2, "topLevelKeyword1"); TaxonomyNode keyword11 = topLevelKeyword1.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword11, testKeyword11.Title, 1, "keyword11"); TaxonomyNode keyword112 = keyword11.Items[0] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword112, "Keyword 1.1.2", 0, "keyword112"); TaxonomyNode keyword12 = topLevelKeyword1.Items[1] as TaxonomyNode; AssertExpectedTaxonomyNode(keyword12, "Keyword 1.2", 0, "keyword12"); TaxonomyNode topLevelKeyword2 = taxonomyRoot.Items[1] as TaxonomyNode; AssertExpectedTaxonomyNode(topLevelKeyword2, TestFixture.TopLevelKeyword2Title, 0, "topLevelKeyword2"); }
private static TaxonomyNode ExpandAncestorsForKeyword(string keywordUri, string taxonomyUri, NavigationFilter filter, Localization localization) { using (new Tracer(keywordUri, taxonomyUri, filter, localization)) { TaxonomyFactory taxonomyFactory = new TaxonomyFactory(); TaxonomyFilter taxonomyFilter = new DepthFilter(DepthFilter.UnlimitedDepth, DepthFilter.FilterUp); Keyword taxonomyRoot = taxonomyFactory.GetTaxonomyKeywords(taxonomyUri, taxonomyFilter, keywordUri); if (taxonomyRoot == null) { Log.Warn("Keyword '{0}' in Taxonomy '{1}' not found.", keywordUri, taxonomyUri); return null; } return CreateTaxonomyNode(taxonomyRoot, -1, filter, localization); } }
public void GetNavigationSubtree_TaxonomyRootsOnly_Success() { NavigationFilter testNavFilter = new NavigationFilter(); SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(taxonomyRoots, "taxonomyRoots"); OutputJson(taxonomyRoots); AssertNoChildItems(taxonomyRoots, "taxonomyRoots"); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots); Assert.AreEqual(true, testTaxonomyRoot.HasChildNodes, "testTaxonomyRoot.HasChildNodes"); Assert.AreEqual(4, testTaxonomyRoot.ClassifiedItemsCount, "testTaxonomyRoot.ClassifiedItemsCount"); }
private static TaxonomyNode ExpandAncestorsForPage(string pageUri, string taxonomyUri, NavigationFilter filter, Localization localization) { using (new Tracer(pageUri, taxonomyUri, filter, localization)) { // Get TaxonomyRelationManager.GetTaxonomyKeywords may return multiple paths towards the (same) Taxonomy root. TaxonomyRelationManager taxonomyRelationManager = new TaxonomyRelationManager(); Keyword[] contextKeywords = new Keyword[0]; Keyword[] taxonomyRoots = taxonomyRelationManager.GetTaxonomyKeywords(taxonomyUri, pageUri, contextKeywords, new DepthFilter(-1, DepthFilter.FilterUp), (int) ItemType.Page); if (taxonomyRoots == null || taxonomyRoots.Length == 0) { Log.Debug("Page '{0}' is not classified in Taxonomy '{1}.", pageUri, taxonomyUri); return null; } TaxonomyNode[] taxonomyRootNodes = taxonomyRoots.Select(kw => CreateTaxonomyNode(kw, -1, filter, localization)).ToArray(); // Merge all returned paths into a single subtree TaxonomyNode mergedSubtreeRootNode = taxonomyRootNodes[0]; foreach (TaxonomyNode taxonomyRootNode in taxonomyRootNodes.Skip(1)) { MergeSubtrees(taxonomyRootNode, mergedSubtreeRootNode); } return mergedSubtreeRootNode; } }
public void GetNavigationSubtree_TestTaxonomyChildren_Success() { TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(); NavigationFilter testNavFilter = new NavigationFilter(); SitemapItem[] childItems = _testOnDemandNavigationProvider.GetNavigationSubtree(testTaxonomyRoot.Id, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(childItems, "childItems"); OutputJson(childItems); Assert.AreEqual(2, childItems.Length, "childItems.Length"); AssertNoChildItems(childItems, "childItems"); TaxonomyNode topLevelKeyword1 = childItems.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title) as TaxonomyNode; Assert.IsNotNull(topLevelKeyword1, "topLevelkeyword1"); }
private static IEnumerable<SitemapItem> ExpandTaxonomyRoots(NavigationFilter filter, Localization localization) { using (new Tracer(filter, localization)) { TaxonomyFactory taxonomyFactory = new TaxonomyFactory(); string[] taxonomyIds = taxonomyFactory.GetTaxonomies(GetPublicationTcmUri(localization)); int depth= filter.DescendantLevels > 0 ? (filter.DescendantLevels - 1) : filter.DescendantLevels; TaxonomyFilter taxonomyFilter = new DepthFilter(depth, DepthFilter.FilterDown); IEnumerable<Keyword> taxonomyRoots = taxonomyIds.Select(id => taxonomyFactory.GetTaxonomyKeywords(id, taxonomyFilter)); return taxonomyRoots.Select(kw => CreateTaxonomyNode(kw, depth, filter, localization)); } }
public void GetNavigationSubtree_FullTaxonomies_Success() { NavigationFilter testNavFilter = new NavigationFilter { DescendantLevels = -1 }; SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray(); Assert.IsNotNull(taxonomyRoots, "taxonomyRoots"); OutputJson(taxonomyRoots); TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots); Assert.IsNotNull(testTaxonomyRoot.Items, "testTaxonomyRoot.Items"); Assert.AreEqual(2, testTaxonomyRoot.Items.Count, "testTaxonomyRoot.Items.Count"); SitemapItem topLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title); Assert.IsNotNull(topLevelKeyword1, "topLevelKeyword1"); SitemapItem keyword11 = topLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title); Assert.IsNotNull(keyword11, "keyword11"); SitemapItem keyword112 = keyword11.Items.FirstOrDefault(i => i.Title == "Keyword 1.1.2"); Assert.IsNotNull(keyword112, "keyword112"); Assert.IsNotNull(keyword112.Items, "keyword112.Items"); Assert.AreEqual(1, keyword112.Items.Count, "keyword112.Items.Count"); }