mirror/PHPMailer
0
0
Fork 0
mirror of https://github.com/PHPMailer/PHPMailer.git synced 2024-09-20 01:52:15 +02:00
Code

Merge pull request #2450 from jrfnl/feature/tests-reorganize-33

Browse Source 
Tests: move (get|set|clear)ReplyTo tests to own file
This commit is contained in:
Marcus Bointon 2021-07-12 22:35:14 +02:00 committed by GitHub
commit 7cc67dd1dc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 452 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
test/PHPMailer/MailTransportTest.php
View File

@ -81,16 +81,10 @@ final class MailTransportTest extends SendTestCase
$this->setAddress('testmailsend@example.com', 'totest');
$this->setAddress('cctestmailsend@example.com', 'cctest', $sType = 'cc');
$this->setAddress('bcctestmailsend@example.com', 'bcctest', $sType = 'bcc');
$this->setAddress('replytotestmailsend@example.com', 'replytotest', $sType = 'ReplyTo');
self::assertContains('testmailsend@example.com', $this->Mail->getToAddresses()[0], 'To address not found');
self::assertContains('cctestmailsend@example.com', $this->Mail->getCcAddresses()[0], 'CC address not found');
self::assertContains('bcctestmailsend@example.com', $this->Mail->getBccAddresses()[0], 'BCC address not found');
self::assertContains(
'replytotestmailsend@example.com',
$this->Mail->getReplyToAddresses()['replytotestmailsend@example.com'],
'Replyto address not found'
);
self::assertTrue(
$this->Mail->getAllRecipientAddresses()['testmailsend@example.com'],

36
test/PHPMailer/PHPMailerTest.php
View File

@ -32,7 +32,6 @@ final class PHPMailerTest extends SendTestCase
$this->Mail->Body = 'Here is the main body. There should be ' .
'a reply to address in this message.';
$this->Mail->Subject .= ': Low Priority';
$this->Mail->addReplyTo('nobody@nobody.com', 'Nobody (Unit Test)');
$this->buildBody();
self::assertTrue($this->Mail->send(), $this->Mail->ErrorInfo);
@ -753,11 +752,8 @@ EOT;
self::assertTrue($this->Mail->addBCC('c@example.com'), 'BCC addressing failed');
self::assertFalse($this->Mail->addBCC('c@example.com'), 'BCC duplicate addressing failed');
self::assertFalse($this->Mail->addBCC('a@example.com'), 'BCC duplicate addressing failed (2)');
self::assertTrue($this->Mail->addReplyTo('a@example.com'), 'Replyto Addressing failed');
self::assertFalse($this->Mail->addReplyTo('a@example..com'), 'Invalid Replyto address accepted');
$this->Mail->clearCCs();
$this->Mail->clearBCCs();
$this->Mail->clearReplyTos();
}
/**
@ -1109,7 +1105,6 @@ EOT;
}
$this->Mail->clearAllRecipients();
$this->Mail->clearReplyTos();
//This file is UTF-8 encoded. Create a domain encoded in "iso-8859-1".
$letter = html_entity_decode('ç', ENT_COMPAT, PHPMailer::CHARSET_ISO88591);
@ -1117,13 +1112,11 @@ EOT;
$this->Mail->addAddress('test' . $domain);
$this->Mail->addCC('test+cc' . $domain);
$this->Mail->addBCC('test+bcc' . $domain);
$this->Mail->addReplyTo('test+replyto' . $domain);
//Queued addresses are not returned by get*Addresses() before send() call.
self::assertEmpty($this->Mail->getToAddresses(), 'Bad "to" recipients');
self::assertEmpty($this->Mail->getCcAddresses(), 'Bad "cc" recipients');
self::assertEmpty($this->Mail->getBccAddresses(), 'Bad "bcc" recipients');
self::assertEmpty($this->Mail->getReplyToAddresses(), 'Bad "reply-to" recipients');
//Clear queued BCC recipient.
$this->Mail->clearBCCs();
@ -1144,11 +1137,6 @@ EOT;
'Bad "cc" recipients'
);
self::assertEmpty($this->Mail->getBccAddresses(), 'Bad "bcc" recipients');
self::assertSame(
['test+replyto' . $domain => ['test+replyto' . $domain, '']],
$this->Mail->getReplyToAddresses(),
'Bad "reply-to" addresses'
);
}
/**
@ -1161,7 +1149,6 @@ EOT;
}
$this->Mail->clearAllRecipients();
$this->Mail->clearReplyTos();
$this->Mail->CharSet = PHPMailer::CHARSET_UTF8;
@ -1173,14 +1160,6 @@ EOT;
self::assertFalse($this->Mail->addAddress('test@xn--franois-xxa.ch'));
self::assertFalse($this->Mail->addAddress('test@XN--FRANOIS-XXA.CH'));
self::assertTrue($this->Mail->addReplyTo('test+replyto@françois.ch'));
self::assertFalse($this->Mail->addReplyTo('test+replyto@françois.ch'));
self::assertTrue($this->Mail->addReplyTo('test+replyto@FRANÇOIS.CH'));
self::assertFalse($this->Mail->addReplyTo('test+replyto@FRANÇOIS.CH'));
self::assertTrue($this->Mail->addReplyTo('test+replyto@xn--franois-xxa.ch'));
self::assertFalse($this->Mail->addReplyTo('test+replyto@xn--franois-xxa.ch'));
self::assertFalse($this->Mail->addReplyTo('test+replyto@XN--FRANOIS-XXA.CH'));
$this->buildBody();
self::assertTrue($this->Mail->send(), $this->Mail->ErrorInfo);
@ -1190,11 +1169,6 @@ EOT;
$this->Mail->getToAddresses(),
'Bad count of "to" recipients'
);
self::assertCount(
1,
$this->Mail->getReplyToAddresses(),
'Bad count of "reply-to" addresses'
);
}
/**
@ -1247,16 +1221,6 @@ EOT;
$this->assertTrue($this->Mail->addAddress('test@françois.ch'));
}
public function testGivenIdnAddress_addReplyTo_returns_true()
{
if (file_exists(\PHPMAILER_INCLUDE_DIR . '/test/fakefunctions.php') === false) {
$this->markTestSkipped('/test/fakefunctions.php file not found');
}
include \PHPMAILER_INCLUDE_DIR . '/test/fakefunctions.php';
$this->assertTrue($this->Mail->addReplyTo('test@françois.ch'));
}
public function testErroneousAddress_addAddress_returns_false()
{
$this->assertFalse($this->Mail->addAddress('mehome.com'));

452
test/PHPMailer/ReplyToGetSetClearTest.php Normal file
View File

@ -0,0 +1,452 @@
<?php
/**
* PHPMailer - PHP email transport unit tests.
* PHP version 5.5.
*
* @author Marcus Bointon <phpmailer@synchromedia.co.uk>
* @author Andy Prevost
* @copyright 2012 - 2020 Marcus Bointon
* @copyright 2004 - 2009 Andy Prevost
* @license http://www.gnu.org/copyleft/lesser.html GNU Lesser General Public License
*/
namespace PHPMailer\Test\PHPMailer;
use PHPMailer\PHPMailer\Exception;
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\Test\PreSendTestCase;
/**
* Test reply-to address setting, getting and clearing functionality.
*/
final class ReplyToGetSetClearTest extends PreSendTestCase
{
/**
* Test adding a non-IDN reply-to address.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addReplyTo
* @covers \PHPMailer\PHPMailer\PHPMailer::addOrEnqueueAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::addAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::getReplyToAddresses
*
* @dataProvider dataAddReplyToValidAddressNonIdn
*
* @param string $address The email address to set.
* @param string $name Optional. The name to set.
* @param string $expected Optional. The email address and name as they are expected to be set.
* Only needs to be passed if different than the original inputs.
*/
public function testAddReplyToValidAddressNonIdn($address, $name = null, $expected = null)
{
if (isset($name)) {
$result = $this->Mail->addReplyTo($address, $name);
} else {
$result = $this->Mail->addReplyTo($address);
$name = '';
}
if (isset($expected) === false) {
$expected = [
'key' => $address,
'address' => $address,
'name' => $name,
];
}
// Test the setting is successful.
self::assertTrue($result, 'Replyto Addressing failed');
// Verify that the address was correctly added to the array.
$retrieved = $this->Mail->getReplyToAddresses();
self::assertIsArray($retrieved, 'ReplyTo property is not an array');
self::assertCount(1, $retrieved, 'ReplyTo property does not contain exactly one address');
$key = $expected['key'];
self::assertArrayHasKey(
$key,
$retrieved,
'ReplyTo property does not contain an entry with this address as the key'
);
self::assertCount(
2,
$retrieved[$key],
'ReplyTo array for this address does not contain exactly two array items'
);
self::assertSame(
$expected['address'],
$retrieved[$key][0],
'ReplyTo array for this address does not contain added address'
);
self::assertSame(
$expected['name'],
$retrieved[$key][1],
'ReplyTo array for this address does not contain added name'
);
}
/**
* Data provider.
*
* @return array
*/
public function dataAddReplyToValidAddressNonIdn()
{
return [
'Valid address' => [
'address' => 'a@example.com',
],
'Valid address with surrounding whitespace and mixed case' => [
'address' => " \tMiXeD@Example.Com \r\n",
'name' => null,
'expected' => [
'key' => 'mixed@example.com',
'address' => 'MiXeD@Example.Com',
'name' => '',
],
],
'Valid address with name' => [
'address' => 'a@example.com',
'name' => 'ReplyTo name',
],
'Valid address with name; name with whitespace and line breaks' => [
'address' => 'a@example.com',
'name' => "\t\t ReplyTo\r\nname ",
'expected' => [
'key' => 'a@example.com',
'address' => 'a@example.com',
'name' => 'ReplyToname',
],
],
];
}
/**
* Test adding an invalid non-IDN reply-to address.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addOrEnqueueAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::addAnAddress
*
* @dataProvider dataAddReplyToInvalidAddressNonIdn
*
* @param string $address The email address to set.
*/
public function testAddReplyToInvalidAddressNonIdn($address)
{
// Test the setting fails.
$result = $this->Mail->addReplyTo($address);
self::assertFalse($result, 'Invalid Replyto address accepted');
// Verify that the address was not added to the array.
$retrieved = $this->Mail->getReplyToAddresses();
self::assertIsArray($retrieved, 'ReplyTo property is not an array');
self::assertCount(0, $retrieved, 'ReplyTo property is not empty');
}
/**
* Test receiving an excepting when adding an invalid non-IDN reply-to address.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addOrEnqueueAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::addAnAddress
*
* @dataProvider dataAddReplyToInvalidAddressNonIdn
*
* @param string $address The email address to set.
*/
public function testAddReplyToInvalidAddressNonIdnException($address)
{
$this->expectException(Exception::class);
$this->expectExceptionMessage('Invalid address: (Reply-To): ' . $address);
$mail = new PHPMailer(true);
$mail->addReplyTo($address);
}
/**
* Data provider.
*
* @return array
*/
public function dataAddReplyToInvalidAddressNonIdn()
{
return [
'Invalid domain' => ['a@example..com'],
'Missing @ sign' => ['example.com'],
];
}
/**
* Test that the correct Reply-To message header has been added to the message.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addReplyTo
* @covers \PHPMailer\PHPMailer\PHPMailer::createHeader
* @covers \PHPMailer\PHPMailer\PHPMailer::addrAppend
*
* @dataProvider dataReplyToInMessageHeader
*
* @param string $addresses The email address(es) to set for Reply-To.
* @param string $expected The expected message header.
*/
public function testReplyToInMessageHeader($addresses, $expected)
{
$this->Mail->Body = 'Here is the main body. There should be ' .
'a reply to header in this message.';
$this->Mail->Subject .= ': Reply to header';
foreach ($addresses as $address) {
if (isset($address['name'])) {
$this->Mail->addReplyTo($address['address'], $address['name']);
} else {
$this->Mail->addReplyTo($address['address']);
}
}
$this->buildBody();
self::assertTrue($this->Mail->preSend(), $this->Mail->ErrorInfo);
$message = $this->Mail->getSentMIMEMessage();
self::assertStringContainsString($expected, $message, 'Message does not contain the expected reply-to header');
}
/**
* Data provider.
*
* @return array
*/
public function dataReplyToInMessageHeader()
{
$LE = PHPMailer::getLE();
return [
'Single address' => [
'addresses' => [
[
'address' => 'nobody@nobody.com',
],
],
'expected' => $LE . 'Reply-To: nobody@nobody.com' . $LE,
],
'Single address + name' => [
'addresses' => [
[
'address' => 'nobody@nobody.com',
'name' => 'Nobody (Unit Test)',
],
],
'expected' => $LE . 'Reply-To: "Nobody (Unit Test)" <nobody@nobody.com>' . $LE,
],
'Multiple addresses, including no name and mixed case email' => [
'addresses' => [
[
'address' => 'nobody@nobody.com',
'name' => 'Nobody (Unit Test)',
],
[
'address' => 'Somebody@SomeBody.com',
'name' => 'Somebody (Unit Test)',
],
[
'address' => 'noname@noname.com',
],
],
'expected' => $LE . 'Reply-To: "Nobody (Unit Test)" <nobody@nobody.com>,'
. ' "Somebody (Unit Test)" <Somebody@SomeBody.com>, noname@noname.com' . $LE,
],
];
}
/**
* Tests handling of IDN reply-to addresses.
*
* Verifies that:
* - CharSet and Unicode -> ASCII conversions for addresses with IDN gets executed correctly.
* - IDN addresses initially get enqueued.
* - IDN addresses correctly get added during `preSend()`.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addReplyTo
* @covers \PHPMailer\PHPMailer\PHPMailer::addOrEnqueueAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::addAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::preSend
*
* @requires extension mbstring
* @requires function idn_to_ascii
*/
public function testEnqueueAndAddIdnAddress()
{
// This file is UTF-8 encoded. Create a domain encoded in "iso-8859-1".
$letter = html_entity_decode('&ccedil;', ENT_COMPAT, PHPMailer::CHARSET_ISO88591);
$domain = '@' . 'fran' . $letter . 'ois.ch';
$address = 'test+replyto' . $domain;
self::assertTrue($this->Mail->addReplyTo($address), 'Replyto Addressing failed');
// Queued addresses are not returned by get*Addresses() before send() call.
self::assertEmpty($this->Mail->getReplyToAddresses(), 'Unexpected "reply-to" address added');
// Check that the queue has been set correctly.
$queue = $this->getPropertyValue($this->Mail, 'ReplyToQueue');
self::assertCount(1, $queue, 'Queue does not contain exactly 1 entry');
self::assertArrayHasKey($address, $queue, 'Queue does not contain an entry for the IDN address');
$this->buildBody();
self::assertTrue($this->Mail->preSend(), $this->Mail->ErrorInfo);
// Addresses with IDN are returned by get*Addresses() after preSend() call.
$domain = $this->Mail->punyencodeAddress($domain);
self::assertSame(
['test+replyto' . $domain => ['test+replyto' . $domain, '']],
$this->Mail->getReplyToAddresses(),
'Bad "reply-to" addresses'
);
}
/**
* Tests that non-exact duplicate reply-to addresses do get enqueued (IDN),
* but don't get added (IDN converted to punycode + non-IDN).
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addOrEnqueueAnAddress
* @covers \PHPMailer\PHPMailer\PHPMailer::addAnAddress
*
* @requires extension mbstring
* @requires function idn_to_ascii
*/
public function testNoDuplicateReplyToAddresses()
{
$this->Mail->CharSet = PHPMailer::CHARSET_UTF8;
self::assertTrue(
$this->Mail->addReplyTo('test+replyto@françois.ch', 'UTF8 domain'),
'Initial address + name not queued'
);
self::assertFalse(
$this->Mail->addReplyTo('test+replyto@françois.ch'),
'Duplicate address should not have been queued'
);
// For the queue, a duplicate address in a different case is accepted.
self::assertTrue(
$this->Mail->addReplyTo('test+replyto@FRANÇOIS.CH'),
'Duplicate address, different case address not queued'
);
self::assertFalse(
$this->Mail->addReplyTo('test+replyto@FRANÇOIS.CH'),
'Duplicate address, different case should not have been queued twice'
);
// An address in punycode does not go into the queue, but gets added straight away.
self::assertTrue(
$this->Mail->addReplyTo('test+replyto@xn--franois-xxa.ch'),
'Punycode address, no name not added'
);
self::assertFalse(
$this->Mail->addReplyTo('test+replyto@xn--franois-xxa.ch', 'Punycode domain'),
'Duplicate punycode address should not have been added, no matter that this one has a name'
);
self::assertFalse(
$this->Mail->addReplyTo('test+replyto@XN--FRANOIS-XXA.CH'),
'Duplicate punycode address, different case should not have been added'
);
// The one accepted punycode address should already be lined up.
self::assertCount(1, $this->Mail->getReplyToAddresses(), 'Addresses added did not match expected count of 1');
// Check that the non-punycode addresses were added to the queue correctly.
$queue = $this->getPropertyValue($this->Mail, 'ReplyToQueue');
self::assertIsArray($queue, 'Queue is not an array');
self::assertCount(2, $queue, 'Queue does not contain exactly 2 entries');
self::assertArrayHasKey(
'test+replyto@françois.ch',
$queue,
'Queue does not contain an entry for the lowercase address'
);
self::assertArrayHasKey(
'test+replyto@FRANÇOIS.CH',
$queue,
'Queue does not contain an entry for the uppercase address'
);
$this->buildBody();
self::assertTrue($this->Mail->preSend(), $this->Mail->ErrorInfo);
// There should be only one "Reply-To" address after preSend().
self::assertCount(
1,
$this->Mail->getReplyToAddresses(),
'Bad count of "reply-to" addresses'
);
$expectedAddress = 'test+replyto@xn--franois-xxa.ch';
$retrieved = $this->Mail->getReplyToAddresses();
self::assertCount(1, $retrieved, 'Stored addresses after preSend() is not 1');
// Verify that the registered reply-to address is the initially added lowercase punycode one.
self::assertArrayHasKey(
$expectedAddress,
$retrieved,
'ReplyTo property does not contain an entry with this address as the key'
);
self::assertCount(
2,
$retrieved[$expectedAddress],
'ReplyTo array for this address does not contain exactly two array items'
);
self::assertSame(
$expectedAddress,
$retrieved[$expectedAddress][0],
'ReplyTo array for this address does not contain added address'
);
self::assertSame(
'',
$retrieved[$expectedAddress][1],
'ReplyTo array for this address does not contain added name'
);
}
/**
* Test unsuccesfully adding an Reply-to address when an email address containing
* an 8bit character is passed and either the MbString or the Intl extension are
* not available.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::addAnAddress
*/
public function testAddReplyToFailsOn8BitCharInDomainWithoutOptionalExtensions()
{
if (extension_loaded('mbstring') && function_exists('idn_to_ascii')) {
$this->markTestSkipped('Test requires MbString and/or Intl *not* to be available');
}
self::assertFalse($this->Mail->addReplyTo('test@françois.ch'));
}
/**
* Test successfully clearing out both the added as well as the queued Reply-to addresses.
*
* @covers \PHPMailer\PHPMailer\PHPMailer::clearReplyTos
*
* @requires extension mbstring
* @requires function idn_to_ascii
*/
public function testClearReplyTos()
{
self::assertTrue($this->Mail->addReplyTo('example@example.com'), 'Address not added');
self::assertTrue($this->Mail->addReplyTo('test@françois.ch'), 'IDN Address not queued');
// Verify there is something to clear.
$retrieved = $this->Mail->getReplyToAddresses();
self::assertIsArray($retrieved, 'ReplyTo property is not an array (pre-clear)');
self::assertCount(1, $retrieved, 'ReplyTo property does not contain exactly one address');
$queue = $this->getPropertyValue($this->Mail, 'ReplyToQueue');
self::assertIsArray($queue, 'Queue is not an array (pre-clear)');
self::assertCount(1, $queue, 'Queue does not contain exactly one entry');
$this->Mail->clearReplyTos();
// Verify the clearing was successful.
$retrieved = $this->Mail->getReplyToAddresses();
self::assertIsArray($retrieved, 'ReplyTo property is not an array (post-clear)');
self::assertCount(0, $retrieved, 'ReplyTo property still contains an address');
$queue = $this->getPropertyValue($this->Mail, 'ReplyToQueue');
self::assertIsArray($queue, 'Queue is not an array (post-clear)');
self::assertCount(0, $queue, 'Queue still contains an entry');
}
}