public void TestSetCssPropertyElement()
{
HElement element = null;
Assert.Equal(null, element.Css("color", "blue").Attr("style"));
Assert.Equal(
"color=blue;font-size=12px;font-name=Arial",
new HElement("div")
.Css("color", "blue")
.Css("fontSize", "12px")
.Css("font-name", "Arial")
.Attr("style")
);
Assert.Equal(
"color=blue;font-size=24px",
new HElement("div")
.Css("color", "blue")
.Css("fontSize", "12px")
.Css("font-name", "Arial")
.Css("font-Size", "24px")
.Css("font-name", "")
.Attr("style")
);
}
public void TestSetCssPropertyElements()
{
var element1 = new HElement("div");
var element2 = new HElement("div").Attr("style", "color=blue;");
var element3 = new HElement("div").Attr("style", "font-size=12px;other=;empty;color=blue");
HElement[] elements = null;
Assert.Equal(
null,
elements
.Css("font-name", "Arial")
.Css("font-Size", "24px")
.Css("font-name", "")
);
elements = new HElement[] { element1, element2, element3 };
Assert.Equal(
new String[] { "font-size=24px", "color=blue;font-size=24px", "font-size=24px;color=blue" },
elements
.Css("font-name", "Arial")
.Css("font-Size", "24px")
.Css("font-name", "")
.Select(e => e.Attr("style"))
.ToArray());
}
public void TestGetCssElements()
{
var element1 = new HElement("div");
var element2 = new HElement("div").Attr("style", "font-size=12px;color=blue;");
var element3 = new HElement("div").Attr("style", "font-size=12px;other=;empty;color=blue");
HElement[] elements = null;
var style = elements.Css();
Assert.Equal(0, style.Count);
elements = new HElement[] { element1, element2, element3 };
style = elements.Css();
Assert.Equal(0, style.Count);
elements = new HElement[] { element2, element1, element3 };
style = elements.Css();
Assert.Equal(2, style.Count);
Assert.Equal("12px", style["font-size"]);
Assert.Equal("blue", style["color"]);
elements = new HElement[] { element3, element2, element1 };
style = elements.Css();
Assert.Equal(4, style.Count);
Assert.Equal("12px", style["font-size"]);
Assert.Equal("blue", style["color"]);
Assert.Equal("", style["other"]);
Assert.Equal("", style["empty"]);
}
private static string Diff(HElement h1, HElement h2)
{
var results = HtmlJavaScriptDiffer.JsSync(new HElementProvider(), h1, h2, Array <object> .Empty).ToArray();
var s = JsonConvert.SerializeObject(results);
return(s.Replace('"', '\''));
}
private static void GetPlainText(StringBuilder builder, IEnumerable <HNode> nodes)
{
foreach (HNode node in nodes)
{
HElement element = node as HElement;
if (element != null)
{
if (element.Name != "script" && element.Name != "style")
{
GetPlainText(builder, element.Nodes());
}
}
else
{
HText text = node as HText;
if (text != null)
{
builder.Append(text + "\r\n");
}
else
{
HEntity entity = node as HEntity;
if (entity != null)
{
builder.Append(entity.Value + "\r\n");
}
}
}
}
}
public void TestSlice()
{
var n1 = new HElement("div", "Content 1");
var n2 = new HElement("div", "Content 2");
var n3 = new HElement("div", "Content 3");
var n4 = new HElement("div", "Content 4");
var n5 = new HElement("div", "Content 5");
var root = new HElement("div", n1, n2, n3, n4, n5);
IEnumerable <HElement> elements = root.Elements().ToArray();
Assert.Equal(new HElement[] { n1, n2, n3, n4, n5 }, elements.Slice(0).ToArray());
Assert.Equal(new HElement[] { n3, n4, n5 }, elements.Slice(2).ToArray());
Assert.Equal(new HElement[] { n4, n5 }, elements.Slice(-2).ToArray());
Assert.Equal(new HElement[] { n1, n2, n3, n4, n5 }, elements.Slice(0, 4).ToArray());
Assert.Equal(new HElement[] { n3, n4 }, elements.Slice(2, 3).ToArray());
Assert.Equal(new HElement[] { n3 }, elements.Slice(2, 2).ToArray());
Assert.Equal(new HElement[] { n4, n5 }, elements.Slice(-2, 4).ToArray());
Assert.Equal(new HElement[] { n4, n5 }, elements.Slice(-2, -1).ToArray());
Assert.Equal(new HElement[] { }, elements.Slice(-2, 2).ToArray());
elements = null;
Assert.Equal(0, elements.Slice(0).Count());
Assert.Equal(0, elements.Slice(0, 4).Count());
}
public void TestAdd()
{
HContainer container = new HElement("div");
// Nothing appening
container.Add(null);
Assert.Equal(0, container.Nodes().Count());
container.Add(123.45);
String s = (123.45).ToString();
Assert.Equal(1, container.Nodes().Count());
Assert.Equal("<div>" + s + "</div>", container.ToString());
container.Add(null);
Assert.Equal(1, container.Nodes().Count());
Assert.Equal("<div>" + s + "</div>", container.ToString());
container.Add("Other Content");
Assert.Equal(1, container.Nodes().Count());
Assert.Equal("<div>" + s + "Other Content</div>", container.ToString());
container.Add(new HElement("span", "SPAN"));
Assert.Equal(2, container.Nodes().Count());
Assert.Equal("<div>" + s + "Other Content<span>SPAN</span></div>", container.ToString());
}
public void TestAddParentAsNode()
{
HContainer parent = new HElement("parent");
HElement child1 = new HElement("child1");
parent.Add(child1);
HElement child2 = new HElement("child2");
child1.Add(child2);
child2.Add(parent);
Assert.IsType <HElement>(child2.FirstNode);
HElement node = (HElement)child2.FirstNode;
Assert.Equal("parent", node.Name);
Assert.NotSame(parent, node);
node = (HElement)node.FirstNode;
Assert.Equal("child1", node.Name);
Assert.NotSame(child1, node);
node = (HElement)node.FirstNode;
Assert.Equal("child2", node.Name);
Assert.NotSame(child2, node);
Assert.Null(node.FirstNode);
}
public void TestAttrPoco()
{
var elements = new HElement[] {
new HElement("div", new HAttribute("class", "one")),
new HElement("div"),
new HElement("div", new HAttribute("style", "font-size:red"))
};
elements.Attr(new { style = "", @class = "two" });
Assert.Null(elements[0].Attribute("style"));
Assert.Null(elements[1].Attribute("style"));
Assert.Null(elements[2].Attribute("style"));
Assert.Equal("two", elements.Attr("class"));
// Create the attribute
elements.Attr(new { style = "font-size:red", data_value = "data" });
Assert.Equal("font-size:red", elements[0].Attr("style"));
Assert.Equal("font-size:red", elements[1].Attr("style"));
Assert.Equal("font-size:red", elements[2].Attr("style"));
Assert.Equal("data", elements.Attr("data-value"));
elements.Attr(new TestPoco()
{
data_int = 123, data_str = "str"
});
Assert.Equal("123", elements.Attr("data-int"));
Assert.Equal("str", elements.Attr("data-str"));
}
public void TestPrependElementsByCallback()
{
var element1 = new HElement("div", new HElement("p"));
var element2 = new HElement("div", new HElement("p"), new HElement("div"), new HAttribute("attr1", "val1"));
var elements = new HElement[] { element1, null, element2 };
Assert.Same(elements, elements.Prepend((e, i) => {
return(new object[] {
new HAttribute("a" + i.ToString(), i.ToString()),
"Content"
});
}));
Assert.Equal(2, element1.Nodes().Count());
Assert.Equal("0", element1.Attr("a0"));
Assert.Equal(3, element2.Nodes().Count());
Assert.Equal("2", element2.Attr("a2"));
elements = null;
Assert.Null(elements.Prepend((e, i) => {
return(new object[] {
new HAttribute("a" + i.ToString(), i.ToString()),
"Content"
});
}));
}
public static void SendRegistrationConfirmation(int userId, string login, string email)
{
string url = string.Format("http://basketball.ru.com/confirmation?id={0}&hash={1}",
userId, UserHlp.CalcConfirmationCode(userId, login, "bbbin")
);
HElement answer = h.Div(
h.P("Вы указали этот адрес при регистрации на basketball.ru.com"),
h.P("Чтобы завершить регистрацию, пожалуйста, перейдите по ссылке:"),
h.A(
h.href(url),
new HAttribute("target", "_blank"),
url
),
h.P("Если вы не регистрировались на сайте, значит, произошла ошибка - просто проигнорируйте это письмо")
);
SiteSettings settings = SiteContext.Default.SiteSettings;
SmtpClient smtpClient = AuthHlp.CreateSmtpClient(
settings.SmtpHost, settings.SmtpPort, settings.SmtpUserName, settings.SmtpPassword);
AuthHlp.SendMail(smtpClient, settings.MailFrom, email,
"Подтвердите регистрацию на basketball.ru.com", answer.ToHtmlText()
);
Logger.AddMessage("Подтверждение регистрации: {0}", email);
}
public void TestRemoveAll()
{
HNode node1 = new HText("node 1");
HNode node2 = new HElement("node2", "value2");
HNode node3 = new HText("node 3");
HNode node4 = new HElement("node4", "value4");
var attr1 = new HAttribute("attr1", "value1");
var attr2 = new HAttribute("attr2", "value2");
var attr3 = new HAttribute("attr3", "value3");
var attr4 = new HAttribute("attr4", "value4");
// Create parent
var elm = new HElement("test", attr1, node1, attr2, node2, node3, node4, attr3, attr4);
Assert.Equal(4, elm.Attributes().Count());
Assert.Equal(4, elm.Nodes().Count());
// Remove all
elm.RemoveAll();
Assert.Equal(0, elm.Attributes().Count());
Assert.Equal(0, elm.Nodes().Count());
// Check no exception
elm.RemoveAll();
Assert.Equal(0, elm.Attributes().Count());
Assert.Equal(0, elm.Nodes().Count());
}
public void TestAddAfter()
{
HElement parent = new HElement("parent");
HNode n1 = new HElement("test-1");
parent.Add(n1);
Assert.Equal(1, parent.Nodes().Count());
HNode n2 = new HElement("test-2");
n1.AddAfter(n2);
Assert.Equal(2, parent.Nodes().Count());
n1.AddAfter("1");
Assert.Equal(3, parent.Nodes().Count());
n2.AddAfter("2");
Assert.Equal(4, parent.Nodes().Count());
var nodes = parent.Nodes().ToArray();
Assert.Equal(4, nodes.Length);
Assert.IsType <HElement>(nodes[0]);
Assert.IsType <HText>(nodes[1]);
Assert.IsType <HElement>(nodes[2]);
Assert.IsType <HText>(nodes[3]);
n1 = new HElement("test-3");
var ioe = Assert.Throws <InvalidOperationException>(() => n1.AddAfter(null));
Assert.Equal("No parent found.", ioe.Message);
}
public void TestSetDataValuesElements()
{
HElement element1 = new HElement("div", new HAttribute("data-value1", "value1"));
HElement element2 = new HElement("div", new HAttribute("data-value3", "value3"));
var elements = new HElement[] { element1, null, element2 };
elements.Data(new {
Value1 = "NewValue1",
Value2 = "NewValue2"
});
Assert.Equal("NewValue1", element1.Data("Value1"));
Assert.Equal("NewValue2", element1.Data("Value2"));
Assert.Equal(null, element1.Data("Value3"));
Assert.Equal("NewValue1", element2.Data("Value1"));
Assert.Equal("NewValue2", element2.Data("Value2"));
Assert.Equal("value3", element2.Data("Value3"));
elements = null;
elements.Data(new {
Value1 = "NewValue1",
Value2 = "NewValue2"
});
}
public void TestRemoveDataElements()
{
HElement element1 = new HElement("div",
new HAttribute("data-value1", "value1"),
new HAttribute("data-value2", "value2"),
new HAttribute("data-value3", "value3")
);
HElement element2 = new HElement("div",
new HAttribute("data-value2", "value2"),
new HAttribute("data-value3", "value3"),
new HAttribute("data-value4", "value4")
);
var elements = new HElement[] { element1, null, element2 };
elements.RemoveData("value1", "value4");
Assert.Equal(new String[] { "data-value2", "data-value3", "data-value2", "data-value3" }, elements.Where(e => e != null).SelectMany(e => e.Attributes()).Select(a => a.Name).ToArray());
elements.RemoveData();
Assert.Equal(new String[] { }, elements.Where(e => e != null).SelectMany(e => e.Attributes()).Select(a => a.Name).ToArray());
elements = null;
elements.RemoveData();
}
public void TestAttrElements()
{
var elements = new HElement[] {
new HElement("div", new HAttribute("class", "one")),
new HElement("div"),
new HElement("div", new HAttribute("style", "font-size:red"))
};
Assert.Equal("one", elements.Attr("class"));
Assert.Equal(null, elements.Attr("style"));
Assert.Equal(null, elements.Attr("id"));
// Remove all style attributes
elements.Attr("style", "");
Assert.Null(elements[0].Attribute("style"));
Assert.Null(elements[1].Attribute("style"));
Assert.Null(elements[2].Attribute("style"));
// Create the attribute
elements.Attr("style", "font-size:red");
Assert.Equal("font-size:red", elements[0].Attr("style"));
Assert.Equal("font-size:red", elements[1].Attr("style"));
Assert.Equal("font-size:red", elements[2].Attr("style"));
elements = null;
Assert.Equal(null, elements.Attr("id"));
}
public void TestClone()
{
var parent = new HElement("parent");
var elm = new HElement("test", "content");
elm.Add(
new HAttribute("attr1", "val1"),
new HAttribute("attr3", "val3")
);
Assert.Equal(1, elm.Nodes().Count());
parent.Add(elm);
var newElm = new HElement("test", elm);
var c = newElm.Elements().First();
Assert.Equal(2, c.Attributes().Count());
Assert.Equal(0, c.Attributes("Attr2").Count());
Assert.Equal(1, c.Nodes().Count());
var cloneElm = c.Clone();
Assert.Equal(2, cloneElm.Attributes().Count());
Assert.Equal(0, cloneElm.Attributes("Attr2").Count());
Assert.Equal(1, cloneElm.Nodes().Count());
}
public void TestGetCssElement()
{
HElement element = null;
var style = element.Css();
Assert.Equal(0, style.Count);
element = new HElement("div");
style = element.Css();
Assert.Equal(0, style.Count);
element.Attr("id", "test").Attr("style", "");
style = element.Css();
Assert.Equal(0, style.Count);
element.Attr("style", "font-size=12px;color=blue;");
style = element.Css();
Assert.Equal(2, style.Count);
Assert.Equal("12px", style["font-size"]);
Assert.Equal("blue", style["color"]);
element.Attr("style", "font-size=12px;other=;empty;color=blue");
style = element.Css();
Assert.Equal(4, style.Count);
Assert.Equal("12px", style["font-size"]);
Assert.Equal("blue", style["color"]);
Assert.Equal("", style["other"]);
Assert.Equal("", style["empty"]);
}
/// <inheritdoc />
public HttpResponse GetResponse(HttpRequest requestPacket, System.Diagnostics.Stopwatch currentStopwatch)
{
SessionData sessionData = new HttpSessionData(requestPacket);
WalkableQueue <Tuple <ID, string> > unpackedUrls = UnpackUrlActions(requestPacket);
HElement e = _debugNode.GetContents(sessionData, unpackedUrls.Peek()?.Item2, unpackedUrls);
PageBuilder pb = new PageBuilder("LamestWebserver Debug View")
{
StylesheetCode = StyleSheet,
Elements =
{
new HContainer
{
Elements ={ e },
Class = "main"
},
new HContainer
{
Elements =
{
new HText($"LamestWebserver DebugView v{typeof(DebugResponse).Assembly.GetName().Version}")
},
Class = "footer"
}
}
};
return(new HttpResponse(requestPacket, pb.GetContent(sessionData))
{
Cookies = ((HttpSessionData)(sessionData)).Cookies.ToList()
});
}
public void TestSetHtmlElement()
{
var element = new HElement("div", new HElement("span", "Content"));
Assert.Same(element, element.Html("<strong>New Content</strong>"));
Assert.Equal("<strong>New Content</strong>", element.Html());
}
public static IEnumerable<HElement> RoundPage(HElement page)
{
yield return page;
foreach (HElement node in page.Elements())
{
foreach (HElement element in RoundPage(node))
yield return element;
}
}
public void TestCantAddDocumentTypeInElement()
{
var elm = new HElement("test");
var dt = new HDocumentType();
var ex = Assert.Throws <ArgumentException>(() => elm.Add(dt));
Assert.Equal("Can't add a document type in a element.", ex.Message);
}
public void TestHasAttributes()
{
var elm = new HElement("test");
Assert.False(elm.HasAttributes);
elm.Add(new HAttribute("attr1", "val1"));
Assert.True(elm.HasAttributes);
}
public void TestRemoveAttributes()
{
var attr1 = new HAttribute("attr1", "value1");
var attr2 = new HAttribute("attr2", "value2");
var attr3 = new HAttribute("attr3", "value3");
var attr4 = new HAttribute("attr4", "value4");
// Create parent
var elm = new HElement("test", attr1, attr2, attr3, attr4);
Assert.Same(attr1, elm.FirstAttribute);
Assert.Same(attr4, elm.LastAttribute);
Assert.Same(elm, attr1.Parent);
Assert.Null(attr1.PreviousAttribute);
Assert.Same(attr2, attr1.NextAttribute);
Assert.Same(elm, attr2.Parent);
Assert.Same(attr1, attr2.PreviousAttribute);
Assert.Same(attr3, attr2.NextAttribute);
Assert.Same(elm, attr3.Parent);
Assert.Same(attr2, attr3.PreviousAttribute);
Assert.Same(attr4, attr3.NextAttribute);
Assert.Same(elm, attr4.Parent);
Assert.Same(attr3, attr4.PreviousAttribute);
Assert.Null(attr4.NextAttribute);
// Remove all attributes
elm.RemoveAttributes();
Assert.Null(elm.FirstAttribute);
Assert.Null(elm.LastAttribute);
Assert.Null(attr1.Parent);
Assert.Null(attr1.PreviousAttribute);
Assert.Null(attr1.NextAttribute);
Assert.Null(attr2.Parent);
Assert.Null(attr2.PreviousAttribute);
Assert.Null(attr2.NextAttribute);
Assert.Null(attr3.Parent);
Assert.Null(attr3.PreviousAttribute);
Assert.Null(attr3.NextAttribute);
Assert.Null(attr4.Parent);
Assert.Null(attr4.PreviousAttribute);
Assert.Null(attr4.NextAttribute);
Assert.Equal(0, elm.Attributes().Count());
// Check no exception
elm.RemoveAttributes();
Assert.Equal(0, elm.Attributes().Count());
}
public static IEnumerable <HElement> CssSelect(this HDocument doc, string expression)
{
var hElement = new HElement
{
Children = doc.Children
};
return(hElement.CssSelect(expression));
}
public void TestGetHtmlElement()
{
var element = new HElement("div", new HElement("span", "Content"));
Assert.Equal("<span>Content</span>", element.Html());
element = null;
Assert.Equal("", element.Html());
}
public void TestContentsElement()
{
var element = new HElement("div", "Content Before", new HElement("p", "Content"), "Content After");
Assert.Equal(3, element.Contents().Count());
element = null;
Assert.Equal(0, element.Contents().Count());
}
public void TestSetCssPropertiesElements()
{
var element1 = new HElement("div");
var element2 = new HElement("div").Attr("style", "color=blue;");
var element3 = new HElement("div").Attr("style", "font-size=12px;other=;empty;color=blue");
HElement[] elements = null;
Assert.Equal(
null,
elements
.Css(new {
fontSize = "12px",
font_Name = "Arial"
})
);
elements = new HElement[] { element1, element2, element3 };
Assert.Equal(
new String[] { "font-size=12px;font-name=Arial", "color=blue;font-size=12px;font-name=Arial", "font-size=12px;color=blue;font-name=Arial" },
elements
.Css(new {
fontSize = "12px",
font_Name = "Arial"
})
.Select(e => e.Attr("style"))
.ToArray());
element1 = new HElement("div");
element2 = new HElement("div").Attr("style", "color=blue;");
element3 = new HElement("div").Attr("style", "font-size=12px;other=;empty;color=blue");
elements = new HElement[] { element1, element2, element3 };
Assert.Equal(
new String[] { "font-size=24px", "color=blue;font-size=24px", "font-size=24px;color=blue" },
elements
.Css(new Dictionary <String, String> {
{ "fontSize", "24px" },
{ "font_Name", "" }
})
.Select(e => e.Attr("style"))
.ToArray());
element1 = new HElement("div");
element2 = new HElement("div").Attr("style", "color=blue;");
element3 = new HElement("div").Attr("style", "font-size=12px;other=;empty;color=blue");
elements = new HElement[] { element1, element2, element3 };
Assert.Equal(
new String[] { "data-str=text;data-int=12", "color=blue;data-str=text;data-int=12", "font-size=12px;color=blue;data-str=text;data-int=12" },
elements
.Css(new TestPoco {
data_int = 12,
data_str = "text"
})
.Select(e => e.Attr("style"))
.ToArray());
}
public void TestBeforeElementsByCallback()
{
var element1 = new HElement("h1");
var element2 = new HElement("h2");
var container = new HElement("div", element1, element2).AddClass("container");
container.Elements().Before((e, i) => new HElement[] { new HElement(e.Name + "-" + i.ToString()) });
Assert.Equal(new String[] { "h1-0", "h1", "h2-1", "h2" }, container.Elements().Select(e => e.Name));
}
public void TestParent()
{
HObject obj = new HText("test");
Assert.Null(obj.Parent);
HElement p = new HElement("parent", obj);
Assert.Same(p, obj.Parent);
}
public void TestCreateWithContent()
{
String name = "test";
var elm = new HElement(name, null);
Assert.Equal(0, elm.Nodes().Count());
elm = new HElement(name, "a");
Assert.Equal(1, elm.Nodes().Count());
}
private static string Diff(HElement h1, HElement h2)
{
var results = HtmlJavaScriptDiffer.JsSync(new HElementProvider(), h1, h2, Array<object>.Empty).ToArray();
var s = JsonConvert.SerializeObject(results);
return s.Replace('"', '\'');
}
static UpdateCycle<HElement> PushUpdate(HElement page)
{
lock (locker)
{
var lastUpdate = Updates.LastOrDefault();
var cycle = (lastUpdate != null ? lastUpdate.Cycle : 0) + 1;
var update = new UpdateCycle<HElement>(null, cycle, page, null);
Updates = Updates.Skip(Math.Max(Updates.Length - 100, 0)).Concat(new[] { update }).ToArray();
return update;
}
}
public HElementControl(HElement element, string cssClassName) :
base("HElementControl", cssClassName)
{
this.element = element;
}
