EmailTest::setUp() - Code Metrics - Inspection of "ENH Create fallback email from address" - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — 4.9 (#10236)

by Steve
created 2022-03-07 00:15 UTC
EmailTest::setUp() A

↳ Parent: EmailTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	6
rs	10
<?php

namespace SilverStripe\Control\Tests\Email;

use DateTime;
use PHPUnit_Framework_MockObject_MockObject;
use SilverStripe\Control\Director;
use SilverStripe\Control\Email\Email;
use SilverStripe\Control\Email\Mailer;
use SilverStripe\Control\Email\SwiftMailer;
use SilverStripe\Control\Tests\Email\EmailTest\EmailSubClass;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Core\Manifest\ModuleResourceLoader;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Dev\TestMailer;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\Security\Member;
use SilverStripe\View\SSViewer;
use Swift_Attachment;
use Swift_Mailer;
use Swift_Message;
use Swift_NullTransport;
use Swift_RfcComplianceException;

class EmailTest extends SapphireTest
{

    protected function setUp()
    {
        parent::setUp();
        // This is done so that the Director::host() and thus Email::getDefaultFrom()
        // have a host within a CI context
        Director::config()->set('alternate_base_url', 'http://www.mysite.com/');
    }

    public function testAddAttachment()
    {
        $email = new Email();

        $email->addAttachment(__DIR__ . '/EmailTest/attachment.txt', null, 'text/plain');

        $children = $email->getSwiftMessage()->getChildren();
        $this->assertCount(1, $children);

        /** @var Swift_Attachment $child */
        $child = reset($children);

        $this->assertInstanceOf(Swift_Attachment::class, $child);
        $this->assertEquals('text/plain', $child->getContentType());
        $this->assertEquals('attachment.txt', $child->getFilename());
    }

    public function testAddAttachmentFromData()
    {
        $email = new Email();

        $email->addAttachmentFromData('foo bar', 'foo.txt', 'text/plain');
        $children = $email->getSwiftMessage()->getChildren();

        $this->assertCount(1, $children);

        /** @var Swift_Attachment $child */
        $child = reset($children);

        $this->assertInstanceOf(Swift_Attachment::class, $child);
        $this->assertEquals('foo bar', $child->getBody());
        $this->assertEquals('text/plain', $child->getContentType());
        $this->assertEquals('foo.txt', $child->getFilename());
    }

    /**
     * @dataProvider provideValidEmailAddresses
     */
    public function testValidEmailAddress($email)
    {
        $this->assertTrue(Email::is_valid_address($email));
    }

    /**
     * @dataProvider provideInvalidEmailAddresses
     */
    public function testInvalidEmailAddress($email)
    {
        $this->assertFalse(Email::is_valid_address($email));
    }

    public function provideValidEmailAddresses()
    {
        return [
            ['[email protected]', '[email protected]'],
        ];
    }

    public function provideInvalidEmailAddresses()
    {
        return [
            ['foo.bar@', '@example.com', 'foo@'],
        ];
    }

    public function testObfuscate()
    {
        $emailAddress = '[email protected]';

        $direction = Email::obfuscate($emailAddress, 'direction');
        $visible = Email::obfuscate($emailAddress, 'visible');
        $hex = Email::obfuscate($emailAddress, 'hex');

        $this->assertEquals('<span class="codedirection">moc.elpmaxe@1-tset</span>', $direction);
        $this->assertEquals('test [dash] 1 [at] example [dot] com', $visible);
        $this->assertEquals(
            '&#x74;&#x65;&#x73;&#x74;&#x2d;&#x31;&#x40;&#x65;&#x78;&#x61;&#x6d;&#x70;&#x6c;&#x65;&#x2e;&#x63;&#x6f;&#x6d;',
            $hex
        );
    }

    public function testSendPlain()
    {
        $email = $this->makeEmailMock('Test send plain');

        // email should not call render if a body is supplied
        $email->expects($this->never())->method('renderWith');
        $successful = $email->sendPlain();

        $this->assertTrue($successful);
        $this->assertEmpty($email->getFailedRecipients());

        /** @var TestMailer $mailer */
        $mailer = Injector::inst()->get(Mailer::class);
        $sentMail = $mailer->findEmail('[email protected]');

        $this->assertTrue(is_array($sentMail));

        $this->assertEquals('[email protected]', $sentMail['To']);
        $this->assertEquals('[email protected]', $sentMail['From']);
        $this->assertEquals('Test send plain', $sentMail['Subject']);
        $this->assertEquals('Body for Test send plain', $sentMail['Content']);

        $this->assertCount(1, $sentMail['AttachedFiles']);
        $child = reset($sentMail['AttachedFiles']);
        $this->assertEquals('text/plain', $child['mimetype']);
        $this->assertEquals('attachment.txt', $child['filename']);
        $this->assertEquals('Hello, I\'m a text document.', $child['contents']);
    }

    public function testSend()
    {
        /** @var Email|PHPUnit_Framework_MockObject_MockObject $email */
        $email = $this->makeEmailMock('Test send HTML');

        // email should not call render if a body is supplied
        $email->expects($this->never())->method('renderWith');
        $successful = $email->send();

        $this->assertTrue($successful);
        $this->assertEmpty($email->getFailedRecipients());

        /** @var TestMailer $mailer */
        $mailer = Injector::inst()->get(Mailer::class);
        $sentMail = $mailer->findEmail('[email protected]');

        $this->assertTrue(is_array($sentMail));

        $this->assertEquals('[email protected]', $sentMail['To']);
        $this->assertEquals('[email protected]', $sentMail['From']);
        $this->assertEquals('Test send HTML', $sentMail['Subject']);
        $this->assertEquals('Body for Test send HTML', $sentMail['Content']);

        $this->assertCount(1, $sentMail['AttachedFiles']);
        $child = reset($sentMail['AttachedFiles']);
        $this->assertEquals('text/plain', $child['mimetype']);
        $this->assertEquals('attachment.txt', $child['filename']);
        $this->assertEquals('Hello, I\'m a text document.', $child['contents']);
    }

    public function testRenderedSend()
    {
        /** @var Email|PHPUnit_Framework_MockObject_MockObject $email */
        $email = $this->getMockBuilder(Email::class)
            ->enableProxyingToOriginalMethods()
            ->getMock();
        $email->setFrom('[email protected]');
        $email->setTo('[email protected]');
        $email->setData([
            'EmailContent' => 'test',
        ]);
        $this->assertFalse($email->hasPlainPart());
        $this->assertEmpty($email->getBody());
        // these seem to fail for some reason :/
        //$email->expects($this->once())->method('render');
        //$email->expects($this->once())->method('generatePlainPartFromBody');
        $email->send();
        $this->assertTrue($email->hasPlainPart());
        $this->assertNotEmpty($email->getBody());
    }

    public function testRenderedSendSubclass()
    {
        // Include dev theme
        SSViewer::set_themes([
            'silverstripe/framework:/tests/php/Control/Email/EmailTest',
            '$default',
        ]);

        /** @var Email|PHPUnit_Framework_MockObject_MockObject $email */
        $email = $this->getMockBuilder(EmailSubClass::class)
            ->enableProxyingToOriginalMethods()
            ->getMock();
        $email->setFrom('[email protected]');
        $email->setTo('[email protected]');
        $email->setData([
            'EmailContent' => 'test',
        ]);
        $this->assertFalse($email->hasPlainPart());
        $this->assertEmpty($email->getBody());
        $email->send();
        $this->assertTrue($email->hasPlainPart());
        $this->assertNotEmpty($email->getBody());
        $this->assertContains('<h1>Email Sub-class</h1>', $email->getBody());
    }

    public function testConsturctor()
    {
        $email = new Email(
            '[email protected]',
            '[email protected]',
            'subject',
            'body',
            '[email protected]',
            '[email protected]',
            '[email protected]'
        );

        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
        $this->assertCount(1, $email->getTo());
        $this->assertContains('[email protected]', array_keys($email->getTo()));
        $this->assertEquals('subject', $email->getSubject());
        $this->assertEquals('body', $email->getBody());
        $this->assertCount(1, $email->getCC());
        $this->assertContains('[email protected]', array_keys($email->getCC()));
        $this->assertCount(1, $email->getBCC());
        $this->assertContains('[email protected]', array_keys($email->getBCC()));
        $this->assertEquals('[email protected]', $email->getReturnPath());
    }

    public function testGetSwiftMessage()
    {
        $email = new Email(
            '[email protected]',
            '[email protected]',
            'subject',
            'body',
            '[email protected]',
            '[email protected]',
            '[email protected]'
        );
        $swiftMessage = $email->getSwiftMessage();

        $this->assertInstanceOf(Swift_Message::class, $swiftMessage);

        $this->assertCount(1, $swiftMessage->getFrom());
        $this->assertContains('[email protected]', array_keys($swiftMessage->getFrom()));
        $this->assertContains('[email protected]', array_keys(/** @scrutinizer ignore-type */ $swiftMessage->getFrom()));
        $this->assertCount(1, $swiftMessage->getTo());
        $this->assertContains('[email protected]', array_keys($swiftMessage->getTo()));
        $this->assertEquals('subject', $swiftMessage->getSubject());
        $this->assertEquals('body', $swiftMessage->getBody());
        $this->assertCount(1, $swiftMessage->getCC());
        $this->assertContains('[email protected]', array_keys($swiftMessage->getCc()));
        $this->assertCount(1, $swiftMessage->getBCC());
        $this->assertContains('[email protected]', array_keys($swiftMessage->getBcc()));
        $this->assertEquals('[email protected]', $swiftMessage->getReturnPath());
    }

    public function testSetSwiftMessage()
    {
        Email::config()->update('admin_email', '[email protected]');
        DBDatetime::set_mock_now('2017-01-01 07:00:00');
        $email = new Email();
        $swiftMessage = new Swift_Message();
        $email->setSwiftMessage($swiftMessage);
        $dateTime = new DateTime();
        $dateTime->setTimestamp(DBDatetime::now()->getTimestamp());
        $email->getSwiftMessage()->setDate($dateTime);
        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($swiftMessage->getFrom()));
        $this->assertContains('[email protected]', array_keys(/** @scrutinizer ignore-type */ $swiftMessage->getFrom()));
        $this->assertEquals(strtotime('2017-01-01 07:00:00'), $swiftMessage->getDate()->getTimestamp());
        $this->assertEquals($swiftMessage, $email->getSwiftMessage());

        // check from field is retained
        $swiftMessage = new Swift_Message();
        $swiftMessage->setFrom('[email protected]');
        $email->setSwiftMessage($swiftMessage);
        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
    }

    public function testAdminEmailApplied()
    {
        Email::config()->update('admin_email', '[email protected]');
        $email = new Email();

        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
    }

    public function testGetFrom()
    {
        $email = new Email('[email protected]');
        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
    }

    public function testSetFrom()
    {
        $email = new Email('[email protected]');
        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
        $email->setFrom('[email protected]');
        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
    }

    public function testAddFrom()
    {
        $email = new Email('[email protected]');
        $this->assertCount(1, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
        $email->addFrom('[email protected]');
        $this->assertCount(2, $email->getFrom());
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
        $this->assertContains('[email protected]', array_keys($email->getFrom()));
    }

    public function testSetGetSender()
    {
        $email = new Email();
        $this->assertEmpty($email->getSender());
        $email->setSender('[email protected]', 'Silver Stripe');
        $this->assertEquals(['[email protected]' => 'Silver Stripe'], $email->getSender());
    }

    public function testSetGetReturnPath()
    {
        $email = new Email();
        $this->assertEmpty($email->getReturnPath());
        $email->setReturnPath('[email protected]');
        $this->assertEquals('[email protected]', $email->getReturnPath());
    }

    public function testSetGetTo()
    {
        $email = new Email('[email protected]', '[email protected]');
        $this->assertCount(1, $email->getTo());
        $this->assertContains('[email protected]', array_keys($email->getTo()));
        $email->setTo('[email protected]', 'Silver Stripe');
        $this->assertEquals(['[email protected]' => 'Silver Stripe'], $email->getTo());
    }

    public function testAddTo()
    {
        $email = new Email('[email protected]', '[email protected]');
        $this->assertCount(1, $email->getTo());
        $this->assertContains('[email protected]', array_keys($email->getTo()));
        $email->addTo('[email protected]');
        $this->assertCount(2, $email->getTo());
        $this->assertContains('[email protected]', array_keys($email->getTo()));
        $this->assertContains('[email protected]', array_keys($email->getTo()));
    }

    public function testSetGetCC()
    {
        $email = new Email('[email protected]', '[email protected]', 'subject', 'body', '[email protected]');
        $this->assertCount(1, $email->getCC());
        $this->assertContains('[email protected]', array_keys($email->getCC()));
        $email->setCC('[email protected]', 'Silver Stripe');
        $this->assertEquals(['[email protected]' => 'Silver Stripe'], $email->getCC());
    }

    public function testAddCC()
    {
        $email = new Email('[email protected]', '[email protected]', 'subject', 'body', '[email protected]');
        $this->assertCount(1, $email->getCC());
        $this->assertContains('[email protected]', array_keys($email->getCC()));
        $email->addCC('[email protected]', 'Silver Stripe');
        $this->assertCount(2, $email->getCC());
        $this->assertContains('[email protected]', array_keys($email->getCC()));
        $this->assertContains('[email protected]', array_keys($email->getCC()));
    }

    public function testSetGetBCC()
    {
        $email = new Email(
            '[email protected]',
            '[email protected]',
            'subject',
            'body',
            '[email protected]',
            '[email protected]'
        );
        $this->assertCount(1, $email->getBCC());
        $this->assertContains('[email protected]', array_keys($email->getBCC()));
        $email->setBCC('[email protected]', 'Silver Stripe');
        $this->assertEquals(['[email protected]' => 'Silver Stripe'], $email->getBCC());
    }

    public function testAddBCC()
    {
        $email = new Email(
            '[email protected]',
            '[email protected]',
            'subject',
            'body',
            '[email protected]',
            '[email protected]'
        );
        $this->assertCount(1, $email->getBCC());
        $this->assertContains('[email protected]', array_keys($email->getBCC()));
        $email->addBCC('[email protected]', 'Silver Stripe');
        $this->assertCount(2, $email->getBCC());
        $this->assertContains('[email protected]', array_keys($email->getBCC()));
        $this->assertContains('[email protected]', array_keys($email->getBCC()));
    }

    public function testReplyTo()
    {
        $email = new Email();
        $this->assertEmpty($email->getReplyTo());
        $email->setReplyTo('[email protected]', 'Silver Stripe');
        $this->assertEquals(['[email protected]' => 'Silver Stripe'], $email->getReplyTo());
        $email->addReplyTo('[email protected]');
        $this->assertCount(2, $email->getReplyTo());
        $this->assertContains('[email protected]', array_keys($email->getReplyTo()));
        $this->assertContains('[email protected]', array_keys(/** @scrutinizer ignore-type */ $email->getReplyTo()));
        $this->assertContains('[email protected]', array_keys($email->getReplyTo()));
    }

    public function testSubject()
    {
        $email = new Email('[email protected]', '[email protected]', 'subject');
        $this->assertEquals('subject', $email->getSubject());
        $email->setSubject('new subject');
        $this->assertEquals('new subject', $email->getSubject());
    }

    public function testPriority()
    {
        $email = new Email();
        $this->assertEquals(3, $email->getPriority());
        $email->setPriority(5);
        $this->assertEquals(5, $email->getPriority());
    }

    public function testData()
    {
        $email = new Email();
        $this->assertEmpty($email->getData());
        $email->setData([
            'Title' => 'My Title',
        ]);
        $this->assertCount(1, $email->getData());
        $this->assertEquals(['Title' => 'My Title'], $email->getData());

        $email->addData('Content', 'My content');
        $this->assertCount(2, $email->getData());
        $this->assertEquals([
            'Title' => 'My Title',
            'Content' => 'My content',
        ], $email->getData());
        $email->removeData('Title');
        $this->assertEquals(['Content' => 'My content'], $email->getData());
    }

    public function testDataWithViewableData()
    {
        $member = new Member();
        $member->FirstName = 'First Name';
        $email = new Email();
        $this->assertEmpty($email->getData());
        $email->setData($member);
        $this->assertEquals($member, $email->getData());
        $email->addData('Test', 'Test value');
        $this->assertEquals('Test value', $email->getData()->Test);

        $email->removeData('Test');
        $this->assertNull($email->getData()->Test);
    }

    public function testBody()
    {
        $email = new Email();
        $this->assertEmpty($email->getBody());
        $email->setBody('<h1>Title</h1>');
        $this->assertEquals('<h1>Title</h1>', $email->getBody());
    }

    public function testHTMLTemplate()
    {
        // Include dev theme
        SSViewer::set_themes([
            'silverstripe/framework:/tests/php/Control/Email/EmailTest',
            '$default',
        ]);

        // Find template on disk
        $emailTemplate = ModuleResourceLoader::singleton()->resolveResource(
            'silverstripe/framework:templates/SilverStripe/Control/Email/Email.ss'
        );
        $subClassTemplate = ModuleResourceLoader::singleton()->resolveResource(
            'silverstripe/framework:tests/php/Control/Email/EmailTest/templates/'
            . str_replace('\\', '/', EmailSubClass::class)
            . '.ss'
        );
        $this->assertTrue($emailTemplate->exists());
        $this->assertTrue($subClassTemplate->exists());

        // Check template is auto-found
        $email = new Email();
        $this->assertEquals($emailTemplate->getPath(), $email->getHTMLTemplate());
        $email->setHTMLTemplate('MyTemplate');
        $this->assertEquals('MyTemplate', $email->getHTMLTemplate());

        // Check subclass template is found
        $email2 = new EmailSubClass();
        $this->assertEquals($subClassTemplate->getPath(), $email2->getHTMLTemplate());
        $email->setHTMLTemplate('MyTemplate');
        $this->assertEquals('MyTemplate', $email->getHTMLTemplate());
    }

    public function testPlainTemplate()
    {
        $email = new Email();
        $this->assertEmpty($email->getPlainTemplate());
        $email->setPlainTemplate('MyTemplate');
        $this->assertEquals('MyTemplate', $email->getPlainTemplate());
    }

    public function testGetFailedRecipients()
    {
        $mailer = new SwiftMailer();
        /** @var Swift_NullTransport|PHPUnit_Framework_MockObject_MockObject $transport */
        $transport = $this->getMockBuilder(Swift_NullTransport::class)->getMock();
        $transport->expects($this->once())
            ->method('send')
            ->willThrowException(new Swift_RfcComplianceException('Bad email'));
        $mailer->setSwiftMailer(new Swift_Mailer($transport));
        $email = new Email();
        $email->setTo('[email protected]');
        $email->setFrom('[email protected]');
        $mailer->send($email);
        $this->assertCount(1, $email->getFailedRecipients());
    }

    public function testIsEmail()
    {
        $this->assertTrue((new Email)->IsEmail());
    }

    public function testRenderAgain()
    {
        $email = new Email();
        $email->setData([
            'EmailContent' => 'my content',
        ]);
        $email->render();
        $this->assertContains('my content', $email->getBody());
        $children = $email->getSwiftMessage()->getChildren();
        $this->assertCount(1, $children);
        $plainPart = reset($children);
        $this->assertEquals('my content', $plainPart->getBody());

        // ensure repeat renders don't add multiple plain parts
        $email->render();
        $this->assertCount(1, $email->getSwiftMessage()->getChildren());
    }

    public function testRerender()
    {
        $email = new Email();
        $email->setData([
            'EmailContent' => 'my content',
        ]);
        $email->render();
        $this->assertContains('my content', $email->getBody());
        $children = $email->getSwiftMessage()->getChildren();
        $this->assertCount(1, $children);
        $plainPart = reset($children);
        $this->assertEquals('my content', $plainPart->getBody());

        // Ensure setting data causes a rerender
        $email->setData([
            'EmailContent' => 'your content'
        ]);
        $email->render();
        $this->assertContains('your content', $email->getBody());

        // Ensure removing data causes a rerender
        $email->removeData('EmailContent');
        $email->render();
        $this->assertNotContains('your content', $email->getBody());

        // Ensure adding data causes a rerender
        $email->addData([
            'EmailContent' => 'their content'
        ]);
        $email->render();
        $this->assertContains('their content', $email->getBody());
    }

    public function testRenderPlainOnly()
    {
        $email = new Email();
        $email->setData([
            'EmailContent' => 'test content',
        ]);
        $email->render(true);
        $this->assertEquals('text/plain', $email->getSwiftMessage()->getContentType());
        $this->assertEmpty($email->getSwiftMessage()->getChildren());
    }

    public function testHasPlainPart()
    {
        $email = new Email();
        $email->setData([
            'EmailContent' => 'test',
        ]);
        //emails are assumed to be HTML by default
        $this->assertFalse($email->hasPlainPart());
        //make sure plain attachments aren't picked up as a plain part
        $email->addAttachmentFromData('data', 'attachent.txt', 'text/plain');
        $this->assertFalse($email->hasPlainPart());
        $email->getSwiftMessage()->addPart('plain', 'text/plain');
        $this->assertTrue($email->hasPlainPart());
    }

    public function testGeneratePlainPartFromBody()
    {
        $email = new Email();
        $email->setBody('<h1>Test</h1>');
        $this->assertEmpty($email->getSwiftMessage()->getChildren());
        $email->generatePlainPartFromBody();
        $children = $email->getSwiftMessage()->getChildren();
        $this->assertCount(1, $children);
        $plainPart = reset($children);
        $this->assertContains('Test', $plainPart->getBody());
        $this->assertNotContains('<h1>Test</h1>', $plainPart->getBody());
    }

    public function testMultipleEmailSends()
    {
        $email = new Email();
        $email->setData([
            'EmailContent' => 'Test',
        ]);
        $this->assertEmpty($email->getBody());
        $this->assertEmpty($email->getSwiftMessage()->getChildren());
        $email->send();
        $this->assertContains('Test', $email->getBody());
        $this->assertCount(1, $email->getSwiftMessage()->getChildren());
        $children = $email->getSwiftMessage()->getChildren();
        /** @var \Swift_MimePart $plainPart */
        $plainPart = reset($children);
        $this->assertContains('Test', $plainPart->getBody());


        //send again
        $email->send();
        $this->assertContains('Test', $email->getBody());
        $this->assertCount(1, $email->getSwiftMessage()->getChildren());
        $children = $email->getSwiftMessage()->getChildren();
        /** @var \Swift_MimePart $plainPart */
        $plainPart = reset($children);
        $this->assertContains('Test', $plainPart->getBody());
    }

    public function testGetDefaultFrom()
    {
        $email = new Email();
        $class = new \ReflectionClass(Email::class);
        $method = $class->getMethod('getDefaultFrom');
        $method->setAccessible(true);

        // default to [email protected] if admin_email config not set
        $host = parse_url(Director::host(), PHP_URL_HOST) ?: 'example.com';
        $expected = sprintf('no-reply@%s', $host);
        $this->assertSame($expected, $method->invokeArgs($email, []));

        // use admin_email config
        Email::config()->set('admin_email', '[email protected]');
        $this->assertSame('[email protected]', $method->invokeArgs($email, []));
    }

    /**
     * @return PHPUnit_Framework_MockObject_MockObject|Email
     */
    protected function makeEmailMock($subject)
    {
        /** @var Email|PHPUnit_Framework_MockObject_MockObject $email */
        $email = $this->getMockBuilder(Email::class)
            ->enableProxyingToOriginalMethods()
            ->getMock();

        $email->setFrom('[email protected]');
        $email->setTo('[email protected]');
        $email->setSubject($subject);
        $email->setBody("Body for {$subject}");
        $email->setCC('[email protected]');
        $email->setBCC('[email protected]');
        $email->addAttachment(__DIR__ . '/EmailTest/attachment.txt', null, 'text/plain');
        return $email;
    }
}

silverstripe / silverstripe-framework

Pull Request — 4.9 (#10236)

EmailTest::setUp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
