from __future__ import absolute_import, unicode_literals
import sys
import re
import unittest
import logging
from contextlib import contextmanager
if sys.version_info >= (3, ):  # As in, Python 3
    from urllib.request import urlopen
else:  # Python 2
    from urllib2 import urlopen
    urlopen = urlopen  # shut up pyflakes
from io import StringIO  # Yes, the is an io lib in py2.x

from nose.tools import eq_, ok_, assert_raises
import mock
from lxml.etree import fromstring, XMLSyntaxError

from premailer.premailer import (
    transform,
    Premailer,
    merge_styles,
    csstext_to_pairs,
    ExternalNotFoundError,
)
from premailer.__main__ import main
import premailer.premailer  # lint:ok


whitespace_between_tags = re.compile('>\s*<')


@contextmanager
def captured_output():
    new_out, new_err = StringIO(), StringIO()
    old_out, old_err = sys.stdout, sys.stderr
    try:
        sys.stdout, sys.stderr = new_out, new_err
        yield sys.stdout, sys.stderr
    finally:
        sys.stdout, sys.stderr = old_out, old_err


@contextmanager
def provide_input(content):
    old_stdin = sys.stdin
    sys.stdin = StringIO(content)
    try:
        with captured_output() as (out, err):
            yield out, err
    finally:
        sys.stdin = old_stdin
        sys.stdin = StringIO(content)


class MockResponse(object):

    def __init__(self, content):
        self.text = content


def compare_html(one, two):
    one = one.strip()
    two = two.strip()
    one = whitespace_between_tags.sub('>\n<', one)
    two = whitespace_between_tags.sub('>\n<', two)
    one = one.replace('><', '>\n<')
    two = two.replace('><', '>\n<')
    for i, line in enumerate(one.splitlines()):
        other = two.splitlines()[i]
        if line.lstrip() != other.lstrip():
            eq_(line.lstrip(), other.lstrip())


class Tests(unittest.TestCase):

    def shortDescription(self):
        # most annoying thing in the world about nose
        pass

    def test_merge_styles_basic(self):
        inline_style = 'font-size:1px; color: red'
        new = 'font-size:2px; font-weight: bold'
        expect = 'font-size:1px;', 'font-weight:bold;', 'color:red'
        result = merge_styles(inline_style, [csstext_to_pairs(new)], [''])
        for each in expect:
            ok_(each in result)

    def test_merge_styles_with_class(self):
        inline_style = 'color:red; font-size:1px;'
        new, class_ = 'font-size:2px; font-weight: bold', ':hover'

        # because we're dealing with dicts (random order) we have to
        # test carefully.
        # We expect something like this:
        #  {color:red; font-size:1px} :hover{font-size:2px; font-weight:bold}

        result = merge_styles(inline_style, [csstext_to_pairs(new)], [class_])
        ok_(result.startswith('{'))
        ok_(result.endswith('}'))
        ok_(' :hover{' in result)
        split_regex = re.compile('{([^}]+)}')
        eq_(len(split_regex.findall(result)), 2)
        expect_first = 'color:red', 'font-size:1px'
        expect_second = 'font-weight:bold', 'font-size:2px'
        for each in expect_first:
            ok_(each in split_regex.findall(result)[0])
        for each in expect_second:
            ok_(each in split_regex.findall(result)[1])

    def test_merge_styles_non_trivial(self):
        inline_style = (
            'background-image:url("data:image/png;base64,iVBORw0KGg")'
        )
        new = 'font-size:2px; font-weight: bold'
        expect = (
            'background-image:url("data:image/png;base64,iVBORw0KGg")',
            'font-size:2px;',
            'font-weight:bold'
        )
        result = merge_styles(inline_style, [csstext_to_pairs(new)], [''])
        for each in expect:
            ok_(each in result)

    def test_merge_styles_with_unset(self):
        inline_style = 'color: red'
        new = 'font-size: 10px; font-size: unset; font-weight: bold'
        expect = 'font-weight:bold;', 'color:red'
        css_new = csstext_to_pairs(new)
        result = merge_styles(
            inline_style,
            [css_new],
            [''],
            remove_unset_properties=True,
        )
        for each in expect:
            ok_(each in result)
        ok_('font-size' not in result)

    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)

    def test_remove_classes(self):
        """test the simplest case"""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        .stuff {
            color: red;
        }
        </style>
        </head>
        <body>
        <p class="stuff"><strong>Yes!</strong></p>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <p style="color:red"><strong>Yes!</strong></p>
        </body>
        </html>"""

        p = Premailer(html, remove_classes=True)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_basic_html_shortcut_function(self):
        """test the plain transform function"""
        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>"""

        result_html = transform(html)
        compare_html(expect_html, result_html)

    def test_empty_style_tag(self):
        """empty style tag"""

        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()

        compare_html(expect_html, result_html)

    def test_include_star_selector(self):
        """test the simplest case"""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        p * { color: red }
        </style>
        </head>
        <body>
        <h1>Hi!</h1>
        <p><strong>Yes!</strong></p>
        </body>
        </html>"""

        expect_html_not_included = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <h1>Hi!</h1>
        <p><strong>Yes!</strong></p>
        </body>
        </html>"""

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html_not_included, result_html)

        expect_html_star_included = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <h1>Hi!</h1>
        <p><strong style="color:red">Yes!</strong></p>
        </body>
        </html>"""

        p = Premailer(html, include_star_selectors=True)
        result_html = p.transform()

        compare_html(expect_html_star_included, 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(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_parse_style_rules(self):
        p = Premailer('html')  # won't need the html
        func = p._parse_style_rules
        rules, leftover = func("""
        h1, h2 { color:red; }
        /* ignore
            this */
        strong {
            text-decoration:none
            }
        ul li {  list-style: 2px; }
        a:hover { text-decoration: underline }
        """, 0)

        # 'rules' is a list, turn it into a dict for
        # easier assertion testing
        rules_dict = {}
        rules_specificity = {}
        for specificity, k, v in rules:
            rules_dict[k] = v
            rules_specificity[k] = specificity

        ok_('h1' in rules_dict)
        ok_('h2' in rules_dict)
        ok_('strong' in rules_dict)
        ok_('ul li' in rules_dict)

        eq_(rules_dict['h1'], 'color:red')
        eq_(rules_dict['h2'], 'color:red')
        eq_(rules_dict['strong'], 'text-decoration:none')
        eq_(rules_dict['ul li'], 'list-style:2px')
        ok_('a:hover' not in rules_dict)

        # won't need the html
        p = Premailer('html', exclude_pseudoclasses=True)
        func = p._parse_style_rules
        rules, leftover = func("""
        ul li {  list-style: 2px; }
        a:hover { text-decoration: underline }
        """, 0)

        eq_(len(rules), 1)
        specificity, k, v = rules[0]
        eq_(k, 'ul li')
        eq_(v, 'list-style:2px')

        eq_(len(leftover), 1)
        k, v = leftover[0]
        eq_((k, v), ('a:hover', 'text-decoration:underline'), (k, v))

    def test_precedence_comparison(self):
        p = Premailer('html')  # won't need the html
        rules, leftover = p._parse_style_rules("""
        #identified { color:blue; }
        h1, h2 { color:red; }
        ul li {  list-style: 2px; }
        li.example { color:green; }
        strong { text-decoration:none }
        div li.example p.sample { color:black; }
        """, 0)

        # 'rules' is a list, turn it into a dict for
        # easier assertion testing
        rules_specificity = {}
        for specificity, k, v in rules:
            rules_specificity[k] = specificity

        # Last in file wins
        ok_(rules_specificity['h1'] < rules_specificity['h2'])
        # More elements wins
        ok_(rules_specificity['strong'] < rules_specificity['ul li'])
        # IDs trump everything
        ok_(rules_specificity['div li.example p.sample'] <
            rules_specificity['#identified'])

        # Classes trump multiple elements
        ok_(rules_specificity['ul li'] <
            rules_specificity['li.example'])

    def test_base_url_fixer(self):
        """if you leave some URLS as /foo and set base_url to
        'http://www.google.com' the URLS become 'http://www.google.com/foo'
        """
        html = '''<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <img src="/images/foo.jpg">
        <img src="/images/bar.gif">
        <img src="cid:images/baz.gif">
        <img src="http://www.googe.com/photos/foo.jpg">
        <a href="/home">Home</a>
        <a href="http://www.peterbe.com">External</a>
        <a href="subpage">Subpage</a>
        <a href="#internal_link">Internal Link</a>
        </body>
        </html>
        '''

        expect_html = '''<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <img src="http://kungfupeople.com/images/foo.jpg">
        <img src="http://kungfupeople.com/images/bar.gif">
        <img src="cid:images/baz.gif">
        <img src="http://www.googe.com/photos/foo.jpg">
        <a href="http://kungfupeople.com/home">Home</a>
        <a href="http://www.peterbe.com">External</a>
        <a href="http://kungfupeople.com/subpage">Subpage</a>
        <a href="#internal_link">Internal Link</a>
        </body>
        </html>'''

        p = Premailer(
            html,
            base_url='http://kungfupeople.com',
            preserve_internal_links=True
        )
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_base_url_with_path(self):
        """if you leave some URLS as /foo and set base_url to
        'http://www.google.com' the URLS become 'http://www.google.com/foo'
        """

        html = '''<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <img src="/images/foo.jpg">
        <img src="http://www.googe.com/photos/foo.jpg">
        <a href="/home">Home</a>
        <a href="http://www.peterbe.com">External</a>
        <a href="http://www.peterbe.com/base/">External 2</a>
        <a href="subpage">Subpage</a>
        <a href="#internal_link">Internal Link</a>
        </body>
        </html>
        '''

        expect_html = '''<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <img src="http://kungfupeople.com/images/foo.jpg">
        <img src="http://www.googe.com/photos/foo.jpg">
        <a href="http://kungfupeople.com/home">Home</a>
        <a href="http://www.peterbe.com">External</a>
        <a href="http://www.peterbe.com/base/">External 2</a>
        <a href="http://kungfupeople.com/base/subpage">Subpage</a>
        <a href="#internal_link">Internal Link</a>
        </body>
        </html>'''

        p = Premailer(html, base_url='http://kungfupeople.com/base/',
                      preserve_internal_links=True)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_style_block_with_external_urls(self):
        """
        From http://github.com/peterbe/premailer/issues/#issue/2

        If you have
          body { background:url(http://example.com/bg.png); }
        the ':' inside '://' is causing a problem
        """

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        body {
          color:#123;
          background: url(http://example.com/bg.png);
          font-family: Omerta;
        }
        </style>
        </head>
        <body>
        <h1>Hi!</h1>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        </head>
        <body style="background:url(http://exam
ple.com/bg.png); color:#123; font-family:Omerta">
        <h1>Hi!</h1>
        </body>
        </html>""".replace('exam\nple', 'example')

        p = Premailer(html)
        result_html = p.transform()

        compare_html(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 fragment_in_html(self, fragment, html, fullMessage=False):
        if fullMessage:
            message = '"{0}" not in\n{1}'.format(fragment, html)
        else:
            message = '"{0}" not in HTML'.format(fragment)
        ok_(fragment in html, message)

    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.
        e = '<p style="::first-letter{float:left; font-size:300%}">'\
            'Paragraph</p>'
        self.fragment_in_html(e, result_html, True)

        e = 'style="{color:red; border:1px solid green}'
        self.fragment_in_html(e, result_html)
        e = ' :visited{border:1px solid green}'
        self.fragment_in_html(e, result_html)
        e = ' :hover{text-decoration:none; border:1px solid green}'
        self.fragment_in_html(e, result_html)

    def test_css_with_pseudoclasses_excluded(self):
        "Skip things like `a:hover{}` and keep them in the style block"

        html = """<html>
        <head>
        <style type="text/css">
        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="#">Page</a>
        <p>Paragraph</p>
        </body>
        </html>"""

        expect_html = """<html>
<head>
<style type="text/css">a:hover {text-decoration:none}
a:hover {border:1px solid green}
a:visited {border:1px solid green}p::first-letter {float:left;font-size:300%}
</style>
</head>
<body>
<a href="#" style="color:red; border:1px solid green">Page</a>
<p>Paragraph</p>
</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()

        expect_html = re.sub('}\s+', '}', expect_html)
        result_html = result_html.replace('}\n', '}')

        eq_(expect_html, result_html)
        # XXX

    def test_css_with_html_attributes(self):
        """Some CSS styles can be applied as normal HTML attribute like
        'background-color' can be turned into 'bgcolor'
        """

        html = """<html>
        <head>
        <style type="text/css">
        td { background-color:red; vertical-align:middle;}
        p { text-align:center;}
        table { width:200px; }
        </style>
        </head>
        <body>
        <p>Text</p>
        <table>
          <tr>
            <td>Cell 1</td>
            <td>Cell 2</td>
          </tr>
        </table>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        </head>
        <body>
        <p style="text-align:center" align="center">Text</p>
        <table style="width:200px" width="200">
          <tr>
            <td style="background-color:red; vert
ical-align:middle" bgcolor="red" valign="middle">Cell 1</td>
            <td style="background-color:red; vert
ical-align:middle" bgcolor="red" valign="middle">Cell 2</td>
          </tr>
        </table>
        </body>
        </html>""".replace('vert\nical', 'vertical')

        p = Premailer(html, exclude_pseudoclasses=True)
        result_html = p.transform()

        expect_html = re.sub('}\s+', '}', expect_html)
        result_html = result_html.replace('}\n', '}')

        compare_html(expect_html, result_html)

    def test_css_disable_basic_html_attributes(self):
        """Some CSS styles can be applied as normal HTML attribute like
        'background-color' can be turned into 'bgcolor'
        """

        html = """<html>
        <head>
        <style type="text/css">
        td { background-color:red; }
        p { text-align:center; }
        table { width:200px; height: 300px; }
        </style>
        </head>
        <body>
        <p>Text</p>
        <table>
          <tr>
            <td>Cell 1</td>
            <td>Cell 2</td>
          </tr>
        </table>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        </head>
        <body>
        <p style="text-align:center">Text</p>
        <table style="height:300px; width:200px">
          <tr>
            <td style="background-color:red" bgcolor="red">Cell 1</td>
            <td style="background-color:red" bgcolor="red">Cell 2</td>
          </tr>
        </table>
        </body>
        </html>"""

        p = Premailer(
            html,
            exclude_pseudoclasses=True,
            disable_basic_attributes=['align', 'width', 'height']
        )
        result_html = p.transform()

        expect_html = re.sub('}\s+', '}', expect_html)
        result_html = result_html.replace('}\n', '}')

        compare_html(expect_html, result_html)

    def test_apple_newsletter_example(self):
        # stupidity test
        import os

        html_file = os.path.join('premailer', 'tests',
                                 'test-apple-newsletter.html')
        html = open(html_file).read()

        p = Premailer(html, exclude_pseudoclasses=False,
                      keep_style_tags=True,
                      strip_important=False)
        result_html = p.transform()
        ok_('<html>' in result_html)
        ok_('<style media="only screen and (max-device-width: 480px)" '
            'type="text/css">\n'
            '* {line-height: normal !important; '
            '-webkit-text-size-adjust: 125%}\n'
            '</style>' in 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:e-mail@example.com">e-mail@example.com</a>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <a href="mailto:e-mail@example.com">e-mail@example.com</a>
        </body>
        </html>"""

        p = Premailer(html, base_url='http://kungfupeople.com')
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_tel_url(self):
        """if you use URL with tel: protocol, it should stay as tel:
        when baseurl is used
        """

        html = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <a href="tel:202-555-0113">202-555-0113</a>
        </body>
        </html>"""

        p = Premailer(html, base_url='http://kungfupeople.com')
        result_html = p.transform()

        compare_html(result_html, html)

    def test_uppercase_margin(self):
        """Option to comply with outlook.com

        https://emailonacid.com/blog/article/email-development/outlook.com-does-support-margins
        """

        html = """<html>
<head>
<title>Title</title>
</head>
<style>
h1 {margin: 0}
h2 {margin-top:0;margin-bottom:0;margin-left:0;margin-right:0}
</style>
<body>
<h1>a</h1>
<h2>
b
</h2>
</body>
</html>"""

        expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<h1 style="Margin:0">a</h1>
<h2 style="Margin-bottom:0; Margin-left:0; Margin-right:0; Margin-top:0">
b
</h2>
</body>
</html>"""

        p = Premailer(html, capitalize_float_margin=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%" height="100%" width="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(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)
        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_mediaquery(self):
        html = """<html>
        <head>
        <style type="text/css">
        div {
            text-align: right;
        }
        @media print{
            div {
                text-align: center;
                color: white;
            }
            div {
                font-size: 999px;
            }
        }
        </style>
        </head>
        <body>
        <div>First div</div>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <style type="text/css">@media print {
        div {
            text-align: center !important;
            color: white !important
            }
        div {
            font-size: 999px !important
            }
        }</style>
        </head>
        <body>
        <div style="text-align:right" align="right">First div</div>
        </body>
        </html>"""

        p = Premailer(html, strip_important=False)
        result_html = p.transform()

        compare_html(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 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_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 class="example" style="color:red"></div>
        </body>
        </html>"""

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_favour_rule_with_element_over_generic(self):
        html = """<html>
        <head>
        <style>
        div.example {
            color: green;
        }
        .example {
            color: black;
        }
        </style>
        </head>
        <body>
        <div class="example"></div>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        </head>
        <body>
        <div class="example" 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 class="example" style="color:green"></div>
        </body>
        </html>"""

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_favour_rule_with_id_over_others(self):
        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 class="example" id="identified" style="color:green"></div>
        </body>
        </html>"""

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_favour_rule_with_important_over_others(self):
        html = """<html>
        <head>
        <style>
        .makeblue {
            color: blue !important;
            font-size: 12px;
        }
        #id {
            color: green;
            font-size: 22px;
        }
        div.example {
            color: black;
        }
        </style>
        </head>
        <body>
        <div class="example makeblue" id="id"></div>
        </body>
        </html>"""

        expect_html = """<html>
<head>
</head>
<body>
<div class="example makeblue" id="id" style="font-size:22px; color:blue"></div>
</body>
</html>"""

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_multiple_style_elements(self):
        """Asserts that rules from multiple style elements
        are inlined correctly."""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        h1, h2 { color:red; }
        strong {
            text-decoration:none
            }
        </style>
        <style type="text/css">
        h1, h2 { color:green; }
        p {
            font-size:120%
            }
        </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:green">Hi!</h1>
        <p style="font-size:120%"><strong style="text-deco
ration:none">Yes!</strong></p>
        </body>
        </html>""".replace('deco\nration', 'decoration')

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_style_attribute_specificity(self):
        """Stuff already in style attributes beats style tags."""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        h1 { color: pink }
        h1.foo { color: blue }
        </style>
        </head>
        <body>
        <h1 class="foo" style="color: green">Hi!</h1>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <h1 class="foo" style="color:green">Hi!</h1>
        </body>
        </html>"""

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_ignore_style_elements_with_media_attribute(self):
        """Asserts that style elements with media attributes other than
        'screen' are ignored."""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
            h1, h2 { color:red; }
            strong {
                text-decoration:none
            }
        </style>
        <style type="text/css" media="screen">
            h1, h2 { color:green; }
            p {
                font-size:16px;
                }
        </style>
        <style type="text/css" media="only screen and (max-width: 480px)">
            h1, h2 { color:orange; }
            p {
                font-size:120%;
            }
        </style>
        </head>
        <body>
        <h1>Hi!</h1>
        <p><strong>Yes!</strong></p>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css" media="only screen and (max-width: 480px)">
            h1, h2 { color:orange; }
            p {
                font-size:120%;
            }
        </style>
        </head>
        <body>
        <h1 style="color:green">Hi!</h1>
        <p style="font-size:16px"><strong style="text-deco
ration:none">Yes!</strong></p>
        </body>
        </html>""".replace('deco\nration', 'decoration')

        p = Premailer(html)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_leftover_important(self):
        """Asserts that leftover styles should be marked as !important."""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        a { color: red; }
        a:hover { color: green; }
        a:focus { color: blue !important; }
        </style>
        </head>
        <body>
        <a href="#">Hi!</a>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        a { color: red; }
        a:hover { color: green; }
        a:focus { color: blue !important; }
        </style>
        </head>
        <body>
        <a href="#" style="color:red">Hi!</a>
        </body>
        </html>"""

        p = Premailer(html,
                      keep_style_tags=True,
                      strip_important=False)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_basic_xml(self):
        """Test the simplest case with xml"""

        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()

        compare_html(expect_html, result_html)

    def test_broken_xml(self):
        """Test the simplest case with xml"""

        html = """<html>
        <head>
        <title>Title
        <style type="text/css">
        img { border: none; }
        </style>
        </head>
        <body>
        <img src="test.png" alt="test"/>
        </body>
        """

        p = Premailer(html, method="xml")
        assert_raises(
            XMLSyntaxError,
            p.transform,
        )

    def test_xml_cdata(self):
        """Test that CDATA is set correctly on remaining styles"""

        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 {back
ground:red}/*]]>*/</style>
        </head>
        <body>
        <span><a>Test</a></span>
        </body>
        </html>
        """.replace('back\nground', 'background')

        p = Premailer(html, method="xml")
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_command_line_fileinput_from_stdin(self):
        html = '<style>h1 { color:red; }</style><h1>Title</h1>'
        expect_html = """
        <html>
        <head></head>
        <body><h1 style="color:red">Title</h1></body>
        </html>
        """

        with provide_input(html) as (out, err):
            main([])
        result_html = out.getvalue().strip()

        compare_html(expect_html, result_html)

    def test_command_line_fileinput_from_argument(self):
        with captured_output() as (out, err):
            main([
                '-f',
                'premailer/tests/test-apple-newsletter.html',
                '--disable-basic-attributes=bgcolor'
            ])

        result_html = out.getvalue().strip()

        ok_('<html>' in result_html)
        ok_('<style media="only screen and (max-device-width: 480px)" '
            'type="text/css">\n'
            '* {line-height: normal !important; '
            '-webkit-text-size-adjust: 125%}\n'
            '</style>' in result_html)

    def test_command_line_preserve_style_tags(self):
        with captured_output() as (out, err):
            main([
                '-f',
                'premailer/tests/test-issue78.html',
                '--preserve-style-tags',
                '--external-style=premailer/tests/test-external-styles.css',
            ])

        result_html = out.getvalue().strip()

        expect_html = """
        <html>
        <head>
        <style type="text/css">h1 {
          color: blue;
        }
        h2 {
          color: green;
        }
        a {
          color: pink;
        }
        a:hover {
          color: purple;
        }
        </style>
        <link rel="alternate" type="applic
ation/rss+xml" title="RSS" href="/rss.xml">
        <style type="text/css">
        .yshortcuts a {border-bottom: none !important;}
        @media screen and (max-width: 600px) {
            table[class="container"] {
                width: 100% !important;
            }
        }
        /* Even comments should be preserved when the
           keep_style_tags flag is set */
        p {font-size:12px;}
        </style>
        <style type="text/css">h1 {
          color: brown;
        }
        h2::after {
          content: "";
          display: block;
        }
        @media all and (max-width: 320px) {
            h1 {
                font-size: 12px;
            }
        }
        </style>
        </head>
        <body>
        <h1 style="color:brown">h1</h1>
        <p style="font-size:12px"><a href="" style="{color:pink} :hover{col
or:purple}">html</a></p>
        </body>
        </html>
        """.replace('col\nor', 'color').replace('applic\nation', 'application')

        compare_html(expect_html, result_html)

        # for completeness, test it once without
        with captured_output() as (out, err):
            main([
                '-f',
                'premailer/tests/test-issue78.html',
                '--external-style=premailer/tests/test-external-styles.css',
            ])

        result_html = out.getvalue().strip()
        expect_html = """
        <html>
        <head>
        <link rel="alternate" type="applic
ation/rss+xml" title="RSS" href="/rss.xml">
        <style type="text/css">@media screen and (max-width: 600px) {
            table[class="container"] {
                width: 100% !important
                }
            }</style>
        <style type="text/css">@media all and (max-width: 320px) {
            h1 {
                font-size: 12px !important
                }
            }</style>
        </head>
        <body>
        <h1 style="color:brown">h1</h1>
        <p style="font-size:12px"><a href="" style="{color:pink} :hover{co
lor:purple}">html</a></p>
        </body>
        </html>
        """.replace('co\nlor', 'color').replace('applic\nation', 'application')

        compare_html(expect_html, result_html)

    def test_multithreading(self):
        """The test tests thread safety of merge_styles function which employs
        thread non-safe cssutils calls.
        The test would fail if merge_styles would have not been thread-safe """

        import threading
        import logging
        THREADS = 30
        REPEATS = 100

        class RepeatMergeStylesThread(threading.Thread):
            """The thread is instantiated by test and run multiple
            times in parallel."""
            exc = None

            def __init__(self, old, new, class_):
                """The constructor just stores merge_styles parameters"""
                super(RepeatMergeStylesThread, self).__init__()
                self.old, self.new, self.class_ = old, new, class_

            def run(self):
                """Calls merge_styles in a loop and sets exc attribute
                if merge_styles raises an exception."""
                for _ in range(0, REPEATS):
                    try:
                        merge_styles(self.old, self.new, self.class_)
                    except Exception as e:
                        logging.exception("Exception in thread %s", self.name)
                        self.exc = e

        inline_style = 'background-color:#ffffff;'
        new = 'background-color:#dddddd;'
        class_ = ''

        # start multiple threads concurrently; each
        # calls merge_styles many times
        threads = [
            RepeatMergeStylesThread(
                inline_style,
                [csstext_to_pairs(new)],
                [class_]
            )
            for _ in range(0, THREADS)
        ]
        for t in threads:
            t.start()

        # wait until all threads are done
        for t in threads:
            t.join()

        # check if any thread raised exception while in merge_styles call
        exceptions = [t.exc for t in threads if t.exc is not None]
        eq_(exceptions, [])

    def test_external_links(self):
        """Test loading stylesheets via link tags"""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        h1 { color:red; }
        h3 { color:yellow; }
        </style>
        <link href="premailer/tests/test-external-links.css" rel="style
sheet" type="text/css">
        <link rel="alternate" type="applic
ation/rss+xml" title="RSS" href="/rss.xml">
        <style type="text/css">
        h1 { color:orange; }
        </style>
        </head>
        <body>
        <h1>Hello</h1>
        <h2>World</h2>
        <h3>Test</h3>
        <a href="#">Link</a>
        </body>
        </html>""".replace(
            'applic\naction', 'application'
        ).replace('style\nsheet', 'stylesheet')

        expect_html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">a:hover {color:purple !important}</style>
        <link rel="alternate" type="applic
ation/rss+xml" title="RSS" href="/rss.xml">
        </head>
        <body>
        <h1 style="color:orange">Hello</h1>
        <h2 style="color:green">World</h2>
        <h3 style="color:yellow">Test</h3>
        <a href="#" style="color:pink">Link</a>
        </body>
        </html>""".replace('applic\naction', 'application')

        p = Premailer(
            html,
            strip_important=False
        )
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_external_links_unfindable(self):
        """Test loading stylesheets that can't be found"""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        h1 { color:red; }
        h3 { color:yellow; }
        </style>
        <link href="premailer/xxxx.css" rel="stylesheet" type="text/css">
        <style type="text/css">
        h1 { color:orange; }
        </style>
        </head>
        <body>
        <h1>Hello</h1>
        <h2>World</h2>
        <h3>Test</h3>
        <a href="#">Link</a>
        </body>
        </html>"""

        p = Premailer(
            html,
            strip_important=False
        )
        assert_raises(
            ExternalNotFoundError,
            p.transform,
        )

    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>
        <h2>Hello</h2>
        <a href="">Hello</a>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <style type="text/css">a:hover {color:purple !important}</style>
        <style type="text/css">h2::after {cont
ent:"" !important;display:block !important}
        @media all and (max-width: 320px) {
            h1 {
                font-size: 12px !important
                }
            }</style>
        </head>
        <body>
        <h1 style="color:brown">Hello</h1>
        <h2 style="color:green">Hello</h2>
        <a href="" style="color:pink">Hello</a>
        </body>
        </html>""".replace('cont\nent', 'content')

        p = Premailer(
            html,
            strip_important=False,
            external_styles='test-external-styles.css',
            base_path='premailer/tests/')
        result_html = p.transform()

        compare_html(expect_html, result_html)

    @mock.patch('premailer.premailer.requests')
    def test_load_external_url(self, mocked_requests):
        'Test premailer.premailer.Premailer._load_external_url'
        faux_response = 'This is not a response'
        faux_uri = 'https://example.com/site.css'
        mocked_requests.get.return_value = MockResponse(faux_response)
        p = premailer.premailer.Premailer('<p>A paragraph</p>')
        r = p._load_external_url(faux_uri)

        mocked_requests.get.assert_called_once_with(faux_uri)
        eq_(faux_response, r)

    def test_css_text(self):
        """Test handling css_text passed as a string"""

        html = """<html>
        <head>
        </head>
        <body>
        <h1>Hello</h1>
        <h2>Hello</h2>
        <a href="">Hello</a>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <style type="text/css">@media all and (max-width: 320px) {
            h1 {
                color: black !important
                }
            }</style>
        </head>
        <body>
        <h1 style="color:brown">Hello</h1>
        <h2 style="color:green">Hello</h2>
        <a href="" style="color:pink">Hello</a>
        </body>
        </html>"""

        css_text = """
        h1 {
            color: brown;
        }
        h2 {
            color: green;
        }
        a {
            color: pink;
        }
        @media all and (max-width: 320px) {
            h1 {
                color: black;
            }
        }

        """

        p = Premailer(
            html,
            strip_important=False,
            css_text=[css_text])
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_css_text_with_only_body_present(self):
        """Test handling css_text passed as a string when no <html> or
        <head> is present"""

        html = """<body>
        <h1>Hello</h1>
        <h2>Hello</h2>
        <a href="">Hello</a>
        </body>"""

        expect_html = """<html>
        <head>
        <style type="text/css">@media all and (max-width: 320px) {
            h1 {
                color: black !important
                }
            }</style>
        </head>
        <body>
        <h1 style="color:brown">Hello</h1>
        <h2 style="color:green">Hello</h2>
        <a href="" style="color:pink">Hello</a>
        </body>
        </html>"""

        css_text = """
        h1 {
            color: brown;
        }
        h2 {
            color: green;
        }
        a {
            color: pink;
        }
        @media all and (max-width: 320px) {
            h1 {
                color: black;
            }
        }
        """

        p = Premailer(
            html,
            strip_important=False,
            css_text=css_text)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_css_disable_leftover_css(self):
        """Test handling css_text passed as a string when no <html> or
        <head> is present"""

        html = """<body>
        <h1>Hello</h1>
        <h2>Hello</h2>
        <a href="">Hello</a>
        </body>"""

        expect_html = """<html>
        <body>
        <h1 style="color:brown">Hello</h1>
        <h2 style="color:green">Hello</h2>
        <a href="" style="color:pink">Hello</a>
        </body>
        </html>"""

        css_text = """
        h1 {
            color: brown;
        }
        h2 {
            color: green;
        }
        a {
            color: pink;
        }
        @media all and (max-width: 320px) {
            h1 {
                color: black;
            }
        }
        """

        p = Premailer(
            html,
            strip_important=False,
            css_text=css_text,
            disable_leftover_css=True)
        result_html = p.transform()

        compare_html(expect_html, result_html)

    @staticmethod
    def mocked_urlopen(url):
        'The standard "response" from the "server".'
        retval = ''
        if 'style1.css' in url:
            retval = "h1 { color: brown }"
        elif 'style2.css' in url:
            retval = "h2 { color: pink }"
        elif 'style3.css' in url:
            retval = "h3 { color: red }"
        return retval

    @mock.patch.object(Premailer, '_load_external_url')
    def test_external_styles_on_http(self, mocked_pleu):
        """Test loading styles that are genuinely external"""

        html = """<html>
        <head>
        <link href="https://www.com/style1.css" rel="stylesheet">
        <link href="//www.com/style2.css" rel="stylesheet">
        <link href="//www.com/style3.css" rel="stylesheet">
        </head>
        <body>
        <h1>Hello</h1>
        <h2>World</h2>
        <h3>World</h3>
        </body>
        </html>"""
        mocked_pleu.side_effect = self.mocked_urlopen
        p = Premailer(html)
        result_html = p.transform()

        # Expected values are tuples of the positional values (as another
        # tuple) and the ketword arguments (which are all null), hence the
        # following Lisp-like explosion of brackets and commas.
        expected_args = [(('https://www.com/style1.css',),),
                         (('http://www.com/style2.css',),),
                         (('http://www.com/style3.css',),)]
        eq_(expected_args, mocked_pleu.call_args_list)

        expect_html = """<html>
        <head>
        </head>
        <body>
        <h1 style="color:brown">Hello</h1>
        <h2 style="color:pink">World</h2>
        <h3 style="color:red">World</h3>
        </body>
        </html>"""
        compare_html(expect_html, result_html)

    @mock.patch.object(Premailer, '_load_external_url')
    def test_external_styles_on_https(self, mocked_pleu):
        """Test loading styles that are genuinely external"""

        html = """<html>
        <head>
        <link href="https://www.com/style1.css" rel="stylesheet">
        <link href="//www.com/style2.css" rel="stylesheet">
        <link href="/style3.css" rel="stylesheet">
        </head>
        <body>
        <h1>Hello</h1>
        <h2>World</h2>
        <h3>World</h3>
        </body>
        </html>"""

        mocked_pleu.side_effect = self.mocked_urlopen
        p = Premailer(html, base_url='https://www.peterbe.com')
        result_html = p.transform()

        expected_args = [(('https://www.com/style1.css',),),
                         (('https://www.com/style2.css',),),
                         (('https://www.peterbe.com/style3.css',),)]
        eq_(expected_args, mocked_pleu.call_args_list)
        expect_html = """<html>
        <head>
        </head>
        <body>
        <h1 style="color:brown">Hello</h1>
        <h2 style="color:pink">World</h2>
        <h3 style="color:red">World</h3>
        </body>
        </html>"""
        compare_html(expect_html, result_html)

    @mock.patch.object(Premailer, '_load_external_url')
    def test_external_styles_with_base_url(self, mocked_pleu):
        """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>"""
        mocked_pleu.return_value = "h1 { color: brown }"
        p = Premailer(html, base_url='http://www.peterbe.com/')
        result_html = p.transform()
        expected_args = [(('http://www.peterbe.com/style.css',),), ]
        eq_(expected_args, mocked_pleu.call_args_list)

        expect_html = """<html>
        <head>
        </head>
        <body>
        <h1 style="color:brown">Hello</h1>
        </body>
        </html>"""
        compare_html(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_comments_in_media_queries(self):
        """CSS comments inside a media query block should not be a problem"""
        html = """<!doctype html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <title>Document</title>
            <style>
            @media screen {
                /* comment */
            }
            </style>
        </head>
        <body></body>
        </html>"""

        p = Premailer(html, disable_validation=True)
        result_html = p.transform()
        ok_('/* comment */' in result_html)

    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');
                    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_keyframe_selectors(self):
        """
        keyframes shouldn't be a problem.
        """
        html = """<!doctype html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <title>Document</title>
            <style>
            @keyframes fadein {
                from { opacity: 0; }
                to   { opacity: 1; }
            }

            /* Firefox */
            @-moz-keyframes fadein {
                from { opacity: 0; }
                to   { opacity: 1; }
            }

            /* Safari and Chrome */
            @-webkit-keyframes fadein {
                from { opacity: 0; }
                to   { opacity: 1; }
            }

            /* Internet Explorer */
            @-ms-keyframes fadein {
                from { opacity: 0; }
                to   { opacity: 1; }
            }

            /* Opera */
            @-o-keyframes fadein {
                from { opacity: 0; }
                to   { opacity: 1; }
            }
            </style>
        </head>
        <body></body>
        </html>"""

        p = Premailer(html, disable_validation=True)
        p.transform()  # it should just work

    def test_capture_cssutils_logging(self):
        """you can capture all the warnings, errors etc. from cssutils
        with your own logging. """
        html = """<!doctype html>
        <html>
        <head>
            <meta charset="UTF-8">
            <title>Document</title>
            <style>
            @keyframes fadein {
                from { opacity: 0; }
                to   { opacity: 1; }
            }
            </style>
        </head>
        <body></body>
        </html>"""

        mylog = StringIO()
        myhandler = logging.StreamHandler(mylog)
        p = Premailer(
            html,
            cssutils_logging_handler=myhandler,
        )
        p.transform()  # it should work
        eq_(
            mylog.getvalue(),
            'CSSStylesheet: Unknown @rule found. [2:13: @keyframes]\n'
        )

        # only log errors now
        mylog = StringIO()
        myhandler = logging.StreamHandler(mylog)
        p = Premailer(
            html,
            cssutils_logging_handler=myhandler,
            cssutils_logging_level=logging.ERROR,
        )
        p.transform()  # it should work
        eq_(mylog.getvalue(), '')

    def test_type_test(self):
        """test the correct type is returned"""

        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>"""

        p = Premailer(html)
        result = p.transform()
        eq_(type(result), type(""))

        html = fromstring(html)
        etree_type = type(html)

        p = Premailer(html)
        result = p.transform()
        ok_(type(result) != etree_type)

    def test_ignore_some_inline_stylesheets(self):
        """test that it's possible to put a `data-premailer="ignore"`
        attribute on a <style> tag and it gets left alone (except that
        the attribute gets removed)"""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        h1 { color:red; }
        </style>
        <style type="text/css" data-premailer="ignore">
        h1 { color:blue; }
        </style>
        </head>
        <body>
        <h1>Hello</h1>
        <h2>World</h2>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css">
        h1 { color:blue; }
        </style>
        </head>
        <body>
        <h1 style="color:red">Hello</h1>
        <h2>World</h2>
        </body>
        </html>"""

        p = Premailer(html, disable_validation=True)
        result_html = p.transform()
        compare_html(expect_html, result_html)

    @mock.patch('premailer.premailer.warnings')
    def test_ignore_some_incorrectly(self, warnings_mock):
        """You can put `data-premailer="ignore"` but if the attribute value
        is something we don't recognize you get a warning"""

        html = """<html>
        <head>
        <title>Title</title>
        <style type="text/css" data-premailer="blah">
        h1 { color:blue; }
        </style>
        </head>
        <body>
        <h1>Hello</h1>
        <h2>World</h2>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        <title>Title</title>
        </head>
        <body>
        <h1 style="color:blue">Hello</h1>
        <h2>World</h2>
        </body>
        </html>"""

        p = Premailer(html, disable_validation=True)
        result_html = p.transform()
        warnings_mock.warn.assert_called_with(
            "Unrecognized data-premailer attribute ('blah')"
        )

        compare_html(expect_html, result_html)

    def test_ignore_some_external_stylesheets(self):
        """test that it's possible to put a `data-premailer="ignore"`
        attribute on a <link> tag and it gets left alone (except that
        the attribute gets removed)"""

        # Know thy fixtures!
        # The test-external-links.css has a `h1{color:blue}`
        # And the test-external-styles.css has a `h1{color:brown}`
        html = """<html>
        <head>
        <title>Title</title>
        <link href="premailer/tests/test-external-links.css"
         rel="stylesheet" type="text/css">
        <link data-premailer="ignore"
          href="premailer/tests/test-external-styles.css"
          rel="stylesheet" type="text/css">
        </head>
        <body>
        <h1>Hello</h1>
        </body>
        </html>"""

        # Note that the `test-external-links.css` gets converted to a inline
        # style sheet.
        expect_html = """<html>
<head>
<title>Title</title>
<style type="text/css">a:hover {color:purple}</style>
<link href="premailer/tests/test-external-styles.css" rel="style
sheet" type="text/css">
</head>
<body>
<h1 style="color:blue">Hello</h1>
</body>
</html>""".replace('style\nsheet', 'stylesheet')

        p = Premailer(html, disable_validation=True)
        result_html = p.transform()
        compare_html(expect_html, result_html)

    def test_turnoff_cache_works_as_expected(self):
        html = """<html>
        <head>
        <style>
        .color {
            color: green;
        }
        div.example {
            font-size: 10px;
        }
        </style>
        </head>
        <body>
        <div class="color example"></div>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        </head>
        <body>
        <div class="color example" style="color:green; font-size:10px"></div>
        </body>
        </html>"""

        p = Premailer(html, cache_css_parsing=False)
        self.assertFalse(p.cache_css_parsing)
        # run one time first
        p.transform()
        result_html = p.transform()

        compare_html(expect_html, result_html)

    def test_links_without_protocol(self):
        """If you the base URL is set to https://example.com and your html
        contains <img src="//otherdomain.com/">... then the URL to point to
        is "https://otherdomain.com/" not "https://example.com/file.css"
        """
        html = """<html>
        <head>
        </head>
        <body>
        <img src="//example.com">
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        </head>
        <body>
        <img src="{protocol}://example.com">
        </body>
        </html>"""

        p = Premailer(html, base_url='https://www.peterbe.com')
        result_html = p.transform()
        compare_html(expect_html.format(protocol="https"), result_html)

        p = Premailer(html, base_url='http://www.peterbe.com')
        result_html = p.transform()
        compare_html(expect_html.format(protocol="http"), result_html)

        # Because you can't set a base_url without a full protocol
        p = Premailer(html, base_url='www.peterbe.com')
        assert_raises(ValueError, p.transform)

    def test_align_float_images(self):

        html = """<html>
        <head>
        <title>Title</title>
        <style>
        .floatright {
            float: right;
        }
        </style>
        </head>
        <body>
        <p><img src="/images/left.jpg" style="float: left"> text
           <img src="/r.png" class="floatright"> text
           <img src="/images/nofloat.gif"> text
        </body>
        </html>"""

        expect_html = """<html>
<head>
<title>Title</title>
</head>
<body>
<p><img src="/images/left.jpg" style="float: left" align="left"> text
   <img src="/r.png" class="floatright" style="float:right" align="right"> text
   <img src="/images/nofloat.gif"> text
</p>
</body>
</html>"""

        p = Premailer(html, align_floating_images=True)
        result_html = p.transform()
        compare_html(expect_html, result_html)

    def test_remove_unset_properties(self):
        html = """<html>
        <head>
        <style>
        div {
            color: green;
        }
        span {
            color: blue;
        }
        span.nocolor {
            color: unset;
        }
        </style>
        </head>
        <body>
        <div class="color"><span class="nocolor"></span></div>
        </body>
        </html>"""

        expect_html = """<html>
        <head>
        </head>
        <body>
        <div class="color" style="color:green"><span class="nocolor"></span>
        </div>
        </body>
        </html>"""

        p = Premailer(html, remove_unset_properties=True)
        self.assertTrue(p.remove_unset_properties)
        result_html = p.transform()
        compare_html(expect_html, result_html)

    def test_six_color(self):
        r = Premailer.six_color('#cde')
        e = '#ccddee'
        self.assertEqual(e, r)

    def test_3_digit_color_expand(self):
        'Are 3-digit color values expanded into 6-digits for IBM Notes'
        html = """<html>
    <style>
        body {background-color: #fe5;}
        p {background-color: #123456;}
        h1 {color: #f0df0d;}
    </style>
    <body>
        <h1>color test</h1>
        <p>
            This is a test of color handling.
        </p>
    </body>
</html>"""
        expect_html = """<html>
    <head>
    </head>
    <body style="background-color:#fe5" bgcolor="#ffee55">
        <h1 style="color:#f0df0d">color test</h1>
        <p style="background-color:#123456" bgcolor="#123456">
            This is a test of color handling.
        </p>
    </body>
</html>"""
        p = Premailer(html, remove_unset_properties=True)
        result_html = p.transform()
        compare_html(expect_html, result_html)

    def test_inline_important(self):
        'Are !important tags preserved inline.'

        html = """<html>
<head>
  <title></title>
</head>
<body>
  <style type="text/css">.something { display:none !important; }</style>
  <div class="something">blah</div>
</body>
</html>"""

        expect_html = """<html>
<head>
  <title></title>
</head>
<body>
  <style type="text/css">.something { display:none !important; }</style>
  <div class="something" style="display:none !important">blah</div>
</body>
</html>"""
        p = Premailer(
            html,
            remove_classes=False,
            keep_style_tags=True,
            strip_important=False
        )
        result_html = p.transform()
        compare_html(expect_html, result_html)