# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Test cases for twisted.mail.smtp module.
"""


import base64
import inspect
import re
from io import BytesIO
from typing import Any, List, Optional, Tuple, Type

from zope.interface import directlyProvides, implementer

import twisted.cred.checkers
import twisted.cred.credentials
import twisted.cred.error
import twisted.cred.portal
from twisted import cred
from twisted.cred.checkers import AllowAnonymousAccess, ICredentialsChecker
from twisted.cred.credentials import IAnonymous
from twisted.cred.error import UnauthorizedLogin
from twisted.cred.portal import IRealm, Portal
from twisted.internet import address, defer, error, interfaces, protocol, reactor, task
from twisted.internet.testing import MemoryReactor, StringTransport
from twisted.mail import smtp
from twisted.mail._cred import LOGINCredentials
from twisted.protocols import basic, loopback
from twisted.python.util import LineLog
from twisted.trial.unittest import TestCase

sslSkip: Optional[str]
try:
    from twisted.test.ssl_helpers import ClientTLSContext, ServerTLSContext
except ImportError:
    sslSkip = "OpenSSL not present"
else:
    sslSkip = None


if not interfaces.IReactorSSL.providedBy(reactor):
    sslSkip = "Reactor doesn't support SSL"


def spameater(*spam, **eggs):
    return None


@implementer(smtp.IMessage)
class BrokenMessage:
    """
    L{BrokenMessage} is an L{IMessage} which raises an unexpected exception
    from its C{eomReceived} method.  This is useful for creating a server which
    can be used to test client retry behavior.
    """

    def __init__(self, user):
        pass

    def lineReceived(self, line):
        pass

    def eomReceived(self):
        raise RuntimeError("Some problem, delivery is failing.")

    def connectionLost(self):
        pass


class DummyMessage:
    """
    L{BrokenMessage} is an L{IMessage} which saves the message delivered to it
    to its domain object.

    @ivar domain: A L{DummyDomain} which will be used to store the message once
        it is received.
    """

    def __init__(self, domain, user):
        self.domain = domain
        self.user = user
        self.buffer = []

    def lineReceived(self, line):
        # Throw away the generated Received: header
        if not re.match(rb"Received: From yyy.com \(\[.*\]\) by localhost;", line):
            self.buffer.append(line)

    def eomReceived(self):
        message = b"\n".join(self.buffer) + b"\n"
        self.domain.messages[self.user.dest.local].append(message)
        deferred = defer.Deferred()
        deferred.callback(b"saved")
        return deferred


class DummyDomain:
    """
    L{DummyDomain} is an L{IDomain} which keeps track of messages delivered to
    it in memory.
    """

    def __init__(self, names):
        self.messages = {}
        for name in names:
            self.messages[name] = []

    def exists(self, user):
        if user.dest.local in self.messages:
            return defer.succeed(lambda: DummyMessage(self, user))
        return defer.fail(smtp.SMTPBadRcpt(user))


mail = b"""\
Subject: hello

Goodbye
"""


class MyClient:
    def __init__(self, messageInfo=None):
        if messageInfo is None:
            messageInfo = ("moshez@foo.bar", ["moshez@foo.bar"], BytesIO(mail))
        self._sender = messageInfo[0]
        self._recipient = messageInfo[1]
        self._data = messageInfo[2]

    def getMailFrom(self):
        return self._sender

    def getMailTo(self):
        return self._recipient

    def getMailData(self):
        return self._data

    def sendError(self, exc):
        self._error = exc

    def sentMail(self, code, resp, numOk, addresses, log):
        # Prevent another mail from being sent.
        self._sender = None
        self._recipient = None
        self._data = None


class MySMTPClient(MyClient, smtp.SMTPClient):
    def __init__(self, messageInfo=None):
        smtp.SMTPClient.__init__(self, b"foo.baz")
        MyClient.__init__(self, messageInfo)


class MyESMTPClient(MyClient, smtp.ESMTPClient):
    def __init__(self, secret=b"", contextFactory=None):
        smtp.ESMTPClient.__init__(self, secret, contextFactory, b"foo.baz")
        MyClient.__init__(self)


class LoopbackMixin:
    def loopback(self, server, client):
        return loopback.loopbackTCP(server, client)


class FakeSMTPServer(basic.LineReceiver):
    clientData = [
        b"220 hello",
        b"250 nice to meet you",
        b"250 great",
        b"250 great",
        b"354 go on, lad",
    ]

    def connectionMade(self):
        self.buffer = []
        self.clientData = self.clientData[:]
        self.clientData.reverse()
        self.sendLine(self.clientData.pop())

    def lineReceived(self, line):
        self.buffer.append(line)
        if line == b"QUIT":
            self.transport.write(b"221 see ya around\r\n")
            self.transport.loseConnection()
        elif line == b".":
            self.transport.write(b"250 gotcha\r\n")
        elif line == b"RSET":
            self.transport.loseConnection()

        if self.clientData:
            self.sendLine(self.clientData.pop())


class SMTPClientTests(TestCase, LoopbackMixin):
    """
    Tests for L{smtp.SMTPClient}.
    """

    def test_timeoutConnection(self):
        """
        L{smtp.SMTPClient.timeoutConnection} calls the C{sendError} hook with a
        fatal L{SMTPTimeoutError} with the current line log.
        """
        errors = []
        client = MySMTPClient()
        client.sendError = errors.append
        client.makeConnection(StringTransport())
        client.lineReceived(b"220 hello")
        client.timeoutConnection()
        self.assertIsInstance(errors[0], smtp.SMTPTimeoutError)
        self.assertTrue(errors[0].isFatal)
        self.assertEqual(
            bytes(errors[0]),
            b"Timeout waiting for SMTP server response\n"
            b"<<< 220 hello\n"
            b">>> HELO foo.baz\n",
        )

    expected_output = [
        b"HELO foo.baz",
        b"MAIL FROM:<moshez@foo.bar>",
        b"RCPT TO:<moshez@foo.bar>",
        b"DATA",
        b"Subject: hello",
        b"",
        b"Goodbye",
        b".",
        b"RSET",
    ]

    def test_messages(self):
        """
        L{smtp.SMTPClient} sends I{HELO}, I{MAIL FROM}, I{RCPT TO}, and I{DATA}
        commands based on the return values of its C{getMailFrom},
        C{getMailTo}, and C{getMailData} methods.
        """
        client = MySMTPClient()
        server = FakeSMTPServer()
        d = self.loopback(server, client)
        d.addCallback(lambda x: self.assertEqual(server.buffer, self.expected_output))
        return d

    def test_transferError(self):
        """
        If there is an error while producing the message body to the
        connection, the C{sendError} callback is invoked.
        """
        client = MySMTPClient(
            ("alice@example.com", ["bob@example.com"], BytesIO(b"foo"))
        )
        transport = StringTransport()
        client.makeConnection(transport)
        client.dataReceived(
            b"220 Ok\r\n"  # Greeting
            b"250 Ok\r\n"  # EHLO response
            b"250 Ok\r\n"  # MAIL FROM response
            b"250 Ok\r\n"  # RCPT TO response
            b"354 Ok\r\n"  # DATA response
        )

        # Sanity check - a pull producer should be registered now.
        self.assertNotIdentical(transport.producer, None)
        self.assertFalse(transport.streaming)

        # Now stop the producer prematurely, meaning the message was not sent.
        transport.producer.stopProducing()

        # The sendError hook should have been invoked as a result.
        self.assertIsInstance(client._error, Exception)

    def test_sendFatalError(self):
        """
        If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError}
        which is fatal, it disconnects its transport without writing anything
        more to it.
        """
        client = smtp.SMTPClient(None)
        transport = StringTransport()
        client.makeConnection(transport)
        client.sendError(smtp.SMTPClientError(123, "foo", isFatal=True))
        self.assertEqual(transport.value(), b"")
        self.assertTrue(transport.disconnecting)

    def test_sendNonFatalError(self):
        """
        If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError}
        which is not fatal, it sends C{"QUIT"} and waits for the server to
        close the connection.
        """
        client = smtp.SMTPClient(None)
        transport = StringTransport()
        client.makeConnection(transport)
        client.sendError(smtp.SMTPClientError(123, "foo", isFatal=False))
        self.assertEqual(transport.value(), b"QUIT\r\n")
        self.assertFalse(transport.disconnecting)

    def test_sendOtherError(self):
        """
        If L{smtp.SMTPClient.sendError} is called with an exception which is
        not an L{SMTPClientError}, it disconnects its transport without
        writing anything more to it.
        """
        client = smtp.SMTPClient(None)
        transport = StringTransport()
        client.makeConnection(transport)
        client.sendError(Exception("foo"))
        self.assertEqual(transport.value(), b"")
        self.assertTrue(transport.disconnecting)


class DummySMTPMessage:
    def __init__(self, protocol, users):
        self.protocol = protocol
        self.users = users
        self.buffer = []

    def lineReceived(self, line):
        self.buffer.append(line)

    def eomReceived(self):
        message = b"\n".join(self.buffer) + b"\n"
        helo, origin = self.users[0].helo[0], bytes(self.users[0].orig)
        recipients = []
        for user in self.users:
            recipients.append(bytes(user))
        self.protocol.message[tuple(recipients)] = (helo, origin, recipients, message)
        return defer.succeed(b"saved")


class DummyProto:
    def connectionMade(self):
        self.dummyMixinBase.connectionMade(self)
        self.message = {}

    def receivedHeader(*spam):
        return None

    def validateTo(self, user):
        self.delivery = SimpleDelivery(None)
        return lambda: DummySMTPMessage(self, [user])

    def validateFrom(self, helo, origin):
        return origin


class DummySMTP(DummyProto, smtp.SMTP):
    dummyMixinBase = smtp.SMTP


class DummyESMTP(DummyProto, smtp.ESMTP):
    dummyMixinBase = smtp.ESMTP


class AnotherTestCase:
    serverClass: Optional[Type[protocol.Protocol]] = None
    clientClass: Optional[Type[smtp.SMTPClient]] = None

    messages = [
        (
            b"foo.com",
            b"moshez@foo.com",
            [b"moshez@bar.com"],
            b"moshez@foo.com",
            [b"moshez@bar.com"],
            b"""\
From: Moshe
To: Moshe

Hi,
how are you?
""",
        ),
        (
            b"foo.com",
            b"tttt@rrr.com",
            [b"uuu@ooo", b"yyy@eee"],
            b"tttt@rrr.com",
            [b"uuu@ooo", b"yyy@eee"],
            b"""\
Subject: pass

..rrrr..
""",
        ),
        (
            b"foo.com",
            b"@this,@is,@ignored:foo@bar.com",
            [b"@ignore,@this,@too:bar@foo.com"],
            b"foo@bar.com",
            [b"bar@foo.com"],
            b"""\
Subject: apa
To: foo

123
.
456
""",
        ),
    ]

    data: List[Tuple[bytes, bytes, Any, Any]] = [
        (b"", b"220.*\r\n$", None, None),
        (b"HELO foo.com\r\n", b"250.*\r\n$", None, None),
        (b"RSET\r\n", b"250.*\r\n$", None, None),
    ]
    for helo_, from_, to_, realfrom, realto, msg in messages:
        data.append((b"MAIL FROM:<" + from_ + b">\r\n", b"250.*\r\n", None, None))
        for rcpt in to_:
            data.append((b"RCPT TO:<" + rcpt + b">\r\n", b"250.*\r\n", None, None))

        data.append(
            (
                b"DATA\r\n",
                b"354.*\r\n",
                msg,
                (b"250.*\r\n", (helo_, realfrom, realto, msg)),
            )
        )

    def test_buffer(self):
        """
        Exercise a lot of the SMTP client code.  This is a "shotgun" style unit
        test.  It does a lot of things and hopes that something will go really
        wrong if it is going to go wrong.  This test should be replaced with a
        suite of nicer tests.
        """
        transport = StringTransport()
        a = self.serverClass()

        class fooFactory:
            domain = b"foo.com"

        a.factory = fooFactory()
        a.makeConnection(transport)
        for send, expect, msg, msgexpect in self.data:
            if send:
                a.dataReceived(send)
            data = transport.value()
            transport.clear()
            if not re.match(expect, data):
                raise AssertionError(send, expect, data)
            if data[:3] == b"354":
                for line in msg.splitlines():
                    if line and line[0:1] == b".":
                        line = b"." + line
                    a.dataReceived(line + b"\r\n")
                a.dataReceived(b".\r\n")
                # Special case for DATA. Now we want a 250, and then
                # we compare the messages
                data = transport.value()
                transport.clear()
                resp, msgdata = msgexpect
                if not re.match(resp, data):
                    raise AssertionError(resp, data)
                for recip in msgdata[2]:
                    expected = list(msgdata[:])
                    expected[2] = [recip]
                    self.assertEqual(a.message[(recip,)], tuple(expected))
        a.setTimeout(None)


class AnotherESMTPTests(AnotherTestCase, TestCase):
    serverClass = DummyESMTP
    clientClass = MyESMTPClient


class AnotherSMTPTests(AnotherTestCase, TestCase):
    serverClass = DummySMTP
    clientClass = MySMTPClient


@implementer(cred.checkers.ICredentialsChecker)
class DummyChecker:
    users = {b"testuser": b"testpassword"}

    credentialInterfaces = (
        cred.credentials.IUsernamePassword,
        cred.credentials.IUsernameHashedPassword,
    )

    def requestAvatarId(self, credentials):
        return defer.maybeDeferred(
            credentials.checkPassword, self.users[credentials.username]
        ).addCallback(self._cbCheck, credentials.username)

    def _cbCheck(self, result, username):
        if result:
            return username
        raise cred.error.UnauthorizedLogin()


@implementer(smtp.IMessageDelivery)
class SimpleDelivery:
    """
    L{SimpleDelivery} is a message delivery factory with no interesting
    behavior.
    """

    def __init__(self, messageFactory):
        self._messageFactory = messageFactory

    def receivedHeader(self, helo, origin, recipients):
        return None

    def validateFrom(self, helo, origin):
        return origin

    def validateTo(self, user):
        return lambda: self._messageFactory(user)


class DummyRealm:
    def requestAvatar(self, avatarId, mind, *interfaces):
        return smtp.IMessageDelivery, SimpleDelivery(None), lambda: None


class AuthTests(TestCase, LoopbackMixin):
    def test_crammd5Auth(self):
        """
        L{ESMTPClient} can authenticate using the I{CRAM-MD5} SASL mechanism.

        @see: U{http://tools.ietf.org/html/rfc2195}
        """
        realm = DummyRealm()
        p = cred.portal.Portal(realm)
        p.registerChecker(DummyChecker())

        server = DummyESMTP({b"CRAM-MD5": cred.credentials.CramMD5Credentials})
        server.portal = p
        client = MyESMTPClient(b"testpassword")

        cAuth = smtp.CramMD5ClientAuthenticator(b"testuser")
        client.registerAuthenticator(cAuth)

        d = self.loopback(server, client)
        d.addCallback(lambda x: self.assertEqual(server.authenticated, 1))
        return d

    def test_loginAuth(self):
        """
        L{ESMTPClient} can authenticate using the I{LOGIN} SASL mechanism.

        @see: U{http://sepp.oetiker.ch/sasl-2.1.19-ds/draft-murchison-sasl-login-00.txt}
        """
        realm = DummyRealm()
        p = cred.portal.Portal(realm)
        p.registerChecker(DummyChecker())

        server = DummyESMTP({b"LOGIN": LOGINCredentials})
        server.portal = p
        client = MyESMTPClient(b"testpassword")

        cAuth = smtp.LOGINAuthenticator(b"testuser")
        client.registerAuthenticator(cAuth)

        d = self.loopback(server, client)
        d.addCallback(lambda x: self.assertTrue(server.authenticated))
        return d

    def test_loginAgainstWeirdServer(self):
        """
        When communicating with a server which implements the I{LOGIN} SASL
        mechanism using C{"Username:"} as the challenge (rather than C{"User
        Name\\0"}), L{ESMTPClient} can still authenticate successfully using
        the I{LOGIN} mechanism.
        """
        realm = DummyRealm()
        p = cred.portal.Portal(realm)
        p.registerChecker(DummyChecker())

        server = DummyESMTP({b"LOGIN": smtp.LOGINCredentials})
        server.portal = p

        client = MyESMTPClient(b"testpassword")
        cAuth = smtp.LOGINAuthenticator(b"testuser")
        client.registerAuthenticator(cAuth)

        d = self.loopback(server, client)
        d.addCallback(lambda x: self.assertTrue(server.authenticated))
        return d


class SMTPHelperTests(TestCase):
    def testMessageID(self):
        d = {}
        for i in range(1000):
            m = smtp.messageid("testcase")
            self.assertFalse(m in d)
            d[m] = None

    def testQuoteAddr(self):
        cases = [
            [b"user@host.name", b"<user@host.name>"],
            [b'"User Name" <user@host.name>', b"<user@host.name>"],
            [smtp.Address(b"someguy@someplace"), b"<someguy@someplace>"],
            [b"", b"<>"],
            [smtp.Address(b""), b"<>"],
        ]

        for c, e in cases:
            self.assertEqual(smtp.quoteaddr(c), e)

    def testUser(self):
        u = smtp.User(b"user@host", b"helo.host.name", None, None)
        self.assertEqual(str(u), "user@host")

    def testXtextEncoding(self):
        cases = [
            ("Hello world", b"Hello+20world"),
            ("Hello+world", b"Hello+2Bworld"),
            ("\0\1\2\3\4\5", b"+00+01+02+03+04+05"),
            ("e=mc2@example.com", b"e+3Dmc2@example.com"),
        ]

        for case, expected in cases:
            self.assertEqual(smtp.xtext_encode(case), (expected, len(case)))
            self.assertEqual(case.encode("xtext"), expected)
            self.assertEqual(smtp.xtext_decode(expected), (case, len(expected)))
            self.assertEqual(expected.decode("xtext"), case)

    def test_encodeWithErrors(self):
        """
        Specifying an error policy to C{unicode.encode} with the
        I{xtext} codec should produce the same result as not
        specifying the error policy.
        """
        text = "Hello world"
        self.assertEqual(
            smtp.xtext_encode(text, "strict"), (text.encode("xtext"), len(text))
        )
        self.assertEqual(text.encode("xtext", "strict"), text.encode("xtext"))

    def test_decodeWithErrors(self):
        """
        Similar to L{test_encodeWithErrors}, but for C{bytes.decode}.
        """
        bytes = b"Hello world"
        self.assertEqual(
            smtp.xtext_decode(bytes, "strict"), (bytes.decode("xtext"), len(bytes))
        )
        self.assertEqual(bytes.decode("xtext", "strict"), bytes.decode("xtext"))


class NoticeTLSClient(MyESMTPClient):
    tls = False

    def esmtpState_starttls(self, code, resp):
        MyESMTPClient.esmtpState_starttls(self, code, resp)
        self.tls = True


class TLSTests(TestCase, LoopbackMixin):
    skip = sslSkip

    def testTLS(self):
        clientCTX = ClientTLSContext()
        serverCTX = ServerTLSContext()

        client = NoticeTLSClient(contextFactory=clientCTX)
        server = DummyESMTP(contextFactory=serverCTX)

        def check(ignored):
            self.assertEqual(client.tls, True)
            self.assertEqual(server.startedTLS, True)

        return self.loopback(server, client).addCallback(check)


class EmptyLineTests(TestCase):
    def test_emptyLineSyntaxError(self):
        """
        If L{smtp.SMTP} receives an empty line, it responds with a 500 error
        response code and a message about a syntax error.
        """
        proto = smtp.SMTP()
        transport = StringTransport()
        proto.makeConnection(transport)
        proto.lineReceived(b"")
        proto.setTimeout(None)

        out = transport.value().splitlines()
        self.assertEqual(len(out), 2)
        self.assertTrue(out[0].startswith(b"220"))
        self.assertEqual(out[1], b"500 Error: bad syntax")


class TimeoutTests(TestCase, LoopbackMixin):
    """
    Check that SMTP client factories correctly use the timeout.
    """

    def _timeoutTest(self, onDone, clientFactory):
        """
        Connect the clientFactory, and check the timeout on the request.
        """
        clock = task.Clock()
        client = clientFactory.buildProtocol(
            address.IPv4Address("TCP", "example.net", 25)
        )
        client.callLater = clock.callLater
        t = StringTransport()
        client.makeConnection(t)
        t.protocol = client

        def check(ign):
            self.assertEqual(clock.seconds(), 0.5)

        d = self.assertFailure(onDone, smtp.SMTPTimeoutError).addCallback(check)
        # The first call should not trigger the timeout
        clock.advance(0.1)
        # But this one should
        clock.advance(0.4)
        return d

    def test_SMTPClientRecipientBytes(self):
        """
        Test timeout for L{smtp.SMTPSenderFactory}: the response L{Deferred}
        should be errback with a L{smtp.SMTPTimeoutError}.
        """
        onDone = defer.Deferred()
        clientFactory = smtp.SMTPSenderFactory(
            "source@address",
            b"recipient@address",
            BytesIO(b"Message body"),
            onDone,
            retries=0,
            timeout=0.5,
        )
        return self._timeoutTest(onDone, clientFactory)

    def test_SMTPClientRecipientUnicode(self):
        """
        Use a L{unicode} recipient.
        """
        onDone = defer.Deferred()
        clientFactory = smtp.SMTPSenderFactory(
            "source@address",
            "recipient@address",
            BytesIO(b"Message body"),
            onDone,
            retries=0,
            timeout=0.5,
        )
        return self._timeoutTest(onDone, clientFactory)

    def test_SMTPClientRecipientList(self):
        """
        Use a L{list} of recipients.
        """
        onDone = defer.Deferred()
        clientFactory = smtp.SMTPSenderFactory(
            "source@address",
            ("recipient1@address", b"recipient2@address"),
            BytesIO(b"Message body"),
            onDone,
            retries=0,
            timeout=0.5,
        )
        return self._timeoutTest(onDone, clientFactory)

    def test_ESMTPClient(self):
        """
        Test timeout for L{smtp.ESMTPSenderFactory}: the response L{Deferred}
        should be errback with a L{smtp.SMTPTimeoutError}.
        """
        onDone = defer.Deferred()
        clientFactory = smtp.ESMTPSenderFactory(
            "username",
            "password",
            "source@address",
            "recipient@address",
            BytesIO(b"Message body"),
            onDone,
            retries=0,
            timeout=0.5,
        )
        return self._timeoutTest(onDone, clientFactory)

    def test_resetTimeoutWhileSending(self):
        """
        The timeout is not allowed to expire after the server has accepted a
        DATA command and the client is actively sending data to it.
        """

        class SlowFile:
            """
            A file-like which returns one byte from each read call until the
            specified number of bytes have been returned.
            """

            def __init__(self, size):
                self._size = size

            def read(self, max=None):
                if self._size:
                    self._size -= 1
                    return b"x"
                return b""

        failed = []
        onDone = defer.Deferred()
        onDone.addErrback(failed.append)
        clientFactory = smtp.SMTPSenderFactory(
            "source@address",
            "recipient@address",
            SlowFile(1),
            onDone,
            retries=0,
            timeout=3,
        )
        clientFactory.domain = b"example.org"
        clock = task.Clock()
        client = clientFactory.buildProtocol(
            address.IPv4Address("TCP", "example.net", 25)
        )
        client.callLater = clock.callLater
        transport = StringTransport()
        client.makeConnection(transport)

        client.dataReceived(
            b"220 Ok\r\n"  # Greet the client
            b"250 Ok\r\n"  # Respond to HELO
            b"250 Ok\r\n"  # Respond to MAIL FROM
            b"250 Ok\r\n"  # Respond to RCPT TO
            b"354 Ok\r\n"  # Respond to DATA
        )

        # Now the client is producing data to the server.  Any time
        # resumeProducing is called on the producer, the timeout should be
        # extended.  First, a sanity check.  This test is only written to
        # handle pull producers.
        self.assertNotIdentical(transport.producer, None)
        self.assertFalse(transport.streaming)

        # Now, allow 2 seconds (1 less than the timeout of 3 seconds) to
        # elapse.
        clock.advance(2)

        # The timeout has not expired, so the failure should not have happened.
        self.assertEqual(failed, [])

        # Let some bytes be produced, extending the timeout.  Then advance the
        # clock some more and verify that the timeout still hasn't happened.
        transport.producer.resumeProducing()
        clock.advance(2)
        self.assertEqual(failed, [])

        # The file has been completely produced - the next resume producing
        # finishes the upload, successfully.
        transport.producer.resumeProducing()
        client.dataReceived(b"250 Ok\r\n")
        self.assertEqual(failed, [])

        # Verify that the client actually did send the things expected.
        self.assertEqual(
            transport.value(),
            b"HELO example.org\r\n"
            b"MAIL FROM:<source@address>\r\n"
            b"RCPT TO:<recipient@address>\r\n"
            b"DATA\r\n"
            b"x\r\n"
            b".\r\n"
            # This RSET is just an implementation detail.  It's nice, but this
            # test doesn't really care about it.
            b"RSET\r\n",
        )


class MultipleDeliveryFactorySMTPServerFactory(protocol.ServerFactory):
    """
    L{MultipleDeliveryFactorySMTPServerFactory} creates SMTP server protocol
    instances with message delivery factory objects supplied to it.  Each
    factory is used for one connection and then discarded.  Factories are used
    in the order they are supplied.
    """

    def __init__(self, messageFactories):
        self._messageFactories = messageFactories

    def buildProtocol(self, addr):
        p = protocol.ServerFactory.buildProtocol(self, addr)
        p.delivery = SimpleDelivery(self._messageFactories.pop(0))
        return p


class SMTPSenderFactoryTests(TestCase):
    """
    Tests for L{smtp.SMTPSenderFactory}.
    """

    def test_removeCurrentProtocolWhenClientConnectionLost(self):
        """
        L{smtp.SMTPSenderFactory} removes the current protocol when the client
        connection is lost.
        """
        reactor = MemoryReactor()
        sentDeferred = defer.Deferred()
        clientFactory = smtp.SMTPSenderFactory(
            "source@address", "recipient@address", BytesIO(b"message"), sentDeferred
        )
        connector = reactor.connectTCP("localhost", 25, clientFactory)
        clientFactory.buildProtocol(None)
        clientFactory.clientConnectionLost(connector, error.ConnectionDone("Bye."))
        self.assertEqual(clientFactory.currentProtocol, None)

    def test_removeCurrentProtocolWhenClientConnectionFailed(self):
        """
        L{smtp.SMTPSenderFactory} removes the current protocol when the client
        connection is failed.
        """
        reactor = MemoryReactor()
        sentDeferred = defer.Deferred()
        clientFactory = smtp.SMTPSenderFactory(
            "source@address", "recipient@address", BytesIO(b"message"), sentDeferred
        )
        connector = reactor.connectTCP("localhost", 25, clientFactory)
        clientFactory.buildProtocol(None)
        clientFactory.clientConnectionFailed(connector, error.ConnectionDone("Bye."))
        self.assertEqual(clientFactory.currentProtocol, None)


class SMTPSenderFactoryRetryTests(TestCase):
    """
    Tests for the retry behavior of L{smtp.SMTPSenderFactory}.
    """

    def test_retryAfterDisconnect(self):
        """
        If the protocol created by L{SMTPSenderFactory} loses its connection
        before receiving confirmation of message delivery, it reconnects and
        tries to deliver the message again.
        """
        recipient = b"alice"
        message = b"some message text"
        domain = DummyDomain([recipient])

        class CleanSMTP(smtp.SMTP):
            """
            An SMTP subclass which ensures that its transport will be
            disconnected before the test ends.
            """

            def makeConnection(innerSelf, transport):
                self.addCleanup(transport.loseConnection)
                smtp.SMTP.makeConnection(innerSelf, transport)

        # Create a server which will fail the first message deliver attempt to
        # it with a 500 and a disconnect, but which will accept a message
        # delivered over the 2nd connection to it.
        serverFactory = MultipleDeliveryFactorySMTPServerFactory(
            [BrokenMessage, lambda user: DummyMessage(domain, user)]
        )
        serverFactory.protocol = CleanSMTP
        serverPort = reactor.listenTCP(0, serverFactory, interface="127.0.0.1")
        serverHost = serverPort.getHost()
        self.addCleanup(serverPort.stopListening)

        # Set up a client to try to deliver a message to the above created
        # server.
        sentDeferred = defer.Deferred()
        clientFactory = smtp.SMTPSenderFactory(
            b"bob@example.org",
            recipient + b"@example.com",
            BytesIO(message),
            sentDeferred,
        )
        clientFactory.domain = b"example.org"
        clientConnector = reactor.connectTCP(
            serverHost.host, serverHost.port, clientFactory
        )
        self.addCleanup(clientConnector.disconnect)

        def cbSent(ignored):
            """
            Verify that the message was successfully delivered and flush the
            error which caused the first attempt to fail.
            """
            self.assertEqual(domain.messages, {recipient: [b"\n" + message + b"\n"]})
            # Flush the RuntimeError that BrokenMessage caused to be logged.
            self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)

        sentDeferred.addCallback(cbSent)
        return sentDeferred


@implementer(IRealm)
class SingletonRealm:
    """
    Trivial realm implementation which is constructed with an interface and an
    avatar and returns that avatar when asked for that interface.
    """

    def __init__(self, interface, avatar):
        self.interface = interface
        self.avatar = avatar

    def requestAvatar(self, avatarId, mind, *interfaces):
        for iface in interfaces:
            if iface is self.interface:
                return iface, self.avatar, lambda: None


class NotImplementedDelivery:
    """
    Non-implementation of L{smtp.IMessageDelivery} which only has methods which
    raise L{NotImplementedError}.  Subclassed by various tests to provide the
    particular behavior being tested.
    """

    def validateFrom(self, helo, origin):
        raise NotImplementedError("This oughtn't be called in the course of this test.")

    def validateTo(self, user):
        raise NotImplementedError("This oughtn't be called in the course of this test.")

    def receivedHeader(self, helo, origin, recipients):
        raise NotImplementedError("This oughtn't be called in the course of this test.")


class SMTPServerTests(TestCase):
    """
    Test various behaviors of L{twisted.mail.smtp.SMTP} and
    L{twisted.mail.smtp.ESMTP}.
    """

    def testSMTPGreetingHost(self, serverClass=smtp.SMTP):
        """
        Test that the specified hostname shows up in the SMTP server's
        greeting.
        """
        s = serverClass()
        s.host = b"example.com"
        t = StringTransport()
        s.makeConnection(t)
        s.connectionLost(error.ConnectionDone())
        self.assertIn(b"example.com", t.value())

    def testSMTPGreetingNotExtended(self):
        """
        Test that the string "ESMTP" does not appear in the SMTP server's
        greeting since that string strongly suggests the presence of support
        for various SMTP extensions which are not supported by L{smtp.SMTP}.
        """
        s = smtp.SMTP()
        t = StringTransport()
        s.makeConnection(t)
        s.connectionLost(error.ConnectionDone())
        self.assertNotIn(b"ESMTP", t.value())

    def testESMTPGreetingHost(self):
        """
        Similar to testSMTPGreetingHost, but for the L{smtp.ESMTP} class.
        """
        self.testSMTPGreetingHost(smtp.ESMTP)

    def testESMTPGreetingExtended(self):
        """
        Test that the string "ESMTP" does appear in the ESMTP server's
        greeting since L{smtp.ESMTP} does support the SMTP extensions which
        that advertises to the client.
        """
        s = smtp.ESMTP()
        t = StringTransport()
        s.makeConnection(t)
        s.connectionLost(error.ConnectionDone())
        self.assertIn(b"ESMTP", t.value())

    def test_SMTPUnknownCommand(self):
        """
        Sending an unimplemented command is responded to with a 500.
        """
        s = smtp.SMTP()
        t = StringTransport()
        s.makeConnection(t)
        s.lineReceived(b"DOAGOODTHING")
        s.connectionLost(error.ConnectionDone())
        self.assertIn(b"500 Command not implemented", t.value())

    def test_acceptSenderAddress(self):
        """
        Test that a C{MAIL FROM} command with an acceptable address is
        responded to with the correct success code.
        """

        class AcceptanceDelivery(NotImplementedDelivery):
            """
            Delivery object which accepts all senders as valid.
            """

            def validateFrom(self, helo, origin):
                return origin

        realm = SingletonRealm(smtp.IMessageDelivery, AcceptanceDelivery())
        portal = Portal(realm, [AllowAnonymousAccess()])
        proto = smtp.SMTP()
        proto.portal = portal
        trans = StringTransport()
        proto.makeConnection(trans)

        # Deal with the necessary preliminaries
        proto.dataReceived(b"HELO example.com\r\n")
        trans.clear()

        # Try to specify our sender address
        proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")

        # Clean up the protocol before doing anything that might raise an
        # exception.
        proto.connectionLost(error.ConnectionLost())

        # Make sure that we received exactly the correct response
        self.assertEqual(trans.value(), b"250 Sender address accepted\r\n")

    def test_deliveryRejectedSenderAddress(self):
        """
        Test that a C{MAIL FROM} command with an address rejected by a
        L{smtp.IMessageDelivery} instance is responded to with the correct
        error code.
        """

        class RejectionDelivery(NotImplementedDelivery):
            """
            Delivery object which rejects all senders as invalid.
            """

            def validateFrom(self, helo, origin):
                raise smtp.SMTPBadSender(origin)

        realm = SingletonRealm(smtp.IMessageDelivery, RejectionDelivery())
        portal = Portal(realm, [AllowAnonymousAccess()])
        proto = smtp.SMTP()
        proto.portal = portal
        trans = StringTransport()
        proto.makeConnection(trans)

        # Deal with the necessary preliminaries
        proto.dataReceived(b"HELO example.com\r\n")
        trans.clear()

        # Try to specify our sender address
        proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")

        # Clean up the protocol before doing anything that might raise an
        # exception.
        proto.connectionLost(error.ConnectionLost())

        # Make sure that we received exactly the correct response
        self.assertEqual(
            trans.value(),
            b"550 Cannot receive from specified address "
            b"<alice@example.com>: Sender not acceptable\r\n",
        )

    @implementer(ICredentialsChecker)
    def test_portalRejectedSenderAddress(self):
        """
        Test that a C{MAIL FROM} command with an address rejected by an
        L{smtp.SMTP} instance's portal is responded to with the correct error
        code.
        """

        class DisallowAnonymousAccess:
            """
            Checker for L{IAnonymous} which rejects authentication attempts.
            """

            credentialInterfaces = (IAnonymous,)

            def requestAvatarId(self, credentials):
                return defer.fail(UnauthorizedLogin())

        realm = SingletonRealm(smtp.IMessageDelivery, NotImplementedDelivery())
        portal = Portal(realm, [DisallowAnonymousAccess()])
        proto = smtp.SMTP()
        proto.portal = portal
        trans = StringTransport()
        proto.makeConnection(trans)

        # Deal with the necessary preliminaries
        proto.dataReceived(b"HELO example.com\r\n")
        trans.clear()

        # Try to specify our sender address
        proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")

        # Clean up the protocol before doing anything that might raise an
        # exception.
        proto.connectionLost(error.ConnectionLost())

        # Make sure that we received exactly the correct response
        self.assertEqual(
            trans.value(),
            b"550 Cannot receive from specified address "
            b"<alice@example.com>: Sender not acceptable\r\n",
        )

    def test_portalRejectedAnonymousSender(self):
        """
        Test that a C{MAIL FROM} command issued without first authenticating
        when a portal has been configured to disallow anonymous logins is
        responded to with the correct error code.
        """
        realm = SingletonRealm(smtp.IMessageDelivery, NotImplementedDelivery())
        portal = Portal(realm, [])
        proto = smtp.SMTP()
        proto.portal = portal
        trans = StringTransport()
        proto.makeConnection(trans)

        # Deal with the necessary preliminaries
        proto.dataReceived(b"HELO example.com\r\n")
        trans.clear()

        # Try to specify our sender address
        proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n")

        # Clean up the protocol before doing anything that might raise an
        # exception.
        proto.connectionLost(error.ConnectionLost())

        # Make sure that we received exactly the correct response
        self.assertEqual(
            trans.value(),
            b"550 Cannot receive from specified address "
            b"<alice@example.com>: Unauthenticated senders not allowed\r\n",
        )


class ESMTPAuthenticationTests(TestCase):
    def assertServerResponse(self, bytes, response):
        """
        Assert that when the given bytes are delivered to the ESMTP server
        instance, it responds with the indicated lines.

        @type bytes: str
        @type response: list of str
        """
        self.transport.clear()
        self.server.dataReceived(bytes)
        self.assertEqual(response, self.transport.value().splitlines())

    def assertServerAuthenticated(
        self, loginArgs, username=b"username", password=b"password"
    ):
        """
        Assert that a login attempt has been made, that the credentials and
        interfaces passed to it are correct, and that when the login request
        is satisfied, a successful response is sent by the ESMTP server
        instance.

        @param loginArgs: A C{list} previously passed to L{portalFactory}.
        @param username: The login user.
        @param password: The login password.
        """
        d, credentials, mind, interfaces = loginArgs.pop()
        self.assertEqual(loginArgs, [])
        self.assertTrue(
            twisted.cred.credentials.IUsernamePassword.providedBy(credentials)
        )
        self.assertEqual(credentials.username, username)
        self.assertTrue(credentials.checkPassword(password))
        self.assertIn(smtp.IMessageDeliveryFactory, interfaces)
        self.assertIn(smtp.IMessageDelivery, interfaces)
        d.callback((smtp.IMessageDeliveryFactory, None, lambda: None))

        self.assertEqual(
            [b"235 Authentication successful."], self.transport.value().splitlines()
        )

    def setUp(self):
        """
        Create an ESMTP instance attached to a StringTransport.
        """
        self.server = smtp.ESMTP({b"LOGIN": LOGINCredentials})
        self.server.host = b"localhost"
        self.transport = StringTransport(
            peerAddress=address.IPv4Address("TCP", "127.0.0.1", 12345)
        )
        self.server.makeConnection(self.transport)

    def tearDown(self):
        """
        Disconnect the ESMTP instance to clean up its timeout DelayedCall.
        """
        self.server.connectionLost(error.ConnectionDone())

    def portalFactory(self, loginList):
        class DummyPortal:
            def login(self, credentials, mind, *interfaces):
                d = defer.Deferred()
                loginList.append((d, credentials, mind, interfaces))
                return d

        return DummyPortal()

    def test_authenticationCapabilityAdvertised(self):
        """
        Test that AUTH is advertised to clients which issue an EHLO command.
        """
        self.transport.clear()
        self.server.dataReceived(b"EHLO\r\n")
        responseLines = self.transport.value().splitlines()
        self.assertEqual(
            responseLines[0], b"250-localhost Hello 127.0.0.1, nice to meet you"
        )
        self.assertEqual(responseLines[1], b"250 AUTH LOGIN")
        self.assertEqual(len(responseLines), 2)

    def test_plainAuthentication(self):
        """
        Test that the LOGIN authentication mechanism can be used
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.transport.clear()

        self.assertServerResponse(
            b"AUTH LOGIN\r\n", [b"334 " + base64.b64encode(b"User Name\0").strip()]
        )

        self.assertServerResponse(
            base64.b64encode(b"username") + b"\r\n",
            [b"334 " + base64.b64encode(b"Password\0").strip()],
        )

        self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", [])

        self.assertServerAuthenticated(loginArgs)

    def test_plainAuthenticationEmptyPassword(self):
        """
        Test that giving an empty password for plain auth succeeds.
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.transport.clear()

        self.assertServerResponse(
            b"AUTH LOGIN\r\n", [b"334 " + base64.b64encode(b"User Name\0").strip()]
        )

        self.assertServerResponse(
            base64.b64encode(b"username") + b"\r\n",
            [b"334 " + base64.b64encode(b"Password\0").strip()],
        )

        self.assertServerResponse(b"\r\n", [])
        self.assertServerAuthenticated(loginArgs, password=b"")

    def test_plainAuthenticationInitialResponse(self):
        """
        The response to the first challenge may be included on the AUTH command
        line.  Test that this is also supported.
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.transport.clear()

        self.assertServerResponse(
            b"AUTH LOGIN " + base64.b64encode(b"username").strip() + b"\r\n",
            [b"334 " + base64.b64encode(b"Password\0").strip()],
        )

        self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", [])

        self.assertServerAuthenticated(loginArgs)

    def test_abortAuthentication(self):
        """
        Test that a challenge/response sequence can be aborted by the client.
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.server.dataReceived(b"AUTH LOGIN\r\n")

        self.assertServerResponse(b"*\r\n", [b"501 Authentication aborted"])

    def test_invalidBase64EncodedResponse(self):
        """
        Test that a response which is not properly Base64 encoded results in
        the appropriate error code.
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.server.dataReceived(b"AUTH LOGIN\r\n")

        self.assertServerResponse(
            b"x\r\n", [b"501 Syntax error in parameters or arguments"]
        )

        self.assertEqual(loginArgs, [])

    def test_invalidBase64EncodedInitialResponse(self):
        """
        Like L{test_invalidBase64EncodedResponse} but for the case of an
        initial response included with the C{AUTH} command.
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.assertServerResponse(
            b"AUTH LOGIN x\r\n", [b"501 Syntax error in parameters or arguments"]
        )

        self.assertEqual(loginArgs, [])

    def test_unexpectedLoginFailure(self):
        """
        If the L{Deferred} returned by L{Portal.login} fires with an
        exception of any type other than L{UnauthorizedLogin}, the exception
        is logged and the client is informed that the authentication attempt
        has failed.
        """
        loginArgs = []
        self.server.portal = self.portalFactory(loginArgs)

        self.server.dataReceived(b"EHLO\r\n")
        self.transport.clear()

        self.assertServerResponse(
            b"AUTH LOGIN " + base64.b64encode(b"username").strip() + b"\r\n",
            [b"334 " + base64.b64encode(b"Password\0").strip()],
        )
        self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", [])

        d, credentials, mind, interfaces = loginArgs.pop()
        d.errback(RuntimeError("Something wrong with the server"))

        self.assertEqual(
            b"451 Requested action aborted: local error in processing\r\n",
            self.transport.value(),
        )

        self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)


class SMTPClientErrorTests(TestCase):
    """
    Tests for L{smtp.SMTPClientError}.
    """

    def test_str(self):
        """
        The string representation of a L{SMTPClientError} instance includes
        the response code and response string.
        """
        err = smtp.SMTPClientError(123, "some text")
        self.assertEqual(str(err), "123 some text")

    def test_strWithNegativeCode(self):
        """
        If the response code supplied to L{SMTPClientError} is negative, it
        is excluded from the string representation.
        """
        err = smtp.SMTPClientError(-1, b"foo bar")
        self.assertEqual(str(err), "foo bar")

    def test_strWithLog(self):
        """
        If a line log is supplied to L{SMTPClientError}, its contents are
        included in the string representation of the exception instance.
        """
        log = LineLog(10)
        log.append(b"testlog")
        log.append(b"secondline")
        err = smtp.SMTPClientError(100, "test error", log=log.str())
        self.assertEqual(str(err), "100 test error\n" "testlog\n" "secondline\n")


class SenderMixinSentMailTests(TestCase):
    """
    Tests for L{smtp.SenderMixin.sentMail}, used in particular by
    L{smtp.SMTPSenderFactory} and L{smtp.ESMTPSenderFactory}.
    """

    def test_onlyLogFailedAddresses(self):
        """
        L{smtp.SenderMixin.sentMail} adds only the addresses with failing
        SMTP response codes to the log passed to the factory's errback.
        """
        onDone = self.assertFailure(defer.Deferred(), smtp.SMTPDeliveryError)
        onDone.addCallback(
            lambda e: self.assertEqual(
                e.log, b"bob@example.com: 199 Error in sending.\n"
            )
        )

        clientFactory = smtp.SMTPSenderFactory(
            "source@address",
            "recipient@address",
            BytesIO(b"Message body"),
            onDone,
            retries=0,
            timeout=0.5,
        )

        client = clientFactory.buildProtocol(
            address.IPv4Address("TCP", "example.net", 25)
        )

        addresses = [
            (b"alice@example.com", 200, b"No errors here!"),
            (b"bob@example.com", 199, b"Error in sending."),
        ]
        client.sentMail(199, b"Test response", 1, addresses, client.log)

        return onDone


class ESMTPDowngradeTestCase(TestCase):
    """
    Tests for the ESMTP -> SMTP downgrade functionality in L{smtp.ESMTPClient}.
    """

    def setUp(self):
        self.clientProtocol = smtp.ESMTPClient(b"testpassword", None, b"testuser")

    def test_requireHELOFallbackOperates(self):
        """
        If both authentication and transport security are not required, and it
        is asked for, it will fall back to allowing HELO.
        """
        transport = StringTransport()
        self.clientProtocol.requireAuthentication = False
        self.clientProtocol.requireTransportSecurity = False
        self.clientProtocol.heloFallback = True
        self.clientProtocol.makeConnection(transport)

        self.clientProtocol.dataReceived(b"220 localhost\r\n")
        transport.clear()
        self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
        self.assertEqual(b"HELO testuser\r\n", transport.value())

    def test_requireAuthFailsHELOFallback(self):
        """
        If authentication is required, and HELO fallback is on, HELO fallback
        must not be honoured, as authentication requires EHLO to succeed.
        """
        transport = StringTransport()
        self.clientProtocol.requireAuthentication = True
        self.clientProtocol.requireTransportSecurity = False
        self.clientProtocol.heloFallback = True
        self.clientProtocol.makeConnection(transport)

        self.clientProtocol.dataReceived(b"220 localhost\r\n")
        transport.clear()
        self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
        self.assertEqual(b"QUIT\r\n", transport.value())

    def test_requireTLSFailsHELOFallback(self):
        """
        If TLS is required and the connection is insecure, HELO fallback must
        not be honoured, as STARTTLS requires EHLO to succeed.
        """
        transport = StringTransport()
        self.clientProtocol.requireAuthentication = False
        self.clientProtocol.requireTransportSecurity = True
        self.clientProtocol.heloFallback = True
        self.clientProtocol.makeConnection(transport)

        self.clientProtocol.dataReceived(b"220 localhost\r\n")
        transport.clear()
        self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
        self.assertEqual(b"QUIT\r\n", transport.value())

    def test_requireTLSAndHELOFallbackSucceedsIfOverTLS(self):
        """
        If TLS is provided at the transport level, we can honour the HELO
        fallback if we're set to require TLS.
        """
        transport = StringTransport()
        directlyProvides(transport, interfaces.ISSLTransport)
        self.clientProtocol.requireAuthentication = False
        self.clientProtocol.requireTransportSecurity = True
        self.clientProtocol.heloFallback = True
        self.clientProtocol.makeConnection(transport)

        self.clientProtocol.dataReceived(b"220 localhost\r\n")
        transport.clear()
        self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n")
        self.assertEqual(b"HELO testuser\r\n", transport.value())


class SSLTestCase(TestCase):
    """
    Tests for the TLS negotiation done by L{smtp.ESMTPClient}.
    """

    skip = sslSkip

    SERVER_GREETING = b"220 localhost NO UCE NO UBE NO RELAY PROBES ESMTP\r\n"
    EHLO_RESPONSE = b"250-localhost Hello 127.0.0.1, nice to meet you\r\n"

    def setUp(self):
        self.clientProtocol = smtp.ESMTPClient(
            b"testpassword", ClientTLSContext(), b"testuser"
        )
        self.clientProtocol.requireTransportSecurity = True
        self.clientProtocol.getMailFrom = lambda: "test@example.org"

    def _requireTransportSecurityOverSSLTest(self, capabilities):
        """
        Verify that when L{smtp.ESMTPClient} connects to a server over a
        transport providing L{ISSLTransport}, C{requireTransportSecurity} is
        C{True}, and it is presented with the given capabilities, it will try
        to send its mail and not first attempt to negotiate TLS using the
        I{STARTTLS} protocol action.

        @param capabilities: Bytes to include in the test server's capability
            response.  These must be formatted exactly as required by the
            protocol, including a line which ends the capability response.
        @type param: L{bytes}

        @raise: C{self.failureException} if the behavior of
            C{self.clientProtocol} is not as described.
        """
        transport = StringTransport()
        directlyProvides(transport, interfaces.ISSLTransport)
        self.clientProtocol.makeConnection(transport)

        # Get the handshake out of the way
        self.clientProtocol.dataReceived(self.SERVER_GREETING)
        transport.clear()

        # Tell the client about the server's capabilities
        self.clientProtocol.dataReceived(self.EHLO_RESPONSE + capabilities)

        # The client should now try to send a message - without first trying to
        # negotiate TLS, since the transport is already secure.
        self.assertEqual(b"MAIL FROM:<test@example.org>\r\n", transport.value())

    def test_requireTransportSecurityOverSSL(self):
        """
        When C{requireTransportSecurity} is C{True} and the client is connected
        over an SSL transport, mail may be delivered.
        """
        self._requireTransportSecurityOverSSLTest(b"250 AUTH LOGIN\r\n")

    def test_requireTransportSecurityTLSOffered(self):
        """
        When C{requireTransportSecurity} is C{True} and the client is connected
        over a non-SSL transport, if the server offers the I{STARTTLS}
        extension, it is used before mail is delivered.
        """
        transport = StringTransport()
        self.clientProtocol.makeConnection(transport)

        # Get the handshake out of the way
        self.clientProtocol.dataReceived(self.SERVER_GREETING)
        transport.clear()

        # Tell the client about the server's capabilities - including STARTTLS
        self.clientProtocol.dataReceived(
            self.EHLO_RESPONSE + b"250-AUTH LOGIN\r\n" b"250 STARTTLS\r\n"
        )

        # The client should try to start TLS before sending the message.
        self.assertEqual(b"STARTTLS\r\n", transport.value())

    def test_requireTransportSecurityTLSOfferedOverSSL(self):
        """
        When C{requireTransportSecurity} is C{True} and the client is connected
        over an SSL transport, if the server offers the I{STARTTLS}
        extension, it is not used before mail is delivered.
        """
        self._requireTransportSecurityOverSSLTest(
            b"250-AUTH LOGIN\r\n" b"250 STARTTLS\r\n"
        )

    def test_requireTransportSecurityTLSNotOffered(self):
        """
        When C{requireTransportSecurity} is C{True} and the client is connected
        over a non-SSL transport, if the server does not offer the I{STARTTLS}
        extension, mail is not delivered.
        """
        transport = StringTransport()
        self.clientProtocol.makeConnection(transport)

        # Get the handshake out of the way
        self.clientProtocol.dataReceived(self.SERVER_GREETING)
        transport.clear()

        # Tell the client about the server's capabilities - excluding STARTTLS
        self.clientProtocol.dataReceived(self.EHLO_RESPONSE + b"250 AUTH LOGIN\r\n")

        # The client give up
        self.assertEqual(b"QUIT\r\n", transport.value())

    def test_esmtpClientTlsModeDeprecationGet(self):
        """
        L{smtp.ESMTPClient.tlsMode} is deprecated.
        """
        val = self.clientProtocol.tlsMode
        del val
        warningsShown = self.flushWarnings(
            offendingFunctions=[self.test_esmtpClientTlsModeDeprecationGet]
        )
        self.assertEqual(len(warningsShown), 1)
        self.assertIdentical(warningsShown[0]["category"], DeprecationWarning)
        self.assertEqual(
            warningsShown[0]["message"],
            "tlsMode attribute of twisted.mail.smtp.ESMTPClient "
            "is deprecated since Twisted 13.0",
        )

    def test_esmtpClientTlsModeDeprecationGetAttributeError(self):
        """
        L{smtp.ESMTPClient.__getattr__} raises an attribute error for other
        attribute names which do not exist.
        """
        self.assertRaises(AttributeError, lambda: self.clientProtocol.doesNotExist)

    def test_esmtpClientTlsModeDeprecationSet(self):
        """
        L{smtp.ESMTPClient.tlsMode} is deprecated.
        """
        self.clientProtocol.tlsMode = False
        warningsShown = self.flushWarnings(
            offendingFunctions=[self.test_esmtpClientTlsModeDeprecationSet]
        )
        self.assertEqual(len(warningsShown), 1)
        self.assertIdentical(warningsShown[0]["category"], DeprecationWarning)
        self.assertEqual(
            warningsShown[0]["message"],
            "tlsMode attribute of twisted.mail.smtp.ESMTPClient "
            "is deprecated since Twisted 13.0",
        )


class AbortableStringTransport(StringTransport):
    """
    A version of L{StringTransport} that supports C{abortConnection}.
    """

    # This should be replaced by a common version in #6530.
    aborting = False

    def abortConnection(self):
        """
        A testable version of the C{ITCPTransport.abortConnection} method.

        Since this is a special case of closing the connection,
        C{loseConnection} is also called.
        """
        self.aborting = True
        self.loseConnection()


class SendmailTests(TestCase):
    """
    Tests for L{twisted.mail.smtp.sendmail}.
    """

    def test_defaultReactorIsGlobalReactor(self):
        """
        The default C{reactor} parameter of L{twisted.mail.smtp.sendmail} is
        L{twisted.internet.reactor}.
        """
        fullSpec = inspect.getfullargspec(smtp.sendmail)
        defaults = fullSpec[3]
        self.assertEqual(reactor, defaults[2])

    def _honorsESMTPArguments(self, username, password):
        """
        L{twisted.mail.smtp.sendmail} creates the ESMTP factory with the ESMTP
        arguments.
        """
        reactor = MemoryReactor()
        smtp.sendmail(
            "localhost",
            "source@address",
            "recipient@address",
            b"message",
            reactor=reactor,
            username=username,
            password=password,
            requireTransportSecurity=True,
            requireAuthentication=True,
        )
        factory = reactor.tcpClients[0][2]
        self.assertEqual(factory._requireTransportSecurity, True)
        self.assertEqual(factory._requireAuthentication, True)
        self.assertEqual(factory.username, b"foo")
        self.assertEqual(factory.password, b"bar")

    def test_honorsESMTPArgumentsUnicodeUserPW(self):
        """
        L{twisted.mail.smtp.sendmail} should accept C{username} and C{password}
        which are L{unicode}.
        """
        return self._honorsESMTPArguments(username="foo", password="bar")

    def test_honorsESMTPArgumentsBytesUserPW(self):
        """
        L{twisted.mail.smtp.sendmail} should accept C{username} and C{password}
        which are L{bytes}.
        """
        return self._honorsESMTPArguments(username=b"foo", password=b"bar")

    def test_messageFilePassthrough(self):
        """
        L{twisted.mail.smtp.sendmail} will pass through the message untouched
        if it is a file-like object.
        """
        reactor = MemoryReactor()
        messageFile = BytesIO(b"File!")

        smtp.sendmail(
            "localhost",
            "source@address",
            "recipient@address",
            messageFile,
            reactor=reactor,
        )
        factory = reactor.tcpClients[0][2]
        self.assertIs(factory.file, messageFile)

    def test_messageStringMadeFile(self):
        """
        L{twisted.mail.smtp.sendmail} will turn non-file-like objects
        (eg. strings) into file-like objects before sending.
        """
        reactor = MemoryReactor()
        smtp.sendmail(
            "localhost",
            "source@address",
            "recipient@address",
            b"message",
            reactor=reactor,
        )
        factory = reactor.tcpClients[0][2]
        messageFile = factory.file
        messageFile.seek(0)
        self.assertEqual(messageFile.read(), b"message")

    def test_senderDomainName(self):
        """
        L{twisted.mail.smtp.sendmail} passes through the sender domain name, if
        provided.
        """
        reactor = MemoryReactor()
        smtp.sendmail(
            "localhost",
            "source@address",
            "recipient@address",
            b"message",
            reactor=reactor,
            senderDomainName="foo",
        )
        factory = reactor.tcpClients[0][2]
        self.assertEqual(factory.domain, b"foo")

    def test_cancelBeforeConnectionMade(self):
        """
        When a user cancels L{twisted.mail.smtp.sendmail} before the connection
        is made, the connection is closed by
        L{twisted.internet.interfaces.IConnector.disconnect}.
        """
        reactor = MemoryReactor()
        d = smtp.sendmail(
            "localhost",
            "source@address",
            "recipient@address",
            b"message",
            reactor=reactor,
        )
        d.cancel()
        self.assertEqual(reactor.connectors[0]._disconnected, True)
        failure = self.failureResultOf(d)
        failure.trap(defer.CancelledError)

    def test_cancelAfterConnectionMade(self):
        """
        When a user cancels L{twisted.mail.smtp.sendmail} after the connection
        is made, the connection is closed by
        L{twisted.internet.interfaces.ITransport.abortConnection}.
        """
        reactor = MemoryReactor()
        transport = AbortableStringTransport()
        d = smtp.sendmail(
            "localhost",
            "source@address",
            "recipient@address",
            b"message",
            reactor=reactor,
        )
        factory = reactor.tcpClients[0][2]
        p = factory.buildProtocol(None)
        p.makeConnection(transport)
        d.cancel()
        self.assertEqual(transport.aborting, True)
        self.assertEqual(transport.disconnecting, True)
        failure = self.failureResultOf(d)
        failure.trap(defer.CancelledError)
