and do the actual encoding in a lazy way when you call to_message.

        """

        if part:

            self.base.parts.append(part)

        elif filename:

            if not data:

                data = open(filename).read()

            self.base.attach_file(filename, data, content_type,

                                  disposition or 'attachment')

        else:

            self.base.attach_text(data, content_type)

        ctype = self.base.content_encoding['Content-Type'][0]

        if ctype and not ctype.startswith('multipart'):

            self.base.content_encoding['Content-Type'] = ('multipart/mixed', {})

    def to_message(self):

        """

        Figures out all the required steps to finally craft the

        message you need and return it.  The resulting message

        is also available as a self.base attribute.

        What is returned is a Python email API message you can

        use with those APIs.  The self.base attribute is the raw

        lamson.encoding.MailBase.

        """

        del self.base.parts[:]

        if self.Body and self.Html:

            self.multipart = True

            self.base.content_encoding['Content-Type'] = (

                'multipart/alternative', {})

        if self.multipart:

            self.base.body = None

            if self.Body:

                self.base.attach_text(self.Body, 'text/plain')

            if self.Html:

                self.base.attach_text(self.Html, 'text/html')

            for args in self.attachments:

                self._encode_attachment(**args)

        elif self.Body:

            self.base.body = self.Body

            self.base.content_encoding['Content-Type'] = ('text/plain', {})

        elif self.Html:

            self.base.body = self.Html

            self.base.content_encoding['Content-Type'] = ('text/html', {})

        return to_message(self.base, separator=self.separator)

    def all_parts(self):

        """

        Returns all the encoded parts.  Only useful for debugging

        or inspecting after calling to_message().

        """

        return self.base.parts

    def keys(self):

        return self.base.keys()

def to_message(mail, separator="; "):

    """

    Given a MailBase message, this will construct a MIMEPart

    that is canonicalized for use with the Python email API.

    """

    ctype, params = mail.content_encoding['Content-Type']

    if not ctype:

        if mail.parts:

            ctype = 'multipart/mixed'

        else:

            ctype = 'text/plain'

    else:

        if mail.parts:

            assert ctype.startswith(("multipart", "message")), \

                   "Content type should be multipart or message, not %r" % ctype

    # adjust the content type according to what it should be now

    mail.content_encoding['Content-Type'] = (ctype, params)

    try:

        out = MIMEPart(ctype, **params)

    except TypeError as exc:  # pragma: no cover

        raise EncodingError("Content-Type malformed, not allowed: %r; "

                            "%r (Python ERROR: %s" %

                            (ctype, params, exc.message))

    for k in mail.keys():

        if k in ADDRESS_HEADERS_WHITELIST:

                                         mail[k],

                                         not_email=False,

                                         separator=separator

                                     )

        else:

                                         mail[k],

                                         not_email=True

                                    )

    out.extract_payload(mail)

    # go through the children

    for part in mail.parts:

        out.attach(to_message(part))

    return out

class MIMEPart(MIMEBase):

    """

    A reimplementation of nearly everything in email.mime to be more useful

    for actually attaching things.  Rather than one class for every type of

    thing you'd encode, there's just this one, and it figures out how to

    encode what you ask it.

    """

    def __init__(self, type, **params):

        self.maintype, self.subtype = type.split('/')

        MIMEBase.__init__(self, self.maintype, self.subtype, **params)

    def add_text(self, content):

        # this is text, so encode it in canonical form

        try:

            encoded = content.encode('ascii')

            charset = 'ascii'

        except UnicodeError:

            encoded = content.encode('utf-8')

            charset = 'utf-8'

        self.set_payload(encoded, charset=charset)

    def extract_payload(self, mail):

        if mail.body is None:

            return  # only None, '' is still ok

        ctype, ctype_params = mail.content_encoding['Content-Type']

        cdisp, cdisp_params = mail.content_encoding['Content-Disposition']

        assert ctype, ("Extract payload requires that mail.content_encoding "

                       "have a valid Content-Type.")

        if ctype.startswith("text/"):

            self.add_text(mail.body)

        else:

            if cdisp:

                # replicate the content-disposition settings

                self.add_header('Content-Disposition', cdisp, **cdisp_params)

            self.set_payload(mail.body)

            encoders.encode_base64(self)

    def __repr__(self):

        return "<MIMEPart '%s/%s': %r, %r, multipart=%r>" % (

            self.subtype,

            self.maintype,

            self['Content-Type'],

            self['Content-Disposition'],

            self.is_multipart())

def header_to_mime_encoding(value, not_email=False, separator=", "):

    if not value:

        return ""

    encoder = Charset(DEFAULT_ENCODING)

    if isinstance(value, list):

        return separator.join(properly_encode_header(

            v, encoder, not_email) for v in value)

    else:

        return properly_encode_header(value, encoder, not_email)

def properly_encode_header(value, encoder, not_email):

    """

    The only thing special (weird) about this function is that it tries

    to do a fast check to see if the header value has an email address in

    it.  Since random headers could have an email address, and email addresses

    have weird special formatting rules, we have to check for it.

    Normally this works fine, but in Librelist, we need to "obfuscate" email

    addresses by changing the '@' to '-AT-'.  This is where

    VALUE_IS_EMAIL_ADDRESS exists.  It's a simple lambda returning True/False

    to check if a header value has an email address.  If you need to make this

    check different, then change this.

    """

    try:

        if not not_email and VALUE_IS_EMAIL_ADDRESS(value):

            # this could have an email address, make sure we don't screw it up

            name, address = parseaddr(value)

import mock

import kallithea

from kallithea.model.db import User

from kallithea.tests import base

class smtplib_mock(object):

    @classmethod

    def SMTP(cls, server, port, local_hostname):

        return smtplib_mock()

    def ehlo(self):

        pass

    def quit(self):

        pass

    def sendmail(self, sender, dest, msg):

        smtplib_mock.lastsender = sender

        smtplib_mock.lastdest = dest

        smtplib_mock.lastmsg = msg

        pass

@mock.patch('kallithea.lib.rcmail.smtp_mailer.smtplib', smtplib_mock)

class TestMail(base.TestController):

    def test_send_mail_trivial(self):

        mailserver = 'smtp.mailserver.org'

        recipients = ['rcpt1', 'rcpt2']

        envelope_from = 'noreply@mailserver.org'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body)

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

    def test_send_mail_no_recipients(self):

        mailserver = 'smtp.mailserver.org'

        recipients = []

        envelope_from = 'noreply@mailserver.org'

        email_to = 'admin@mailserver.org'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

            'email_to': email_to,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body)

        assert smtplib_mock.lastdest == set([base.TEST_USER_ADMIN_EMAIL, email_to])

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

    def test_send_mail_no_recipients_multiple_email_to(self):

        mailserver = 'smtp.mailserver.org'

        recipients = []

        envelope_from = 'noreply@mailserver.org'

        email_to = 'admin@mailserver.org,admin2@example.com'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

            'email_to': email_to,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body)

        assert smtplib_mock.lastdest == set([base.TEST_USER_ADMIN_EMAIL] + email_to.split(','))

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

    def test_send_mail_no_recipients_no_email_to(self):

        mailserver = 'smtp.mailserver.org'

        recipients = []

        envelope_from = 'noreply@mailserver.org'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body)

        assert smtplib_mock.lastdest == set([base.TEST_USER_ADMIN_EMAIL])

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: %s' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

    def test_send_mail_with_author(self):

        mailserver = 'smtp.mailserver.org'

        recipients = ['rcpt1', 'rcpt2']

        envelope_from = 'noreply@mailserver.org'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        author = User.get_by_username(base.TEST_USER_REGULAR_LOGIN)

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body, author=author)

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: "Kallithea Admin (no-reply)" <%s>' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

    def test_send_mail_with_author_full_mail_from(self):

        mailserver = 'smtp.mailserver.org'

        envelope_addr = 'noreply@mailserver.org'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        author = User.get_by_username(base.TEST_USER_REGULAR_LOGIN)

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body, author=author)

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert 'From: "Kallithea Admin (no-reply)" <%s>' % envelope_addr in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

    def test_send_mail_extra_headers(self):

        mailserver = 'smtp.mailserver.org'

        recipients = ['rcpt1', 'rcpt2']

        envelope_from = 'noreply@mailserver.org'

        subject = 'subject'

        body = 'body'

        html_body = 'html_body'

        author = User(name='foo', lastname=u'(fubar) "baz"')

        headers = {'extra': 'yes'}

        config_mock = {

            'smtp_server': mailserver,

            'app_email_from': envelope_from,

        }

        with mock.patch('kallithea.lib.celerylib.tasks.config', config_mock):

            kallithea.lib.celerylib.tasks.send_email(recipients, subject, body, html_body,

                                                     author=author, headers=headers)

        assert smtplib_mock.lastdest == set(recipients)

        assert smtplib_mock.lastsender == envelope_from

        assert r'From: "foo (fubar) \"baz\" (no-reply)" <%s>' % envelope_from in smtplib_mock.lastmsg

        assert 'Subject: %s' % subject in smtplib_mock.lastmsg

        assert body in smtplib_mock.lastmsg

        assert html_body in smtplib_mock.lastmsg

        assert 'Extra: yes' in smtplib_mock.lastmsg

        # verify that headers dict hasn't mutated by send_email

        assert headers == {'extra': 'yes'}