def test_fontface_selectors_with_no_selectortext(self):
"""
@font-face selectors are weird.
This is a fix for https://github.com/peterbe/premailer/issues/71
"""
html = """<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
<style>
@font-face {
font-family: 'Garamond';
src:
local('Garamond'),
local('Garamond-Regular'),
url('Garamond.ttf')
format('truetype'); /* Safari, Android, iOS */
font-weight: normal;
font-style: normal;
}
</style>
</head>
<body></body>
</html>"""
p = Premailer(html, disable_validation=True)
p.transform() # it should just work
def test_fontface_selectors_with_no_selectortext(self):
"""
@font-face selectors are weird.
This is a fix for https://github.com/peterbe/premailer/issues/71
"""
html = """<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
<style>
@font-face {
font-family: 'Garamond';
src:
local('Garamond'),
local('Garamond-Regular'),
url('Garamond.ttf')
format('truetype'); /* Safari, Android, iOS */
font-weight: normal;
font-style: normal;
}
</style>
</head>
<body></body>
</html>"""
p = Premailer(html, disable_validation=True)
p.transform() # it should just work
def test_child_selector(self):
html = """<html>
<head>
<style type="text/css">
body > div {
text-align: right;
}
</style>
</head>
<body>
<div>First div</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First div</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_mixed_pseudo_selectors(self):
"""mixing pseudo selectors with straight
forward selectors"""
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
p { color: yellow }
a { color: blue }
a:hover { color: pink }
</style>
</head>
<body>
<p>
<a href="#">Page</a>
</p>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
<style type="text/css">a:hover {color:pink}</style>
</head>
<body>
<p style="color:yellow"><a href="#" style="color:blue">Page</a></p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_external_styles_with_base_url(self, urllib2):
"""Test loading styles that are genuinely external if you use
the base_url"""
html = """<html>
<head>
<link href="style.css" rel="stylesheet" type="text/css">
</head>
<body>
<h1>Hello</h1>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<h1 style="color:brown">Hello</h1>
</body>
</html>"""
def mocked_urlopen(url):
if url == "http://www.peterbe.com/style.css":
return MockResponse("h1 { color: brown }")
raise NotImplementedError(url)
urllib2.urlopen = mocked_urlopen
p = Premailer(html, base_url="http://www.peterbe.com/")
result_html = p.transform()
compare_html(expect_html, result_html)
def test_mailto_url():
"""if you use URL with mailto: protocol, they should stay as mailto:
when baseurl is used
"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
p = Premailer(html, base_url='http://kungfupeople.com')
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
assert expect_html == result_html
def test_mediaquery():
html = """<html>
<head>
<style type="text/css">
div {
text-align: right;
}
@media print{
div {
text-align: center;
}
}
</style>
</head>
<body>
<div>First div</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First div</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_doctype(self):
html = (
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
"""<html>
<head>
</head>
<body>
</body>
</html>"""
)
expect_html = (
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
"""<html>
<head>
</head>
<body>
</body>
</html>"""
)
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_empty_style_tag():
"""empty style tag"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title></title>
<style type="text/css"></style>
</head>
<body>
</body>
</html>"""
expect_html = """<html>
<head>
<title></title>
</head>
<body>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_basic_html_with_pseudo_selector(self):
"""test the simplest case"""
html = """
<html>
<style type="text/css">
h1 { border:1px solid black }
p { color:red;}
p::first-letter { float:left; }
</style>
<h1 style="font-weight:bolder">Peter</h1>
<p>Hej</p>
</html>
"""
expect_html = """<html>
<head>
<style type="text/css">p::first-letter {float:left}</style>
</head>
<body>
<h1 style="border:1px solid black; font-weight:bolder">Peter</h1>
<p style="color:red">Hej</p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_strip_important(self):
"""Get rid of !important. Makes no sense inline."""
html = """<html>
<head>
<style type="text/css">
p {
height:100% !important;
width:100% !important;
}
</style>
</head>
<body>
<p>Paragraph</p>
</body>
</html>
"""
expect_html = """<html>
<head>
</head>
<body>
<p style="height:100%; width:100%" width="100%" height="100%">Paragraph</p>
</body>
</html>"""
p = Premailer(html, strip_important=True)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_inline_wins_over_external(self):
html = """<html>
<head>
<style type="text/css">
div {
text-align: left;
}
/* This tests that a second loop for the same style still doesn't
* overwrite it. */
div {
text-align: left;
}
</style>
</head>
<body>
<div style="text-align:right">Some text</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">Some text</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_last_child_exclude_pseudo(self):
html = """<html>
<head>
<style type="text/css">
div {
text-align: right;
}
div:last-child {
text-align: left;
}
</style>
</head>
<body>
<div>First child</div>
<div>Last child</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First child</div>
<div style="text-align:left" align="left">Last child</div>
</body>
</html>"""
p = Premailer(html, exclude_pseudoclasses=True)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_strip_important(self):
"""Get rid of !important. Makes no sense inline."""
html = """<html>
<head>
<style type="text/css">
p {
height:100% !important;
width:100% !important;
}
</style>
</head>
<body>
<p>Paragraph</p>
</body>
</html>
"""
expect_html = """<html>
<head>
</head>
<body>
<p style="height:100%; width:100%" width="100%" height="100%">Paragraph</p>
</body>
</html>"""
p = Premailer(html, strip_important=True)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_mailto_url(self):
"""if you use URL with mailto: protocol, they should stay as mailto:
when baseurl is used
"""
html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
p = Premailer(html, base_url='http://kungfupeople.com')
result_html = p.transform()
compare_html(expect_html, result_html)
def test_css_with_pseudoclasses_included(self):
"Pick up the pseudoclasses too and include them"
html = '''<html>
<head>
<style type="text/css">
a.special:link { text-decoration:none; }
a { color:red; }
a:hover { text-decoration:none; }
a,a:hover,
a:visited { border:1px solid green; }
p::first-letter {float: left; font-size: 300%}
</style>
</head>
<body>
<a href="#" class="special">Special!</a>
<a href="#">Page</a>
<p>Paragraph</p>
</body>
</html>'''
p = Premailer(html, exclude_pseudoclasses=False)
result_html = p.transform()
# because we're dealing with random dicts here
# we can't predict what order the style attribute
# will be written in so we'll look for things manually.
ok_('<p style="::first-letter{font-size:300%; float:left}">'
'Paragraph</p>' in result_html)
ok_('style="{color:red; border:1px solid green}' in result_html)
ok_(' :visited{border:1px solid green}' in result_html)
ok_(' :hover{border:1px solid green; text-decoration:none}' in
result_html)
def test_shortcut_function(self):
# you don't have to use this approach:
# from premailer import Premailer
# p = Premailer(html, base_url=base_url)
# print p.transform()
# You can do it this way:
# from premailer import transform
# print transform(html, base_url=base_url)
html = '''<html>
<head>
<style type="text/css">h1{color:#123}</style>
</head>
<body>
<h1>Hi!</h1>
</body>
</html>'''
expect_html = '''<html>
<head></head>
<body>
<h1 style="color:#123">Hi!</h1>
</body>
</html>'''
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_basic_html_with_pseudo_selector(self):
"""test the simplest case"""
html = """
<html>
<style type="text/css">
h1 { border:1px solid black }
p { color:red;}
p::first-letter { float:left; }
</style>
<h1 style="font-weight:bolder">Peter</h1>
<p>Hej</p>
</html>
"""
expect_html = """<html>
<head>
<style type="text/css">p::first-letter {float:left}</style>
</head>
<body>
<h1 style="border:1px solid black; font-weight:bolder">Peter</h1>
<p style="color:red">Hej</p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_css_with_pseudoclasses_included(self):
"Pick up the pseudoclasses too and include them"
html = """<html>
<head>
<style type="text/css">
a.special:link { text-decoration:none; }
a { color:red; }
a:hover { text-decoration:none; }
a,a:hover,
a:visited { border:1px solid green; }
p::first-letter {float: left; font-size: 300%}
</style>
</head>
<body>
<a href="#" class="special">Special!</a>
<a href="#">Page</a>
<p>Paragraph</p>
</body>
</html>"""
p = Premailer(html, exclude_pseudoclasses=False)
result_html = p.transform()
# because we're dealing with random dicts here
# we can't predict what order the style attribute
# will be written in so we'll look for things manually.
ok_('<p style="::first-letter{font-size:300%; float:left}">' "Paragraph</p>" in result_html)
ok_('style="{color:red; border:1px solid green}' in result_html)
ok_(" :visited{border:1px solid green}" in result_html)
ok_(" :hover{border:1px solid green; text-decoration:none}" in result_html)
def test_doctype(self):
html = (
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
"""<html>
<head>
</head>
<body>
</body>
</html>""")
expect_html = (
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" '
'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
"""<html>
<head>
</head>
<body>
</body>
</html>""")
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_last_child_exclude_pseudo(self):
html = """<html>
<head>
<style type="text/css">
div {
text-align: right;
}
div:last-child {
text-align: left;
}
</style>
</head>
<body>
<div>First child</div>
<div>Last child</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First child</div>
<div style="text-align:left" align="left">Last child</div>
</body>
</html>"""
p = Premailer(html, exclude_pseudoclasses=True)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_prefer_inline_to_class(self):
html = """<html>
<head>
<style>
.example {
color: black;
}
</style>
</head>
<body>
<div class="example" style="color:red"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:red"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_favour_rule_with_class_over_generic(self):
html = """<html>
<head>
<style>
div.example {
color: green;
}
div {
color: black;
}
</style>
</head>
<body>
<div class="example"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:green"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_favour_rule_with_class_over_generic(self):
html = """<html>
<head>
<style>
div.example {
color: green;
}
div {
color: black;
}
</style>
</head>
<body>
<div class="example"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:green"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_xml_cdata():
"""Test that CDATA is set correctly on remaining styles"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
span:hover > a { background: red; }
</style>
</head>
<body>
<span><a>Test</a></span>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
<style type="text/css">/*<![CDATA[*/span:hover > a {background:red}/*]]>*/</style>
</head>
<body>
<span><a>Test</a></span>
</body>
</html>"""
p = Premailer(html, method="xml")
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def send(request, id, test=False):
newsletter = Newsletter.objects.get(id=id)
subject = newsletter.name
pm = Premailer(
_newsletter_html(request, newsletter),
base_url=cyc_settings.CYCLOPE_BASE_URL,
preserve_internal_links=True,
)
html_message = pm.transform()
if test:
recipients = map(strip, newsletter.test_recipients.split(','))
else:
recipients = map(strip, newsletter.recipients.split(','))
if newsletter.sender_name:
from_address = "%s <%s>" % (newsletter.sender_name, newsletter.sender)
else:
from_address = newsletter.sender
msg = EmailMessage(subject, html_message, from_address, recipients)
msg.content_subtype = "html"
try:
msg.send()
except:
logger = logging.getLogger("django.request")
logger.exception("Newsletter send failed")
return HttpResponseRedirect(reverse('newsletter_failed', args=[id]))
else:
return HttpResponseRedirect(reverse('newsletter_sent', args=[id]))
def test_inline_wins_over_external():
html = """<html>
<head>
<style type="text/css">
div {
text-align: left;
}
/* This tests that a second loop for the same style still doesn't
* overwrite it. */
div {
text-align: left;
}
</style>
</head>
<body>
<div style="text-align:right">Some text</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">Some text</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_favour_rule_with_id_over_others():
html = """<html>
<head>
<style>
#identified {
color: green;
}
div.example {
color: black;
}
</style>
</head>
<body>
<div class="example" id="identified"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div id="identified" style="color:green"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_prefer_inline_to_class():
html = """<html>
<head>
<style>
.example {
color: black;
}
</style>
</head>
<body>
<div class="example" style="color:red"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:red"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_basic_xml():
"""Test the simplest case with xml"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
img { border: none; }
</style>
</head>
<body>
<img src="test.png" alt="test">
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<img src="test.png" alt="test" style="border:none"/>
</body>
</html>"""
p = Premailer(html, method="xml")
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_external_styles_and_links(self):
"""Test loading stylesheets via both the
'external_styles' argument and link tags"""
html = """<html>
<head>
<link href="test-external-links.css" rel="stylesheet" type="text/css">
<style type="text/css">
h1 { color: red; }
</style>
</head>
<body>
<h1>Hello</h1>
</body>
</html>"""
expect_html = """<html>
<head>
<style type="text/css">a:hover {color:purple !important}</style>
</head>
<body>
<h1 style="color:brown">Hello</h1>
</body>
</html>"""
p = Premailer(html, strip_important=False, external_styles=["test-external-styles.css"], base_path="premailer/")
result_html = p.transform()
compare_html(expect_html, result_html)
def test_xml_cdata():
"""Test that CDATA is set correctly on remaining styles"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
span:hover > a { background: red; }
</style>
</head>
<body>
<span><a>Test</a></span>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
<style type="text/css">/*<![CDATA[*/span:hover > a {background:red}/*]]>*/</style>
</head>
<body>
<span><a>Test</a></span>
</body>
</html>"""
p = Premailer(html, method="xml")
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_disabled_validator(self):
"""test disabled_validator"""
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
h1, h2 { fo:bar; }
strong {
color:baz;
text-decoration:none;
}
</style>
</head>
<body>
<h1>Hi!</h1>
<p><strong>Yes!</strong></p>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<h1 style="fo:bar">Hi!</h1>
<p><strong style="color:baz; text-decoration:none">Yes!</strong></p>
</body>
</html>"""
p = Premailer(html, disable_validation=True)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_keep_style_tags():
if not etree:
# can't test it
return
html = """<html>
<head>
<style type="text/css">
h1 { color: red; }
</style>
</head>
<body>
<h1>Hello</h1>
</body>
</html>"""
expect_html = """<html>
<head>
<style type="text/css">
h1 { color: red; }
</style>
</head>
<body>
<h1 style="color:red">Hello</h1>
</body>
</html>"""
p = Premailer(html,
keep_style_tags=True)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_mixed_pseudo_selectors(self):
"""mixing pseudo selectors with straight
forward selectors"""
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
p { color: yellow }
a { color: blue }
a:hover { color: pink }
</style>
</head>
<body>
<p>
<a href="#">Page</a>
</p>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
<style type="text/css">a:hover {color:pink}</style>
</head>
<body>
<p style="color:yellow"><a href="#" style="color:blue">Page</a></p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_basic_html_with_pseudo_selector():
"""test the simplest case"""
if not etree:
# can't test it
return
html = """
<html>
<style type="text/css">
h1 { border:1px solid black }
p { color:red;}
p::first-letter { float:left; }
</style>
<h1 style="font-weight:bolder">Peter</h1>
<p>Hej</p>
</html>
"""
expect_html = """<html>
<head>
<style type="text/css">p::first-letter {float:left}</style>
</head>
<body>
<h1 style="border:1px solid black; font-weight:bolder">Peter</h1>
<p style="color:red">Hej</p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_shortcut_function(self):
# you don't have to use this approach:
# from premailer import Premailer
# p = Premailer(html, base_url=base_url)
# print p.transform()
# You can do it this way:
# from premailer import transform
# print transform(html, base_url=base_url)
html = """<html>
<head>
<style type="text/css">h1{color:#123}</style>
</head>
<body>
<h1>Hi!</h1>
</body>
</html>"""
expect_html = """<html>
<head></head>
<body>
<h1 style="color:#123">Hi!</h1>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_inline_wins_over_external():
html = """<html>
<head>
<style type="text/css">
div {
text-align: left;
}
/* This tests that a second loop for the same style still doesn't
* overwrite it. */
div {
text-align: left;
}
</style>
</head>
<body>
<div style="text-align:right">Some text</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">Some text</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_mailto_url(self):
"""if you use URL with mailto: protocol, they should stay as mailto:
when baseurl is used
"""
html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
p = Premailer(html, base_url="http://kungfupeople.com")
result_html = p.transform()
compare_html(expect_html, result_html)
def test_last_child_exclude_pseudo():
html = """<html>
<head>
<style type="text/css">
div {
text-align: right;
}
div:last-child {
text-align: left;
}
</style>
</head>
<body>
<div>First child</div>
<div>Last child</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First child</div>
<div style="text-align:left" align="left">Last child</div>
</body>
</html>"""
p = Premailer(html, exclude_pseudoclasses=True)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_inline_wins_over_external(self):
html = """<html>
<head>
<style type="text/css">
div {
text-align: left;
}
/* This tests that a second loop for the same style still doesn't
* overwrite it. */
div {
text-align: left;
}
</style>
</head>
<body>
<div style="text-align:right">Some text</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">Some text</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_mediaquery():
html = """<html>
<head>
<style type="text/css">
div {
text-align: right;
}
@media print{
div {
text-align: center;
}
}
</style>
</head>
<body>
<div>First div</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First div</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_child_selector(self):
html = """<html>
<head>
<style type="text/css">
body > div {
text-align: right;
}
</style>
</head>
<body>
<div>First div</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First div</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def __call__(self, *args, **kw):
'''Render the page, and then run it through :mod:`premailer`
:param list args: The arguments to the page.
:param dict kw: The keyword-arguments to the page.
This method calls the __call__ of the super-class with the ``args`` and
``kw``. If the output is HTML it:
* Turns the HTML ``<style>`` elements into ``style`` attributtes by calling
:func:`premailer.transform`, and
* Removes the unused HTML ``<style>`` elements.
This allows the HTML to be rendered consistently in email-clients.'''
orig = super(SiteEmail, self).__call__(*args, **kw)
if orig[0] == '<':
# --=mpj17=-- This is probabily markup, so tidy it some.
premailer = Premailer(
orig, preserve_internal_links=True, keep_style_tags=False,
remove_classes=False, strip_important=False,
disable_validation=True)
premailed = premailer.transform()
enlongened = self.fix_color_codes(premailed)
retval = to_unicode_or_bust(enlongened)
if retval[:9] != '<!DOCTYPE':
retval = '<!DOCTYPE html>\n' + retval
else:
# --=mpj17=-- This is probabily plain-text, so just return it.
retval = orig
return retval
def test_prefer_inline_to_class(self):
html = """<html>
<head>
<style>
.example {
color: black;
}
</style>
</head>
<body>
<div class="example" style="color:red"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:red"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)
def test_mailto_url():
"""if you use URL with mailto: protocol, they should stay as mailto:
when baseurl is used
"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<a href="mailto:[email protected]">[email protected]</a>
</body>
</html>"""
p = Premailer(html, base_url='http://kungfupeople.com')
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
assert expect_html == result_html
def test_favour_rule_with_id_over_others():
html = """<html>
<head>
<style>
#identified {
color: green;
}
div.example {
color: black;
}
</style>
</head>
<body>
<div class="example" id="identified"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div id="identified" style="color:green"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_strip_important():
"""Get rid of !important. Makes no sense inline."""
html = """<html>
<head>
<style type="text/css">
p {
height:100% !important;
width:100% !important;
}
</style>
</head>
<body>
<p>Paragraph</p>
</body>
</html>
"""
expect_html = """<html>
<head>
</head>
<body>
<p style="height:100%; width:100%" width="100%" height="100%">Paragraph</p>
</body>
</html>"""
p = Premailer(html, strip_important=True)
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_basic_xml():
"""Test the simplest case with xml"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
img { border: none; }
</style>
</head>
<body>
<img src="test.png" alt="test">
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<img src="test.png" alt="test" style="border:none"/>
</body>
</html>"""
p = Premailer(html, method="xml")
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_empty_style_tag():
"""empty style tag"""
if not etree:
# can't test it
return
html = """<html>
<head>
<title></title>
<style type="text/css"></style>
</head>
<body>
</body>
</html>"""
expect_html = """<html>
<head>
<title></title>
</head>
<body>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_basic_html_with_pseudo_selector():
"""test the simplest case"""
if not etree:
# can't test it
return
html = """
<html>
<style type="text/css">
h1 { border:1px solid black }
p { color:red;}
p::first-letter { float:left; }
</style>
<h1 style="font-weight:bolder">Peter</h1>
<p>Hej</p>
</html>
"""
expect_html = """<html>
<head>
<style type="text/css">p::first-letter {float:left}</style>
</head>
<body>
<h1 style="border:1px solid black; font-weight:bolder">Peter</h1>
<p style="color:red">Hej</p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_child_selector():
html = """<html>
<head>
<style type="text/css">
body > div {
text-align: right;
}
</style>
</head>
<body>
<div>First div</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First div</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_strip_important():
"""Get rid of !important. Makes no sense inline."""
html = """<html>
<head>
<style type="text/css">
p {
height:100% !important;
width:100% !important;
}
</style>
</head>
<body>
<p>Paragraph</p>
</body>
</html>
"""
expect_html = """<html>
<head>
</head>
<body>
<p style="height:100%; width:100%" width="100%" height="100%">Paragraph</p>
</body>
</html>"""
p = Premailer(html, strip_important=True)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_doctype():
html = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
</head>
<body>
</body>
</html>"""
expect_html = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
</head>
<body>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_last_child_exclude_pseudo():
html = """<html>
<head>
<style type="text/css">
div {
text-align: right;
}
div:last-child {
text-align: left;
}
</style>
</head>
<body>
<div>First child</div>
<div>Last child</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First child</div>
<div style="text-align:left" align="left">Last child</div>
</body>
</html>"""
p = Premailer(html, exclude_pseudoclasses=True)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_prefer_inline_to_class():
html = """<html>
<head>
<style>
.example {
color: black;
}
</style>
</head>
<body>
<div class="example" style="color:red"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:red"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_child_selector():
html = """<html>
<head>
<style type="text/css">
body > div {
text-align: right;
}
</style>
</head>
<body>
<div>First div</div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="text-align:right" align="right">First div</div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_favour_rule_with_class_over_generic():
html = """<html>
<head>
<style>
div.example {
color: green;
}
div {
color: black;
}
</style>
</head>
<body>
<div class="example"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:green"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
whitespace_between_tags = re.compile('>\s*<', )
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_favour_rule_with_class_over_generic():
html = """<html>
<head>
<style>
div.example {
color: green;
}
div {
color: black;
}
</style>
</head>
<body>
<div class="example"></div>
</body>
</html>"""
expect_html = """<html>
<head>
</head>
<body>
<div style="color:green"></div>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
expect_html = whitespace_between_tags.sub('><', expect_html).strip()
result_html = whitespace_between_tags.sub('><', result_html).strip()
eq_(expect_html, result_html)
def test_basic_html(self):
"""test the simplest case"""
html = """<html>
<head>
<title>Title</title>
<style type="text/css">
h1, h2 { color:red; }
strong {
text-decoration:none
}
</style>
</head>
<body>
<h1>Hi!</h1>
<p><strong>Yes!</strong></p>
</body>
</html>"""
expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<h1 style="color:red">Hi!</h1>
<p><strong style="text-decoration:none">Yes!</strong></p>
</body>
</html>"""
p = Premailer(html)
result_html = p.transform()
compare_html(expect_html, result_html)