public void RenderGadgetSimpleTemplates()
{
GadgetWithSimpleTemplate data = new GadgetWithSimpleTemplate();
GadgetMaster target = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, data.Source);
ResolveDataControlValues(target.MyDataContext, data.ExpectedViewer, data.ExpectedViewer, data.ExpectedFriends);
Assert.IsTrue(target.IsParsed);
Assert.IsTrue(target.MyOffset.ToString().IndexOf("ContentBlock") > -1, "Content Block not found in offsets");
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.SuppressWhitespace = true;
target.ClientRenderCustomTemplates = false;
string result = target.RenderToString("canvas");
result = ControlTestHelper.NormalizeRenderResult(result);
//remove double spaces
while (result.Contains(" "))
{
result = result.Replace(" ", " ");
}
string expectedCanvas = ControlTestHelper.NormalizeRenderResult(data.ExpectedCanvas);
Assert.IsFalse(string.IsNullOrEmpty(result), "empty result");
Assert.AreEqual(expectedCanvas, result, "Rendered results are incorrect");
}
public void RenderWithSharedDataKeys()
{
GadgetMaster target;
DataGadgetTestData data = new DataGadgetSharedDataKeys();
target = new GadgetMaster(testFactory, data.Source);
ResolveDataControlValues(target.MyDataContext, data.ExpectedViewer, data.ExpectedViewer, data.ExpectedFriends);
target.RenderingOptions.ClientRenderCustomTemplates = false;
target.RenderingOptions.ClientRenderDataContext = false;
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.SuppressWhitespace = true;
//vwr, myfriends
string result;
result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("canvas"));
Assert.AreEqual(ControlTestHelper.NormalizeRenderResult(data.ExpectedCanvas), result, "Canvas Incorrect");
result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("home"));
Assert.AreEqual(ControlTestHelper.NormalizeRenderResult(data.ExpectedHome), result, "Home Incorrect");
result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("profile"));
Assert.AreEqual(ControlTestHelper.NormalizeRenderResult(data.ExpectedProfile), result, "Profile Incorrect");
}
public void TagSimpleElementParametersRender()
{
string content = "My favorite color is {0}";
string param = "color";
string tag = "x:Foo";
string val = "blue";
string template = "<script type='text/os-template' tag='{0}'>\n{1}</script>";
template = String.Format(template, tag, string.Format(content, "${My." + param + "}"));
string elemInstMarkup = "<{0}><{1}>{2}</{1}></{0}>";
string tagInstanceMarkup = string.Format(elemInstMarkup, new string[] { tag, param, val });
string expected = string.Format(content, val);
factory.RegisterCustomTag(tag, template);
CustomTag inst = factory.CreateTagInstance(tag, tagInstanceMarkup);
Assert.AreEqual(val, inst.Parameters[param], "Registered instance value incorrect");
string result = ControlTestHelper.GetRenderedContents(inst);
result = ControlTestHelper.NormalizeRenderResult(result);
Assert.AreEqual(expected, result, "Rendered results incorrect");
}
public void ViewsStandardTest()
{
GadgetWithViews data = new GadgetWithViews();
GadgetMaster target = new GadgetMaster(testFactory, data.Source);
target.RenderingOptions.DivWrapContentSubViews = false;
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.ClientRenderDataContext = false;
string result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("canvas"));
Assert.AreEqual(data.ExpectedCanvas, result, "Canvas incorrect");
String[,] td = new String[, ] {
{ "canvas", data.ExpectedCanvas },
{ "Canvas", data.ExpectedCanvas },
{ "mobilecanvas", data.ExpectedMobileCanvas },
{ "home", data.ExpectedHome },
{ "profile", data.ExpectedProfile }
};
for (int i = 0; i < td.Length / 2; i++)
{
result = ControlTestHelper.NormalizeRenderResult(target.RenderToString(td[i, 0]));
Assert.AreEqual(td[i, 1], result, td[i, 0] + " render incorrect");
}
}
/// <summary>
/// Tests the rendered results against expected output.
/// Trims to remove leading and trailing whitespace
/// </summary>
/// <param name="control"></param>
/// <param name="expectedResult"></param>
/// <returns></returns>
public bool AssertRenderResultsEqual(BaseGadgetControl control, string expectedResult)
{
string result = ControlTestHelper.GetRenderedContents(control);
result = ControlTestHelper.NormalizeRenderResult(result);
expectedResult = ControlTestHelper.NormalizeRenderResult(expectedResult);
return(result == expectedResult);
}
void CheckRender(GadgetMaster target, string view, string expected)
{
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.ClientRenderDataContext = false;
string result = ControlTestHelper.NormalizeRenderResult(target.RenderToString(view));
Assert.AreEqual(ControlTestHelper.NormalizeRenderResult(expected), result, view + " view incorrect");
}
public void TagParameterRegistrationVariantsTest()
{
GadgetCustomTagTemplates testData = new GadgetCustomTagTemplates();
GadgetMaster target = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, testData.Source);
string result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("canvas"));
Assert.IsNotNull(result, "Empty render result");
Assert.IsTrue(result.Contains(testData.ExpectedParamAttributeValue), "Attribute parameter not correctly rendered");
Assert.IsTrue(result.Contains(testData.ExpectedParamElementValue), "Element parameter not correctly rendered");
Assert.IsTrue(result.Contains(testData.ExpectedVariableValue), "osVar parameter not correctly rendered");
}
public void SecurityPolicyAffectsRender()
{
SecurityPolicyGadget data = new SecurityPolicyGadget();
GadgetMaster target = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, data.Source);
target.RenderingOptions.DivWrapContentBlocks = false;
string key = "markup";
string result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("canvas"));
Assert.AreEqual(data.ExpectedCanvas, result);
}
/// <summary>
/// Helper to check the rendered results
/// </summary>
/// <param name="gadget"></param>
void TestRepeaterRenderResult(DataGadgetTestData gadget)
{
GadgetMaster master = null;
master = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, gadget.Source);
master.RenderingOptions.DivWrapContentBlocks = false;
ResolveDataControlValues(master.MyDataContext, gadget.ExpectedViewer, gadget.ExpectedViewer, gadget.ExpectedFriends);
string result = ControlTestHelper.GetRenderedContents(master, "canvas");
string expected = gadget.ExpectedCanvas.Trim().Replace("\r\n", "\n");
Assert.AreEqual(ControlTestHelper.NormalizeRenderResult(expected), ControlTestHelper.NormalizeRenderResult(result), "Rendered results incorrect");
}
public void MissingViewTest()
{
GadgetWithViews data = new GadgetWithViews();
GadgetMaster target = new GadgetMaster(testFactory, data.Source);
target.RenderingOptions.DivWrapContentSubViews = false;
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.ClientRenderDataContext = false;
string result = ControlTestHelper.NormalizeRenderResult(target.RenderToString("mobilecanvas"));
Assert.AreEqual(data.ExpectedMobileCanvas, result, "Mobile Canvas incorrect");
}
public void TestContentRenderTrailingScript()
{
ContentBlockTrailingClientScript testContent = new ContentBlockTrailingClientScript();
GadgetMaster master = new GadgetMaster(testFactory);
ContentBlock block = new ContentBlock();
master.AddContentBlock(block);
block.LoadTag(testContent.Source);
block.IncludeWrappingDivs = false;
string tagRendered = ControlTestHelper.NormalizeRenderResult(ControlTestHelper.GetRenderedContents(block));
Assert.IsTrue(tagRendered.Length > 0, "Empty rendered tag from content");
Assert.AreEqual(ControlTestHelper.NormalizeRenderResult(testContent.ExpectedCanvas), tagRendered);
}
public void LiteralsWithCDataHonored(string raw, bool suppressCDATA, string expected)
{
GadgetLiteral control = new GadgetLiteral(raw);
Assert.AreEqual(raw, control.RawTag);
Assert.AreEqual(raw, control.InnerMarkup);
control.SuppressCDATATags = suppressCDATA;
string rendered = ControlTestHelper.NormalizeRenderResult(
ControlTestHelper.GetRenderedContents(control));
expected = ControlTestHelper.NormalizeRenderResult(expected);
Assert.AreEqual(expected, rendered, "Rendered results do not match expectations");
}
public void TestSurfaceViewRender(string source, string surfaceName, string expected)
{
GadgetMaster target;
target = new GadgetMaster(testFactory, source);
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.DivWrapContentSubViews = false;
AccountTestData.ResolveDataControlValues(target.MyDataContext, GadgetTestData.Viewer, GadgetTestData.Viewer, null);
string written = ControlTestHelper.GetRenderedContents(target, surfaceName);
expected = ControlTestHelper.NormalizeRenderResult(expected);
written = ControlTestHelper.NormalizeRenderResult(written);
Assert.AreEqual(expected.Length, written.Length, "Lengths do not match");
Assert.AreEqual(expected, written, "Rendered gadget not expected from view: [" + surfaceName + "]\nEXPECTED:\n" + expected + "\n\nWRITTEN:\n" + written);
}
public void RenderGadgetWithoutTemplates()
{
GadgetWithoutTemplatesData data = new GadgetWithoutTemplatesData();
GadgetMaster target = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, data.Source);
Assert.IsTrue(target.IsParsed);
Assert.IsTrue(target.MyOffset.ToString().IndexOf("ContentBlock") > -1, "Content Block not found in offsets");
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.SuppressWhitespace = true;
target.ClientRenderCustomTemplates = false;
string result = target.RenderToString("canvas");
result = ControlTestHelper.NormalizeRenderResult(result);
Assert.IsFalse(string.IsNullOrEmpty(result), "empty result");
Assert.AreEqual(data.ExpectedCanvas, result, "Rendered results are incorrect");
}
public void TagTopVariableParametersRender()
{
string name = "Yohan";
Person viewer = ControlTestHelper.CreatePerson(909, name, null);
string content = "My Name is {1} and my favorite color is {0}";
string param = "color";
string tag = "x:Foo";
string val = "blue";
string paramTop = "vwr.displayName";
//${Top.vwr.DisplayName}
string template = "<script type='text/os-template' tag='{0}'>\n{1}</script>";
template = String.Format(template, tag, string.Format(content, "${My." + param + "}", "${Top." + paramTop + "}"));
string elemInstMarkup = "<{0}><{1}>{2}</{1}></{0}>";
string tagInstanceMarkup = string.Format(elemInstMarkup, new string[] { tag, param, val });
string expected = string.Format(content, val, name);
factory.RegisterCustomTag(tag, template);
DataContext dc = factory.MyRootMaster.MyDataContext;
ResolveDataControlValues(dc, viewer, viewer, null);
OsViewerRequest viewerReq = new OsViewerRequest();
viewerReq.Key = "vwr";
dc.RegisterDataItem(viewerReq);
ResolveDataControlValues(dc, viewer, viewer, null);
CustomTag inst = factory.CreateTagInstance(tag, tagInstanceMarkup);
Assert.AreEqual(val, inst.Parameters[param], "Registered instance value incorrect");
string result = ControlTestHelper.GetRenderedContents(inst);
result = ControlTestHelper.NormalizeRenderResult(result);
Assert.AreEqual(expected, result, "Rendered results incorrect");
}
public void DynamicDataElementParametersRender()
{
string name = "Yohan";
Person viewer = ControlTestHelper.CreatePerson(909, name, null);
string content = "My Name is {0}";
string param = "thisPerson";
string mainPersonDataKey = "vwr";
//string instVariable = "${" + param
string paramGet = param + ".displayName";
string tag = "x:Foo";
string template = "<script type='text/os-template' tag='{0}'>\n{1}</script>";
template = String.Format(template, tag, string.Format(content, "${My." + paramGet + "}"));
string elemInstMarkup = "<{0}><{1}>{2}</{1}></{0}>";
string tagInstanceMarkup = string.Format(elemInstMarkup, new string[] { tag, param, "${" + mainPersonDataKey + "}" });
string expected = string.Format(content, name);
factory.RegisterCustomTag(tag, template);
DataContext dc = factory.MyRootMaster.MyDataContext;
OsViewerRequest viewerReq = new OsViewerRequest();
viewerReq.Key = mainPersonDataKey;
dc.RegisterDataItem(viewerReq);
ResolveDataControlValues(dc, viewer, viewer, null);
CustomTag inst = factory.CreateTagInstance(tag, tagInstanceMarkup);
// Assert.AreEqual(name, inst.Parameters[param], "Registered instance value incorrect");
string result = ControlTestHelper.GetRenderedContents(inst);
result = ControlTestHelper.NormalizeRenderResult(result);
Assert.AreEqual(expected, result, "Rendered results incorrect");
}
public void StaticGadgetRender()
{
TestableMarkupDef data = new StaticGadgetApp();
GadgetMaster target = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, data.Source);
target.RenderingOptions.DivWrapContentBlocks = false;
target.RenderingOptions.SuppressWhitespace = true;
target.ClientRenderCustomTemplates = false;
string result = target.RenderToString("canvas");
result = ControlTestHelper.NormalizeRenderResult(result);
Assert.IsFalse(string.IsNullOrEmpty(result), "empty result");
Assert.AreEqual(data.ExpectedCanvas, result, "Rendered Canvas results are incorrect");
result = target.RenderToString("profile");
result = ControlTestHelper.NormalizeRenderResult(result);
Assert.IsFalse(string.IsNullOrEmpty(result), "empty result");
Assert.AreEqual(data.ExpectedProfile, result, "Rendered Profile results are incorrect");
}
public void RenderWithExternalTemplates()
{
GadgetReferencingTemplateLibrary testData = new GadgetReferencingTemplateLibrary();
GadgetMaster master = GadgetMaster.CreateGadget(TEST_FACTORY_KEY, testData.Source); //new GadgetMaster(ControlFactory.GetControlFactory(TEST_FACTORY_KEY));
BasicLibrary testLib = new BasicLibrary();
TemplatesRoot library = master.LoadTemplateLibrary(testData.ExpectedTemplateLibraryUri, BasicLibrary.Source);
master.RenderingOptions.ClientRenderCustomTemplates = false;
master.RenderingOptions.ClientRenderDataContext = false;
master.RenderingOptions.DivWrapContentBlocks = false;
master.RenderingOptions.SuppressWhitespace = true;
master.ReParse();
ResolveDataControlValues(master.MyDataContext, testData.ExpectedViewer, testData.ExpectedViewer, testData.ExpectedFriends);
string result = ControlTestHelper.NormalizeRenderResult(master.RenderToString("canvas"));
result = result.Replace(" ", " ");
string expected = ControlTestHelper.NormalizeRenderResult(testData.ExpectedCanvas);
Assert.AreEqual(expected, result, "Rendered results don't match expected");
}
