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");
}
