public void Resolve_StylesheetUnderTheme_IncludesStylesheet()
{
// arrange
var templateManager = TemplateFactory.CreateTemplateManager(StylesheetItem.TemplateId);
var stylesheetItemMock = ItemFactory.CreateItem(templateId: StylesheetItem.TemplateId);
ItemFactory.SetIndexerField(stylesheetItemMock, StylesheetItem.Fields.Url, "/url");
var itemMock = ItemFactory.CreateItem();
var children = new ChildList(itemMock.Object, new[] { stylesheetItemMock.Object });
itemMock.Setup(x => x.GetChildren()).Returns(children);
var sut = new ThemeFileResolver(templateManager);
// act
var result = sut.Resolve(itemMock.Object);
// assert
Assert.That(result.Scripts, Is.Empty);
Assert.That(result.Stylesheets.Count(), Is.EqualTo(1));
var stylesheet = result.Stylesheets.First();
Assert.That(stylesheet.Url, Is.EqualTo("/url"));
}
public void GetCategories_MixedTemplates()
{
var settings = MockSettings(ID.NewID, ID.NewID, ID.NewID);
var templateManager = TemplateFactory.CreateTemplateManager(settings.CategoryTemplateIds.Concat(settings.BlogTemplateIds).ToArray());
var manager = new CategoryManager(settings, templateManager);
using (var db = new Db
{
new DbItem("blog", ID.NewID, settings.BlogTemplateIds.First())
{
new DbItem("Categories", ID.NewID, ID.NewID)
{
new DbItem("alpha", ID.NewID, settings.CategoryTemplateIds.ElementAt(0)),
new DbItem("beta", ID.NewID, settings.CategoryTemplateIds.ElementAt(1)),
new DbItem("gamma", ID.NewID, settings.CategoryTemplateIds.ElementAt(2))
},
new DbItem("Entries", ID.NewID, ID.NewID)
{
new DbItem("entry1", ID.NewID, settings.EntryTemplateIds.First())
}
}
})
{
var entryItem = db.GetItem("/sitecore/content/blog/entries/entry1");
var categories = manager.GetCategories(entryItem);
var categoryNames = from c in categories select c.Name;
Assert.That(categoryNames, Is.EquivalentTo(new[] { "alpha", "beta", "gamma" }));
}
}
public void Resolve_DerivedScriptUnderTheme_IncludesScript()
{
// arrange
var derivedTemplateId = ID.NewID;
var templates = new TemplateCollection();
var scriptTemplate = TemplateFactory.CreateTemplate(ScriptItem.TemplateId, null, templates);
var derivedScriptTemplate = TemplateFactory.CreateTemplate(derivedTemplateId, ScriptItem.TemplateId, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { scriptTemplate, derivedScriptTemplate });
var scriptItemMock = ItemFactory.CreateItem(templateId: derivedTemplateId);
ItemFactory.SetIndexerField(scriptItemMock, FileItem.Fields.Url, "/url");
ItemFactory.SetIndexerField(scriptItemMock, ScriptItem.ScriptItemFields.FallbackUrl, "/fallbackurl");
ItemFactory.SetIndexerField(scriptItemMock, ScriptItem.ScriptItemFields.VerificationObject, "object");
var itemMock = ItemFactory.CreateItem();
var children = new ChildList(itemMock.Object, new[] { scriptItemMock.Object });
itemMock.Setup(x => x.GetChildren()).Returns(children);
var sut = new ThemeFileResolver(templateManager);
// act
var result = sut.Resolve(itemMock.Object);
// assert
Assert.That(result.Stylesheets, Is.Empty);
Assert.That(result.Scripts.Count(), Is.EqualTo(1));
var script = result.Scripts.First();
Assert.That(script.Url, Is.EqualTo("/url"));
Assert.That(script.FallbackUrl, Is.EqualTo("/fallbackurl"));
Assert.That(script.VerificationObject, Is.EqualTo("object"));
}
private BaseTemplateManager CreateTemplateManager(ID feedTemplateId)
{
var templates = new TemplateCollection();
var template = TemplateFactory.CreateTemplate(feedTemplateId, ID.NewID, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { template });
return(templateManager);
}
public void TemplateIsOrBasedOn_ItemIsNull_ReturnsFalse()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.TemplateIsOrBasedOn(null, templateManager, new[] { templateId });
// assert
Assert.That(result, Is.False);
}
public void TemplateIsOrBasedOn_ItemIsNull_ReturnsFalse()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = templateManager.TemplateIsOrBasedOn(null, new[] { templateId });
// assert
Assert.That(result, Is.False);
}
public void FindAncestorByAnyTemplate_NullItem_ReturnsNull()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.FindAncestorByAnyTemplate(null, new[] { templateId }, templateManager);
// assert
Assert.That(result, Is.Null);
}
public void Add(string contextItemPath, string name, bool expectCategory)
{
var settings = MockSettings(ID.NewID, ID.NewID);
var templateManager = TemplateFactory.CreateTemplateManager(settings.CategoryTemplateIds.Concat(settings.BlogTemplateIds).ToArray());
var manager = new CategoryManager(settings, templateManager);
using (var db = new Db
{
new DbTemplate("category1", settings.CategoryTemplateIds.ElementAt(0))
{
new DbField("Title")
},
new DbTemplate("category2", settings.CategoryTemplateIds.ElementAt(1))
{
new DbField("Title")
},
new DbItem("blog", ID.NewID, settings.BlogTemplateIds.First())
{
new DbItem("Categories", ID.NewID, ID.NewID)
{
new DbItem("alpha", ID.NewID, settings.CategoryTemplateIds.ElementAt(0)),
new DbItem("beta", ID.NewID, settings.CategoryTemplateIds.ElementAt(1)),
new DbItem("gamma", ID.NewID, settings.CategoryTemplateIds.ElementAt(0))
},
new DbItem("Entries", ID.NewID, ID.NewID)
{
new DbItem("entry1", ID.NewID, settings.EntryTemplateIds.First())
}
}
})
{
var entryItem = contextItemPath != null?db.GetItem(contextItemPath) : null;
CategoryItem categoryItem = null;
using (new SecurityDisabler())
{
categoryItem = manager.Add(name, entryItem);
}
if (expectCategory)
{
Assert.That(categoryItem, Is.Not.Null);
Assert.That(categoryItem.Name, Is.EqualTo(name));
}
else
{
Assert.That(categoryItem, Is.Null);
}
}
}
public void TemplateIsOrBasedOn_TemplateMatches_ReturnsTrue()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
var itemMock = ItemFactory.CreateItem(templateId: templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.TemplateIsOrBasedOn(itemMock.Object, templateManager, new[] { templateId });
// assert
Assert.That(result, Is.True);
}
public void Resolve_ThemeIsNull_ReturnsEmptyThemeFiles()
{
// arrange
var templateManager = TemplateFactory.CreateTemplateManager(StylesheetItem.TemplateId);
var sut = new ThemeFileResolver(templateManager);
// act
var result = sut.Resolve(null);
// assert
Assert.That(result.Stylesheets, Is.Empty);
Assert.That(result.Scripts, Is.Empty);
}
public void FindAncestorByAnyTemplate_ItemBasedOnTemplate_ReturnsItem()
{
// arrange
var templateId = ID.NewID;
var item = ItemFactory.CreateItem(templateId: templateId).Object;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.FindAncestorByAnyTemplate(item, new[] { templateId }, templateManager);
// assert
Assert.That(result.ID, Is.EqualTo(item.ID));
}
public void TemplateIsOrBasedOnSingle_TemplateMatches_ReturnsTrue()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
var itemMock = ItemFactory.CreateItem(templateId: templateId);
// act
var result = templateManager.TemplateIsOrBasedOn(itemMock.Object, templateId);
// assert
Assert.That(result, Is.True);
}
public void TemplateIsOrBasedOn_InvalidTemplate_ReturnsFalse()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
var itemMock = ItemFactory.CreateItem(templateId);
// act
var result = templateManager.TemplateIsOrBasedOn(itemMock.Object, new[] { ID.NewID });
// assert
Assert.That(result, Is.False);
}
public void TemplateIsOrBasedOn_TemplatesIsNull_ReturnsFalse()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
var itemMock = ItemFactory.CreateItem(templateId);
// act
var result = templateManager.TemplateIsOrBasedOn(itemMock.Object, (IEnumerable <ID>)null);
// assert
Assert.That(result, Is.False);
}
public void FindAncestorByAnyTemplate_NoTemplates_ReturnsNull()
{
// arrange
var templateId = ID.NewID;
var item = ItemFactory.CreateItem(templateId: templateId).Object;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.FindAncestorByAnyTemplate(item, Enumerable.Empty <ID>(), templateManager);
// assert
Assert.That(result, Is.Null);
}
public void TemplateIsOrBasedOn_TemplatesIsEmpty_ReturnsFalse()
{
// arrange
var templateId = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
var itemMock = ItemFactory.CreateItem(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.TemplateIsOrBasedOn(itemMock.Object, templateManager, Enumerable.Empty <ID>());
// assert
Assert.That(result, Is.False);
}
public void TemplateIsOrBasedOnSingle_TemplateDoesNotMatch_ReturnsFalse()
{
// arrange
var templateId1 = ID.NewID;
var templateId2 = ID.NewID;
var templateManager = TemplateFactory.CreateTemplateManager(templateId1, templateId2);
var itemMock = ItemFactory.CreateItem(templateId2);
// act
var result = templateManager.TemplateIsOrBasedOn(itemMock.Object, templateId1);
// assert
Assert.That(result, Is.False);
}
public void Resolve_ThemeHasNoChildren_ReturnsEmptyThemeFiles()
{
// arrange
var templateManager = TemplateFactory.CreateTemplateManager(StylesheetItem.TemplateId);
var item = ItemFactory.CreateItem().Object;
var sut = new ThemeFileResolver(templateManager);
// act
var result = sut.Resolve(item);
// assert
Assert.That(result.Stylesheets, Is.Empty);
Assert.That(result.Scripts, Is.Empty);
}
public void Resolve_StylesheetsAndScriptsUnderTheme_IncludesReferences()
{
// arrange
var templateManager = TemplateFactory.CreateTemplateManager(ScriptItem.TemplateId, StylesheetItem.TemplateId);
var stylesheetItem1Mock = ItemFactory.CreateItem(templateId: StylesheetItem.TemplateId);
ItemFactory.SetIndexerField(stylesheetItem1Mock, StylesheetItem.Fields.Url, "/url");
var stylesheetItem2Mock = ItemFactory.CreateItem(templateId: StylesheetItem.TemplateId);
ItemFactory.SetIndexerField(stylesheetItem2Mock, StylesheetItem.Fields.Url, "/url2");
var scriptItemMock = ItemFactory.CreateItem(templateId: ScriptItem.TemplateId);
ItemFactory.SetIndexerField(scriptItemMock, FileItem.Fields.Url, "/url");
ItemFactory.SetIndexerField(scriptItemMock, ScriptItem.ScriptItemFields.FallbackUrl, "/fallbackurl");
ItemFactory.SetIndexerField(scriptItemMock, ScriptItem.ScriptItemFields.VerificationObject, "object");
var itemMock = ItemFactory.CreateItem();
var children = new ChildList(itemMock.Object, new[] { scriptItemMock.Object, stylesheetItem1Mock.Object, stylesheetItem2Mock.Object });
itemMock.Setup(x => x.GetChildren()).Returns(children);
var sut = new ThemeFileResolver(templateManager);
// act
var result = sut.Resolve(itemMock.Object);
// assert
Assert.That(result.Stylesheets.Count(), Is.EqualTo(2));
Assert.That(result.Scripts.Count(), Is.EqualTo(1));
var stylesheet1 = result.Stylesheets.First();
Assert.That(stylesheet1.Url, Is.EqualTo("/url"));
var stylesheet2 = result.Stylesheets.ElementAt(1);
Assert.That(stylesheet2.Url, Is.EqualTo("/url2"));
var script = result.Scripts.First();
Assert.That(script.Url, Is.EqualTo("/url"));
Assert.That(script.FallbackUrl, Is.EqualTo("/fallbackurl"));
Assert.That(script.VerificationObject, Is.EqualTo("object"));
}
public void FindAncestorByAnyTemplate_NoAncestorsBasedOnTemplate_ReturnsNull()
{
// arrange
var templateId = ID.NewID;
var itemMock = ItemFactory.CreateItem();
var parentItem = ItemFactory.CreateItem().Object;
ItemFactory.SetParent(itemMock, parentItem);
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.FindAncestorByAnyTemplate(itemMock.Object, new[] { templateId }, templateManager);
// assert
Assert.That(result, Is.Null);
}
public void GetCategories_MixedDerivedTemplates()
{
var baseBaseTemplateId = ID.NewID;
var baseTemplateId = ID.NewID;
var categoryTemplateId = ID.NewID;
var settings = MockSettings(baseBaseTemplateId, baseTemplateId, categoryTemplateId);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { baseBaseTemplateId, baseTemplateId, categoryTemplateId, settings.BlogTemplateIds.First() });
var manager = new CategoryManager(settings, templateManager);
using (var db = new Db
{
new DbTemplate(baseBaseTemplateId),
new DbTemplate(baseTemplateId)
{
BaseIDs = new[] { baseBaseTemplateId }
},
new DbTemplate(categoryTemplateId)
{
BaseIDs = new[] { baseTemplateId }
},
new DbItem("blog", ID.NewID, settings.BlogTemplateIds.First())
{
new DbItem("Categories", ID.NewID, ID.NewID)
{
new DbItem("alpha", ID.NewID, categoryTemplateId),
new DbItem("beta", ID.NewID, baseTemplateId),
new DbItem("gamma", ID.NewID, baseBaseTemplateId)
},
new DbItem("Entries", ID.NewID, ID.NewID)
{
new DbItem("entry1", ID.NewID, settings.EntryTemplateIds.First())
}
}
})
{
var entryItem = db.GetItem("/sitecore/content/blog/entries/entry1");
var categories = manager.GetCategories(entryItem);
var categoryNames = from c in categories select c.Name;
Assert.That(categoryNames, Is.EquivalentTo(new[] { "alpha", "beta", "gamma" }));
}
}
public void FindAncestorByAnyTemplate_AncestorBasedOnTemplate_ReturnsAncestor()
{
// arrange
var templateId = ID.NewID;
var itemMock = ItemFactory.CreateItem();
var parentItemMock = ItemFactory.CreateItem();
var grantParentItemMock = ItemFactory.CreateItem(templateId: templateId).Object;
ItemFactory.SetParent(itemMock, parentItemMock.Object);
ItemFactory.SetParent(parentItemMock, grantParentItemMock);
var templateManager = TemplateFactory.CreateTemplateManager(templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.FindAncestorByAnyTemplate(itemMock.Object, new[] { templateId }, templateManager);
// assert
Assert.That(result.ID, Is.EqualTo(grantParentItemMock.ID));
}
public void TemplateIsOrBasedOn_DerivedTemplateMatches_ReturnsTrue()
{
// arrange
var baseTemplateId = ID.NewID;
var templateId = ID.NewID;
var templates = new TemplateCollection();
var baseTemplate = TemplateFactory.CreateTemplate(baseTemplateId, null, templates);
var template = TemplateFactory.CreateTemplate(templateId, baseTemplateId, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { baseTemplate, template });
var itemMock = ItemFactory.CreateItem(templateId: templateId);
// act
var result = Sitecore.Modules.WeBlog.Extensions.ItemExtensions.TemplateIsOrBasedOn(itemMock.Object, templateManager, new[] { baseTemplateId });
// assert
Assert.That(result, Is.True);
}
public void Resolve_UnknownChildrenUnderTheme_ReturnsEmptyThemeFiles()
{
// arrange
var templateManager = TemplateFactory.CreateTemplateManager(StylesheetItem.TemplateId);
var stylesheetItemMock = ItemFactory.CreateItem();
var itemMock = ItemFactory.CreateItem();
var children = new ChildList(itemMock.Object, new[] { stylesheetItemMock.Object });
itemMock.Setup(x => x.GetChildren()).Returns(children);
var sut = new ThemeFileResolver(templateManager);
// act
var result = sut.Resolve(itemMock.Object);
// assert
Assert.That(result.Stylesheets, Is.Empty);
Assert.That(result.Scripts, Is.Empty);
}
public void Resolve_ItemBasedOnDerivedBlogTemplate_ReturnsSettingsFromBlog()
{
// arrange
var categoryTemplateId = ID.NewID;
var entryTemplateId = ID.NewID;
var commentTemplateId = ID.NewID;
var blogTemplateId = ID.NewID;
var baseBlogTemplateId = ID.NewID;
var templates = new TemplateCollection();
var baseTemplate = TemplateFactory.CreateTemplate(baseBlogTemplateId, null, templates);
var blogTemplate = TemplateFactory.CreateTemplate(blogTemplateId, baseBlogTemplateId, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { blogTemplate });
var item = ItemFactory.CreateItem(templateId: blogTemplateId);
var categoryField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Category Template", categoryTemplateId.ToString());
var entryField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Entry Template", entryTemplateId.ToString());
var commentField = FieldFactory.CreateField(item.Object, ID.NewID, "Defined Comment Template", commentTemplateId.ToString());
ItemFactory.AddFields(item, new[] { categoryField, entryField, commentField });
var weBlogsettings = Mock.Of <IWeBlogSettings>(x =>
x.CategoryTemplateIds == new[] { ID.NewID } &&
x.EntryTemplateIds == new[] { ID.NewID } &&
x.CommentTemplateIds == new[] { ID.NewID } &&
x.BlogTemplateIds == new[] { baseBlogTemplateId }
);
var sut = new BlogSettingsResolver(templateManager, weBlogsettings);
// act
var result = sut.Resolve(item.Object);
// assert
Assert.That(result.CategoryTemplateID, Is.EqualTo(categoryTemplateId));
Assert.That(result.EntryTemplateID, Is.EqualTo(entryTemplateId));
Assert.That(result.CommentTemplateID, Is.EqualTo(commentTemplateId));
}
public void GetCategory(string startItemPath, string categoryName, bool shouldFindCategory)
{
var categoryTemplateId = ID.NewID;
var settings = MockSettings(categoryTemplateId);
var templateManager = TemplateFactory.CreateTemplateManager(categoryTemplateId, settings.BlogTemplateIds.First());
var manager = new CategoryManager(settings, templateManager);
using (var db = new Db
{
new DbItem("blog", ID.NewID, settings.BlogTemplateIds.First())
{
new DbItem("Categories", ID.NewID, ID.NewID)
{
new DbItem("alpha", ID.NewID, settings.CategoryTemplateIds.First()),
new DbItem("beta", ID.NewID, settings.CategoryTemplateIds.First()),
new DbItem("gamma", ID.NewID, settings.CategoryTemplateIds.First())
},
new DbItem("Entries", ID.NewID, ID.NewID)
{
new DbItem("entry1", ID.NewID, settings.EntryTemplateIds.First())
}
}
})
{
var startItem = string.IsNullOrEmpty(startItemPath) ? null : db.GetItem(startItemPath);
var categoryItem = manager.GetCategory(startItem, categoryName);
if (shouldFindCategory)
{
Assert.That(categoryItem, Is.Not.Null);
Assert.That(categoryItem.Name, Is.EqualTo(categoryName));
}
else
{
Assert.That(categoryItem, Is.Null);
}
}
}
public void GetCategories(string startItemPath, bool expectCategories)
{
var categoryTemplateId = ID.NewID;
var settings = MockSettings(categoryTemplateId);
var templateManager = TemplateFactory.CreateTemplateManager(categoryTemplateId, settings.BlogTemplateIds.First());
var manager = new CategoryManager(settings, templateManager);
using (var db = new Db
{
new DbItem("blog", ID.NewID, settings.BlogTemplateIds.First())
{
new DbItem("Categories", ID.NewID, ID.NewID)
{
new DbItem("alpha", ID.NewID, settings.CategoryTemplateIds.First()),
new DbItem("beta", ID.NewID, settings.CategoryTemplateIds.First()),
new DbItem("gamma", ID.NewID, settings.CategoryTemplateIds.First())
},
new DbItem("a folder", ID.NewID, ID.NewID)
{
new DbItem("entry1", ID.NewID, settings.EntryTemplateIds.First())
}
}
})
{
var startItem = string.IsNullOrEmpty(startItemPath) ? null : db.GetItem(startItemPath);
var categories = manager.GetCategories(startItem);
var categoryNames = from c in categories select c.Name;
if (expectCategories)
{
Assert.That(categoryNames, Is.EquivalentTo(new [] { "alpha", "beta", "gamma" }));
}
else
{
Assert.That(categoryNames, Is.Empty);
}
}
}
public void GetCurrentBlog_CustomTemplates(string startPath, string expectedPath)
{
var blogTemplateId = ID.NewID;
var customBlogTemplateId = ID.NewID;
var entryTemplateId = ID.NewID;
var customEntryTemplateId = ID.NewID;
var settings = Mock.Of <IWeBlogSettings>(x =>
x.BlogTemplateIds == new[] { ID.NewID, ID.NewID, blogTemplateId, ID.NewID } &&
x.EntryTemplateIds == new[] { ID.NewID, entryTemplateId, ID.NewID }
);
var templates = new TemplateCollection();
var blogTemplate = TemplateFactory.CreateTemplate(blogTemplateId, null, templates);
var customBlogTemplate = TemplateFactory.CreateTemplate(customBlogTemplateId, blogTemplateId, templates);
var entryTemplate = TemplateFactory.CreateTemplate(entryTemplateId, null, templates);
var customEntryTemplate = TemplateFactory.CreateTemplate(customEntryTemplateId, entryTemplateId, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { blogTemplate, customBlogTemplate, entryTemplate, customEntryTemplate });
using (var db = new Db
{
new DbItem("blog", ID.NewID, customBlogTemplateId)
{
new DbItem("entries")
{
new DbItem("entry", ID.NewID, customEntryTemplateId)
}
}
})
{
var startItem = db.GetItem(startPath);
var manager = CreateBlogManager(settings: settings, templateManager: templateManager);
var resultItem = manager.GetCurrentBlog(startItem);
Assert.That(resultItem.ID, Is.EqualTo(resultItem.ID));
};
}
public void TemplateIsOrBasedOn_DerivedTemplateChainMatches_ReturnsTrue()
{
// arrange
var baseTemplateId1 = ID.NewID;
var baseTemplateId2 = ID.NewID;
var baseTemplateId3 = ID.NewID;
var templateId = ID.NewID;
var templates = new TemplateCollection();
var baseTemplate1 = TemplateFactory.CreateTemplate(baseTemplateId1, null, templates);
var baseTemplate2 = TemplateFactory.CreateTemplate(baseTemplateId2, baseTemplateId1, templates);
var baseTemplate3 = TemplateFactory.CreateTemplate(baseTemplateId3, baseTemplateId2, templates);
var template = TemplateFactory.CreateTemplate(templateId, baseTemplateId3, templates);
var templateManager = TemplateFactory.CreateTemplateManager(new[] { baseTemplate1, baseTemplate2, baseTemplate3, template });
var itemMock = ItemFactory.CreateItem(templateId: templateId);
// act
var result = templateManager.TemplateIsOrBasedOn(itemMock.Object, new[] { baseTemplateId1 });
// assert
Assert.That(result, Is.True);
}
public void GetCurrentBlog(string startPath, string expectedPath)
{
var blogTemplateId = ID.NewID;
var entryTemplateId = ID.NewID;
var settings = Mock.Of <IWeBlogSettings>(x =>
x.BlogTemplateIds == new[] { blogTemplateId } &&
x.EntryTemplateIds == new[] { entryTemplateId }
);
var templateManager = TemplateFactory.CreateTemplateManager(blogTemplateId, entryTemplateId);
using (var db = new Db
{
new DbItem("blog", ID.NewID, blogTemplateId)
{
new DbItem("entries")
{
new DbItem("entry", ID.NewID, entryTemplateId)
}
}
})
{
var startItem = db.GetItem(startPath);
var manager = CreateBlogManager(settings: settings, templateManager: templateManager);
var resultItem = manager.GetCurrentBlog(startItem);
if (expectedPath == null)
{
Assert.That(resultItem, Is.Null);
}
else
{
Assert.That(resultItem.ID, Is.EqualTo(resultItem.ID));
}
};
}
