public void CreateTemplate_SimpleType_CreatesInstanceOfType()
{
Type t = typeof(DummyTemplate);
var factory = new TemplateFactory(t);
var actual = factory.CreateTemplate();
Assert.IsInstanceOf<DummyTemplate>(actual);
}
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 CreateTemplate_SimpleType_CreatesInstanceOfType()
{
Type t = typeof(DummyTemplate);
var factory = new TemplateFactory(t);
var actual = factory.CreateTemplate();
Assert.IsInstanceOf <DummyTemplate>(actual);
}
internal ITemplate CreateTemplate(string typeName, object model)
{
if (ClassTypes != null && ClassTypes.Contains(typeName))
{
return(TemplateFactory.CreateTemplate("TypeScript", "Class", model));
}
return(TemplateFactory.CreateTemplate("TypeScript", TypeStyle.ToString(), model));
}
private static void RenderTemplateFromTemplateFactory(TemplateFactory templateFactory, Stream stream,
dynamic model, NancyContext context)
{
var streamWriter = new StreamWriter(stream);
var template = (NancyNHamlTemplateBase)templateFactory.CreateTemplate();
template.Model = model;
template.Context = context;
template.Render(streamWriter);
streamWriter.Flush();
}
private static void RenderTemplateFromTemplateFactory(TemplateFactory templateFactory, Stream stream,
dynamic model, NancyContext context)
{
var streamWriter = new StreamWriter(stream);
var template = (NancyNHamlTemplateBase)templateFactory.CreateTemplate();
template.Model = model;
template.Context = context;
template.Render(streamWriter);
streamWriter.Flush();
}
/// <summary>
/// Returns the <see cref="DataTemplate"/> for defined view template.
/// </summary>
/// <returns>The generated <see cref="DataTemplate"/>.</returns>
internal DataTemplate ProvideTemplate()
{
if (template == null && viewType != null)
{
template = TemplateFactory.CreateTemplate(viewType);
template.DataType = modelType;
template.Seal();
}
return(template);
}
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_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 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);
}
