def test_text_input(register_builtin_html):
with html.plugged():
html.text_input('tralala')
written_text = "".join(html.drain())
assert compare_html(
written_text,
'<input style="" name="tralala" type="text" class="text" value=\'\' />'
)
with html.plugged():
html.text_input('blabla', cssclass='blubb')
written_text = "".join(html.drain())
assert compare_html(
written_text,
'<input style="" name="tralala" type="text" class="blubb" value=\'\' />'
)
with html.plugged():
html.text_input('blabla', autocomplete='yep')
written_text = "".join(html.drain())
assert compare_html(
written_text,
'<input style="" name="blabla" autocomplete="yep" type="text" class="text" value=\'\' />'
)
with html.plugged():
html.text_input('blabla',
placeholder='placido',
data_world='welt',
data_max_labels=42)
written_text = "".join(html.drain())
assert compare_html(
written_text,
'<input style="" name="tralala" type="text" class="text" value=\'\' />'
)
def test_render_a(register_builtin_html):
a = html.render_a("bla", href="blu", class_=["eee"], target="_blank")
assert compare_html(a, '<a href="blu" target="_blank" class="eee">bla</a>')
a = html.render_a("b<script>alert(1)</script>la",
href="b<script>alert(1)</script>lu",
class_=["eee"],
target="_blank")
assert compare_html(
a,
'<a href="b<script>alert(1)</script>lu" target="_blank" '
'class="eee">b<script>alert(1)</script>la</a>')
def test_nesting_context():
import table
html = TableTester()
__builtin__.html = html
id = 0
title = " TEST "
with table.open(table_id=id, title=title, searchable=False,
sortable=False):
table.row()
table.cell("A", "1")
table.cell("B", "")
with table.open(id + 1, title + "2", searchable=False, sortable=False):
table.row()
table.cell("_", "+")
table.cell("|", "-")
text = html.written_text
assert compare_html(
text, '''<h3> TEST </h3>
<table class="data oddeven">
<tr> <th> A </th> <th> B </th> </tr>
<tr class="data odd0"> <td> 1 </td> <td>
<h3> TEST 2</h3>
<table class="data oddeven">
<tr><th>_</th><th>|</th></tr>
<tr class="data odd0"><td>+</td><td>-</td></tr>
</table> </td>
</tr>
</table>'''), text
def test_multiclass_call():
html = HTMLGenerator()
html.plug()
with html.plugged():
html.div('', class_="1", css="3", cssclass = "4", **{"class": "2"})
assert tools.compare_html(html.drain(), "<div class=\"1 3 4 2\"></div>")
def test_nesting_context(register_builtin_html):
table_id = 0
title = " TEST "
with html.plugged():
with table_element(table_id="%d" % table_id,
title=title,
searchable=False,
sortable=False) as table1:
table1.row()
table1.cell("A", "1")
table1.cell("B", "")
with table_element("%d" % (table_id + 1),
title + "2",
searchable=False,
sortable=False) as table2:
table2.row()
table2.cell("_", "+")
table2.cell("|", "-")
written_text = "".join(html.drain())
assert compare_html(
written_text, '''<h3 class="table"> TEST </h3>
<script type="text/javascript">\ncmk.utils.update_row_info(\'1 row\');\n</script>
<table class="data oddeven">
<tr> <th> A </th> <th> B </th> </tr>
<tr class="data even0"> <td> 1 </td> <td>
<h3 class="table"> TEST 2</h3>
<script type="text/javascript">\ncmk.utils.update_row_info(\'1 row\');\n</script>
<table class="data oddeven">
<tr><th>_</th><th>|</th></tr>
<tr class="data even0"><td>+</td><td>-</td></tr>
</table> </td>
</tr>
</table>'''), written_text
def test_add_manual_link_anchor(module_wide_request_context, monkeypatch):
monkeypatch.setattr(config.user, "language", lambda: "de")
assert compare_html(
html.render_help(u"[cms_graphing#rrds|RRDs]"),
HTML(
u"<div style=\"display:none\" class=\"help\"><a href=\"https://checkmk.de/cms_graphing.html#rrds\" target=\"_blank\">RRDs</a></div>"
))
def test_add_manual_link(register_builtin_html):
assert config.user.language is None
assert compare_html(
html.render_help(u"[cms_introduction_docker|docker]"),
HTML(
u"<div style=\"display:none\" class=\"help\"><a href=\"https://checkmk.com/cms_introduction_docker.html\" target=\"_blank\">docker</a></div>"
))
def test_add_manual_link_localized(module_wide_request_context, monkeypatch):
monkeypatch.setattr(config.user, "language", lambda: "de")
assert compare_html(
html.render_help(u"[cms_introduction_docker|docker]"),
HTML(
u"<div style=\"display:none\" class=\"help\"><a href=\"https://checkmk.de/cms_introduction_docker.html\" target=\"_blank\">docker</a></div>"
))
def test_render_help_html(register_builtin_html):
assert html.have_help is False
assert compare_html(
html.render_help(HTML("<abc>")),
HTML("<div style=\"display:none\" class=\"help\"><abc></div>"))
# NOTE: This seems to be a mypy 0.780 bug.
assert html.have_help is True # type: ignore[comparison-overlap]
def test_nesting():
from table import Table
html = TableTester()
__builtin__.html = html
id = 0
title = " TEST "
table = Table(id, title, searchable=False, sortable=False)
table.row()
table.cell("A", "1")
table.cell("B", "")
t2 = Table(id + 1, title + "2", searchable=False, sortable=False)
t2.row()
t2.cell("_", "+")
t2.cell("|", "-")
t2.end()
table.end()
text = html.written_text
assert compare_html(
text, '''<h3> TEST </h3>
<table class="data oddeven">
<tr> <th> A </th> <th> B </th> </tr>
<tr class="data odd0"> <td> 1 </td> <td>
<h3> TEST 2</h3>
<table class="data oddeven">
<tr><th>_</th><th>|</th></tr>
<tr class="data odd0"><td>+</td><td>-</td></tr>
</table> </td>
</tr>
</table>'''), text
def test_ABCHTMLGenerator(register_builtin_html):
with html.plugged():
with html.plugged():
html.open_div()
text = html.drain()
assert text.rstrip('\n').rstrip(' ') == "<div>"
with html.plugged():
#html.open_div().write("test").close_div()
html.open_div()
html.write("test")
html.close_div()
assert compare_html(html.drain(), "<div>test</div>")
with html.plugged():
#html.open_table().open_tr().td("1").td("2").close_tr().close_table()
html.open_table()
html.open_tr()
html.td("1")
html.td("2")
html.close_tr()
html.close_table()
assert compare_html(
html.drain(), "<table><tr><td>1</td><td>2</td></tr></table>")
with html.plugged():
html.div("test", **{"</div>malicious_code<div>": "trends"})
assert compare_html(
html.drain(),
"<div </div>malicious_code<div>=trends>test</div>")
a = u"\u2665"
with html.plugged():
assert html.render_a("test", href="www.test.case")
html.render_a(u"test", href="www.test.case")
html.render_a("test", href=u"www.test.case")
html.render_a(u"test", href=u"www.test.case")
try:
assert html.render_a(u"test",
href=six.text_type("www.test.case"),
id_=six.text_type("something"),
class_=six.text_type("test_%s") % a)
except Exception as e:
traceback.print_exc()
print(e)
def test_render_help_visible(module_wide_request_context,
register_builtin_html, monkeypatch):
monkeypatch.setattr(config.LoggedInUser, "show_help",
property(lambda s: True))
assert config.user.show_help is True
assert compare_html(
html.render_help(u"äbc"),
HTML(u"<div style=\"display:block\" class=\"help\">äbc</div>"))
def run(self, html=None):
global eval_func, set_html_state
construct_html = (html is None)
if construct_html:
html = Refactored_htmlTester()
add_html_vars(html, self.add_vars)
set_html_state(html, self.state_in)
return_value, html_code = eval_func(html, self.function_name, self.arguments)
try:
assert tools.compare_html(self.return_value, return_value)
except Exception, e:
print tools.bcolors.WARNING + "Test failed: the return value differs!\n%s" % self
print tools.bcolors.WARNING + "EXPECTED: \n%s" % self.return_value
print tools.bcolors.WARNING + "RETURNED: \n%s" % return_value
raise e
def test_multiclass_call(register_builtin_html):
with html.plugged():
html.div('', class_="1", css="3", cssclass="4", **{"class": "2"})
written_text = "".join(html.drain())
assert compare_html(written_text, "<div class=\"1 3 4 2\"></div>")
def test_render_help_visible(register_builtin_html):
assert html.help_visible is False
html.help_visible = True
assert compare_html(html.render_help(u"äbc"),
HTML(u"<div style=\"display:block\" class=\"help\">äbc</div>"))
def test_render_help_text(register_builtin_html):
assert compare_html(html.render_help(u"äbc"),
HTML(u"<div style=\"display:none\" class=\"help\">äbc</div>"))
def test_render_help_html(register_builtin_html):
assert html.have_help is False
assert compare_html(html.render_help(HTML("<abc>")),
HTML("<div style=\"display:none\" class=\"help\"><abc></div>"))
assert html.have_help is True
def test_exception_handling():
html = HTMLGenerator()
try:
raise Exception("Test")
except Exception, e:
assert tools.compare_html(html.render_div(e), "<div>%s</div>" % e)
def test_check_mk():
old = HTMLOrigTester()
new = HTMLCheck_MKTester()
old.plug()
new.plug()
# form elements
# gentest(old, new, lambda x: x.begin_form("Test", method="GET"))
# gentest(old, new, lambda x: x.begin_form("Test", method="POST"))
# gentest(old, new, lambda x: x.begin_form("Test", action="TestAction", onsubmit="Do Something"))
# gentest(old, new, lambda x: x.begin_form("Test", add_transid=False))
assert compare_html(\
old.render_icon("TestIcon", help="Icon Title", middle=True, id="TestID", cssclass="test"),\
new.render_icon("TestIcon", help="Icon Title", middle=True, id="TestID", cssclass="test"))
assert compare_html(\
old.render_icon_button("www.test.de", "Test Title", "TestIcon", id="TestID",
onclick="Do domething", style="Test Style", target="Test Target",
cssclass="test", ty="button"),\
new.render_icon_button("www.test.de", "Test Title", "TestIcon", id="TestID",
onclick="Do domething", style="Test Style", target="Test Target",
cssclass="test", ty="button"))
gentest(old, new, lambda x: x.icon("Test Title", "TestIcon"))
gentest(old, new, lambda x: x.empty_icon())
gentest(old, new, lambda x: x.icon_button("www.test.de", "Test Title", "TestIcon", id="TestID",
onclick="Do domething", style="Test Style", target="Test Target",
cssclass="test", ty="button"))
# headers
gentest(old, new, lambda x: x.default_html_headers())
gentest(old, new, lambda x: x.top_heading("Test"))
gentest(old, new, lambda x: x.top_heading_left("Test"))
gentest(old, new, lambda x: x.top_heading_right())
javascripts = ['alert(\"Hallo Welt!\");']
stylesheets = ['pages', 'teststylesheet']
gentest(old, new, attributes=['header_sent'], fun = lambda x:
x.html_head("Test", javascripts=javascripts,
stylesheets=stylesheets, force=False))
gentest(old, new, attributes=['header_sent'], fun = lambda x:
x.html_head("Test", javascripts=javascripts,
stylesheets=stylesheets, force=True))
gentest(old, new, attributes=['header_sent'], fun = lambda x:
x.header("Test", javascripts=javascripts,
stylesheets=stylesheets, force=False))
gentest(old, new, attributes=['header_sent'], fun = lambda x:
x.header("Test", javascripts=javascripts,
stylesheets=stylesheets, force=True))
# body
gentest(old, new, attributes=['header_sent'], fun = lambda x:
x.body_start("Test", javascripts=javascripts,
stylesheets=stylesheets, force=False))
gentest(old, new, attributes=['header_sent'], fun = lambda x:
x.body_start("Test", javascripts=javascripts,
stylesheets=stylesheets, force=True))
gentest(old, new, lambda x: x.html_foot())
class HtmlTest(object):
# empty constructor
def __init__(self):
super(HtmlTest, self).__init__()
self.function_name = '' # the function to be called
self.arguments = {} # the arguments for the function call
self.state_in = {} # the state of the html object before the function call
self.add_vars = {} # the variables of the html object before the function call
self.expected_html = '' # the expected generated html
self.state_out = {} # the state of the html object after the function call
self.return_value = None # the return value of the function call
def __str__(self):
return pprint.pformat(self.to_dict())
# this is the standard constructor. This was necessary in order to make a constructor call from_dict
def create(self, function_name, expected_html, arguments=None, state_in=None, add_vars=None, state_out=None, return_value=None):
self.function_name = function_name
self.arguments = copy.deepcopy(arguments) if arguments is not None else {}
self.state_in = copy.deepcopy(state_in) if state_in is not None else {}
self.add_vars = copy.deepcopy(add_vars) if add_vars is not None else {}
self.expected_html = expected_html
self.state_out = copy.deepcopy(state_out) if state_out is not None else {}
self.return_value = return_value
return self
# convert to dictionary
def to_dict(self):
# required attributes
d = { "function_name": self.function_name, \
"input" : { "arguments" : self.arguments, }, \
"output" : { "html_code" : self.expected_html } }
# optional attributes
if self.state_in:
d["input"]["attributes"] = self.state_in
if self.add_vars:
d["input"]["variables"] = self.add_vars
if self.state_out:
d["output"]["attributes"] = self.state_out
if self.return_value is not None:
d["output"]["return_value"] = self.return_value
return d
# parse a dictionary
def from_dict(self, test):
# required attributes
self.function_name = test["function_name"]
self.arguments = test["input"]["arguments"]
self.expected_html = test["output"]["html_code"]
# optional attributes
self.state_in = test["input"].get("attributes", {})
self.add_vars = test["input"].get("variables", {})
self.state_out = test["output"].get("attributes", {})
self.return_value = test["output"].get("return_value", None)
return self
# validate that the test is meaningfull
# TODO: DEPRECATED
def validate(self):
return True
def run(self, html=None):
global eval_func, set_html_state
construct_html = (html is None)
if construct_html:
html = Refactored_htmlTester()
add_html_vars(html, self.add_vars)
set_html_state(html, self.state_in)
return_value, html_code = eval_func(html, self.function_name, self.arguments)
try:
assert tools.compare_html(self.return_value, return_value)
except Exception, e:
print tools.bcolors.WARNING + "Test failed: the return value differs!\n%s" % self
print tools.bcolors.WARNING + "EXPECTED: \n%s" % self.return_value
print tools.bcolors.WARNING + "RETURNED: \n%s" % return_value
raise e
try:
assert tools.compare_html(self.expected_html, html_code)
except Exception, e:
print tools.bcolors.WARNING + "Test failed: generated html code differs!\n%s" % self
print tools.bcolors.WARNING + "EXPECTED: \n%s" % self.expected_html
print tools.bcolors.WARNING + "GENERATED: \n%s" % html_code
raise e
def test_exception_handling(register_builtin_html):
try:
raise Exception("Test")
except Exception as e:
assert compare_html(html.render_div(str(e)), "<div>%s</div>" % e)
def test_check_mk():
old = HTMLOrigTester()
new = HTMLCheck_MKTester()
old.plug()
new.plug()
# form elements
# gentest(old, new, lambda x: x.begin_form("Test", method="GET"))
# gentest(old, new, lambda x: x.begin_form("Test", method="POST"))
# gentest(old, new, lambda x: x.begin_form("Test", action="TestAction", onsubmit="Do Something"))
# gentest(old, new, lambda x: x.begin_form("Test", add_transid=False))
assert compare_html(\
old.render_icon("TestIcon", help="Icon Title", middle=True, id="TestID", cssclass="test"),\
new.render_icon("TestIcon", help="Icon Title", middle=True, id="TestID", cssclass="test"))
assert compare_html(\
old.render_icon_button("www.test.de", "Test Title", "TestIcon", id="TestID",
onclick="Do domething", style="Test Style", target="Test Target",
cssclass="test", ty="button"),\
new.render_icon_button("www.test.de", "Test Title", "TestIcon", id="TestID",
onclick="Do domething", style="Test Style", target="Test Target",
cssclass="test", ty="button"))
gentest(old, new, lambda x: x.icon("Test Title", "TestIcon"))
gentest(old, new, lambda x: x.empty_icon())
gentest(
old, new, lambda x: x.icon_button("www.test.de",
"Test Title",
"TestIcon",
id="TestID",
onclick="Do domething",
style="Test Style",
target="Test Target",
cssclass="test",
ty="button"))
# headers
gentest(old, new, lambda x: x.default_html_headers())
gentest(old, new, lambda x: x.top_heading("Test"))
gentest(old, new, lambda x: x.top_heading_left("Test"))
gentest(old, new, lambda x: x.top_heading_right())
javascripts = ['alert(\"Hallo Welt!\");']
stylesheets = ['pages', 'teststylesheet']
gentest(old,
new,
attributes=['header_sent'],
fun=lambda x: x.html_head("Test",
javascripts=javascripts,
stylesheets=stylesheets,
force=False))
gentest(old,
new,
attributes=['header_sent'],
fun=lambda x: x.html_head("Test",
javascripts=javascripts,
stylesheets=stylesheets,
force=True))
gentest(old,
new,
attributes=['header_sent'],
fun=lambda x: x.header("Test",
javascripts=javascripts,
stylesheets=stylesheets,
force=False))
gentest(old,
new,
attributes=['header_sent'],
fun=lambda x: x.header("Test",
javascripts=javascripts,
stylesheets=stylesheets,
force=True))
# body
gentest(old,
new,
attributes=['header_sent'],
fun=lambda x: x.body_start("Test",
javascripts=javascripts,
stylesheets=stylesheets,
force=False))
gentest(old,
new,
attributes=['header_sent'],
fun=lambda x: x.body_start("Test",
javascripts=javascripts,
stylesheets=stylesheets,
force=True))
gentest(old, new, lambda x: x.html_foot())
