tonyair
/
silverstripe-framework
mirror of https://github.com/silverstripe/silverstripe-framework
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

API Rename assert dos to assert list

This commit is contained in:
Werner M. Krauß 2017-09-27 09:25:37 +02:00 committed by Damian Mooyman
parent 566d7baa48
commit f686b50824
30 changed files with 1645 additions and 332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
src/Dev/Constraint/SSListContains.php Normal file
View File

@ -0,0 +1,139 @@
<?php
namespace SilverStripe\Dev\Constraint;
use PHPUnit_Framework_Constraint;
use PHPUnit_Framework_ExpectationFailedException;
use SilverStripe\Dev\SSListExporter;
use SilverStripe\Dev\TestOnly;
use SilverStripe\ORM\SS_List;
use SilverStripe\View\ViewableData;
if (!class_exists(PHPUnit_Framework_Constraint::class)) {
return;
}
/**
* Constraint for checking if a SS_List contains items matching the given
* key-value pairs.
*/
class SSListContains extends PHPUnit_Framework_Constraint implements TestOnly
{
/**
* @var array
*/
protected $matches = [];
/**
* Check if the list has left over items that don't match
*
* @var bool
*/
protected $hasLeftoverItems = false;
public function __construct($matches)
{
parent::__construct();
$this->exporter = new SSListExporter();
$this->matches = $matches;
}
/**
* Evaluates the constraint for parameter $other
*
* If $returnResult is set to false (the default), an exception is thrown
* in case of a failure. null is returned otherwise.
*
* If $returnResult is true, the result of the evaluation is returned as
* a boolean value instead: true in case of success, false in case of a
* failure.
*
* @param SS_List $other Value or object to evaluate.
* @param string $description Additional information about the test
* @param bool $returnResult Whether to return a result or throw an exception
*
* @return null|bool
*
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function evaluate($other, $description = '', $returnResult = false)
{
$success = true;
foreach ($other as $item) {
$this->checkIfItemEvaluatesRemainingMatches($item);
}
//we have remaining matches?
if (count($this->matches) !== 0) {
$success = false;
$this->hasLeftoverItems = true;
}
if ($returnResult) {
return $success;
}
if (!$success) {
$this->fail($other, $description);
}
return null;
}
/**
* @param ViewableData $item
* @return bool
*/
protected function checkIfItemEvaluatesRemainingMatches(ViewableData $item)
{
$success = false;
foreach ($this->matches as $key => $match) {
$constraint = new ViewableDataContains($match);
if ($constraint->evaluate($item, '', true)) {
$success = true;
unset($this->matches[$key]);
break;
}
}
return $success;
}
/**
* Returns a string representation of the object.
*
* @return string
*/
public function toString()
{
$matchToString = function ($key, $value) {
return ' "' . $key . '" is "' . $value . '"';
};
$matchesToString = function ($matches) use ($matchToString) {
$matchesAsString = implode(' and ', array_map(
$matchToString,
array_keys($matches),
array_values($matches)
));
return '(' . $matchesAsString . ')';
};
$allMatchesAsString = implode(
"\n or ",
array_map($matchesToString, $this->matches)
);
return $this->getStubForToString() . $allMatchesAsString;
}
protected function getStubForToString()
{
return ' contains an item matching ';
}
}

80
src/Dev/Constraint/SSListContainsOnly.php Normal file
View File

@ -0,0 +1,80 @@
<?php
namespace SilverStripe\Dev\Constraint;
use PHPUnit_Framework_Constraint;
use PHPUnit_Framework_ExpectationFailedException;
use SilverStripe\Dev\TestOnly;
use SilverStripe\ORM\SS_List;
if (!class_exists(PHPUnit_Framework_Constraint::class)) {
return;
}
/**
* Constraint for checking if a SS_List contains only items matching the given
* key-value pairs. Each match must correspond to 1 distinct record.
*/
class SSListContainsOnly extends SSListContains implements TestOnly
{
/**
* Check if the test fails due to a not matching item
*
* @var bool
*/
private $itemNotMatching = false;
/**
* Evaluates the constraint for parameter $other
*
* If $returnResult is set to false (the default), an exception is thrown
* in case of a failure. null is returned otherwise.
*
* If $returnResult is true, the result of the evaluation is returned as
* a boolean value instead: true in case of success, false in case of a
* failure.
*
* @param SS_List $other Value or object to evaluate.
* @param string $description Additional information about the test
* @param bool $returnResult Whether to return a result or throw an exception
*
* @return null|bool
*
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function evaluate($other, $description = '', $returnResult = false)
{
$success = true;
foreach ($other as $item) {
if (!$this->checkIfItemEvaluatesRemainingMatches($item)) {
$this->itemNotMatching = true;
$success = false;
break;
}
}
//we have remaining matches?
if (!$this->itemNotMatching && count($this->matches) !== 0) {
$success = false;
$this->hasLeftoverItems = true;
}
if ($returnResult) {
return $success;
}
if (!$success) {
$this->fail($other, $description);
}
return null;
}
protected function getStubForToString()
{
return $this->itemNotMatching
? parent::getStubForToString()
: " contained only the given items, the following items were left over:\n";
}
}

89
src/Dev/Constraint/SSListContainsOnlyMatchingItems.php Normal file
View File

@ -0,0 +1,89 @@
<?php
namespace SilverStripe\Dev\Constraint;
use PHPUnit_Framework_Constraint;
use PHPUnit_Framework_ExpectationFailedException;
use SilverStripe\Dev\SSListExporter;
use SilverStripe\Dev\TestOnly;
use SilverStripe\ORM\SS_List;
if (!class_exists(PHPUnit_Framework_Constraint::class)) {
return;
}
/**
* Constraint for checking if every item in a SS_List matches a given match,
* e.g. every Member has isActive set to true
*/
class SSListContainsOnlyMatchingItems extends PHPUnit_Framework_Constraint implements TestOnly
{
/**
* @var array
*/
private $match;
/**
* @var ViewableDataContains
*/
private $constraint;
public function __construct($match)
{
parent::__construct();
$this->exporter = new SSListExporter();
$this->constraint = new ViewableDataContains($match);
$this->match = $match;
}
/**
* Evaluates the constraint for parameter $other
*
* If $returnResult is set to false (the default), an exception is thrown
* in case of a failure. null is returned otherwise.
*
* If $returnResult is true, the result of the evaluation is returned as
* a boolean value instead: true in case of success, false in case of a
* failure.
*
* @param SS_List $other Value or object to evaluate.
* @param string $description Additional information about the test
* @param bool $returnResult Whether to return a result or throw an exception
*
* @return null|bool
*
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function evaluate($other, $description = '', $returnResult = false)
{
$success = true;
foreach ($other as $item) {
if (!$this->constraint->evaluate($item, '', true)) {
$success = false;
break;
}
}
if ($returnResult) {
return $success;
}
if (!$success) {
$this->fail($other, $description);
}
return null;
}
/**
* Returns a string representation of the object.
*
* @return string
*/
public function toString()
{
return 'contains only Objects where "' . key($this->match) . '" is "' . current($this->match) . '"';
}
}

96
src/Dev/Constraint/ViewableDataContains.php Normal file
View File

@ -0,0 +1,96 @@
<?php
namespace SilverStripe\Dev\Constraint;
use PHPUnit_Framework_Constraint;
use PHPUnit_Framework_ExpectationFailedException;
use PHPUnit_Util_InvalidArgumentHelper;
use SilverStripe\Dev\TestOnly;
use SilverStripe\View\ViewableData;
if (!class_exists(PHPUnit_Framework_Constraint::class)) {
return;
}
/**
* Constraint for checking if a ViewableData (e.g. ArrayData or any DataObject) contains fields matching the given
* key-value pairs.
*/
class ViewableDataContains extends PHPUnit_Framework_Constraint implements TestOnly
{
/**
* @var array
*/
private $match;
/**
* ViewableDataContains constructor.
* @param array $match
*/
public function __construct($match)
{
parent::__construct();
if (!is_array($match)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(
1,
'array'
);
}
$this->match = $match;
}
/**
* Evaluates the constraint for parameter $other
*
* If $returnResult is set to false (the default), an exception is thrown
* in case of a failure. null is returned otherwise.
*
* If $returnResult is true, the result of the evaluation is returned as
* a boolean value instead: true in case of success, false in case of a
* failure.
*
* @param ViewableData $other Value or object to evaluate.
* @param string $description Additional information about the test
* @param bool $returnResult Whether to return a result or throw an exception
*
* @return null|bool
*
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function evaluate($other, $description = '', $returnResult = false)
{
$success = true;
foreach ($this->match as $fieldName => $value) {
if ($other->getField($fieldName) != $value) {
$success = false;
break;
}
}
if ($returnResult) {
return $success;
}
if (!$success) {
$this->fail($other, $description);
}
return null;
}
/**
* Returns a string representation of the object.
*
* @todo: add representation for more than one match
*
* @return string
*/
public function toString()
{
return 'contains only Objects where "' . key($this->match) . '" is "' . current($this->match) . '"';
}
}

85
src/Dev/SSListExporter.php Normal file
View File

@ -0,0 +1,85 @@
<?php
namespace SilverStripe\Dev;
use SebastianBergmann\Exporter\Exporter;
use SebastianBergmann\RecursionContext\Context;
use SilverStripe\ORM\SS_List;
use SilverStripe\View\ViewableData;
if (!class_exists(Exporter::class)) {
return;
}
/**
* A custom exporter for prettier formatting of SilverStripe specific Objects in PHPUnit's failing test messages.
*/
class SSListExporter extends Exporter implements TestOnly
{
/**
* @param mixed $value
* @param int $indentation
* @param null|Context $processed
* @return string
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
*/
protected function recursiveExport(&$value, $indentation, $processed = null)
{
if (!$processed) {
$processed = new Context;
}
$whitespace = str_repeat(' ', 4 * $indentation);
if ($value instanceof SS_List) {
$className = get_class($value);
if (($key = $processed->contains($value)) !== false) {
return $className . ' &' . $key;
}
$list = $value;
$key = $processed->add($value);
$values = '';
if ($list->count() > 0) {
foreach ($list as $k => $v) {
$values .= sprintf(
'%s %s ' . "\n",
$whitespace,
$this->recursiveExport($v, $indentation)
);
}
$values = "\n" . $values . $whitespace;
}
return sprintf($className . ' &%s (%s)', $key, $values);
}
if ($value instanceof ViewableData) {
$className = get_class($value);
$data = $this->toMap($value);
return sprintf(
'%s %s => %s' . "\n",
$whitespace,
$className,
$this->recursiveExport($data, $indentation + 2, $processed)
);
}
return parent::recursiveExport($value, $indentation, $processed);
}
/**
* @param ViewableData $object
* @return array
*/
public function toMap(ViewableData $object)
{
return $object->hasMethod('toMap')
? $object->toMap()
: [];
}
}

385
src/Dev/SapphireTest.php
View File

@ -4,7 +4,9 @@ namespace SilverStripe\Dev;
use Exception;
use LogicException;
use PHPUnit_Framework_Constraint_Not;
use PHPUnit_Framework_TestCase;
use PHPUnit_Util_InvalidArgumentHelper;
use SilverStripe\CMS\Controllers\RootURLController;
use SilverStripe\Control\CLIRequestBuilder;
use SilverStripe\Control\Controller;
@ -12,12 +14,15 @@ use SilverStripe\Control\Cookie;
use SilverStripe\Control\Director;
use SilverStripe\Control\Email\Email;
use SilverStripe\Control\Email\Mailer;
use SilverStripe\Control\HTTPApplication;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Core\Config\Config;
use SilverStripe\Control\HTTPApplication;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Core\Injector\InjectorLoader;
use SilverStripe\Core\Manifest\ClassLoader;
use SilverStripe\Dev\Constraint\SSListContains;
use SilverStripe\Dev\Constraint\SSListContainsOnly;
use SilverStripe\Dev\Constraint\SSListContainsOnlyMatchingItems;
use SilverStripe\Dev\State\SapphireTestState;
use SilverStripe\Dev\State\TestState;
use SilverStripe\i18n\i18n;
@ -242,7 +247,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
$fixtureFiles = $this->getFixturePaths();
// Set up fixture
if ($fixtureFiles || $this->usesDatabase) {
if ($this->shouldSetupDatabaseForCurrentTest($fixtureFiles)) {
if (!static::$tempDB->isUsed()) {
static::$tempDB->build();
}
@ -266,7 +271,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
$fixture->writeInto($this->getFixtureFactory());
}
$this->logInWithPermission("ADMIN");
$this->logInWithPermission('ADMIN');
}
// turn off template debugging
@ -280,6 +285,50 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
Email::config()->remove('bcc_all_emails_to');
}
/**
* Helper method to determine if the current test should enable a test database
*
* @param $fixtureFiles
* @return bool
*/
protected function shouldSetupDatabaseForCurrentTest($fixtureFiles)
{
$databaseEnabledByDefault = $fixtureFiles || $this->usesDatabase;
return ($databaseEnabledByDefault && !$this->currentTestDisablesDatabase())
|| $this->currentTestEnablesDatabase();
}
/**
* Helper method to check, if the current test uses the database.
* This can be switched on with the annotation "@useDatabase"
*
* @return bool
*/
protected function currentTestEnablesDatabase()
{
$annotations = $this->getAnnotations();
return array_key_exists('useDatabase', $annotations['method'])
&& $annotations['method']['useDatabase'][0] !== 'false';
}
/**
* Helper method to check, if the current test uses the database.
* This can be switched on with the annotation "@useDatabase false"
*
* @return bool
*/
protected function currentTestDisablesDatabase()
{
$annotations = $this->getAnnotations();
return array_key_exists('useDatabase', $annotations['method'])
&& $annotations['method']['useDatabase'][0] === 'false';
}
/**
* Called once per test case ({@link SapphireTest} subclass).
* This is different to {@link setUp()}, which gets called once
@ -440,8 +489,8 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
{
$filename = ClassLoader::inst()->getItemPath(static::class);
if (!$filename) {
throw new LogicException("getItemPath returned null for " . static::class
. ". Try adding flush=1 to the test run.");
throw new LogicException('getItemPath returned null for ' . static::class
. '. Try adding flush=1 to the test run.');
}
return dirname($filename);
}
@ -540,7 +589,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @return array|null Contains keys: 'Type', 'To', 'From', 'Subject', 'Content', 'PlainContent', 'AttachedFiles',
* 'HtmlContent'
*/
public function findEmail($to, $from = null, $subject = null, $content = null)
public static function findEmail($to, $from = null, $subject = null, $content = null)
{
/** @var Mailer $mailer */
$mailer = Injector::inst()->get(Mailer::class);
@ -559,11 +608,11 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @param string $subject
* @param string $content
*/
public function assertEmailSent($to, $from = null, $subject = null, $content = null)
public static function assertEmailSent($to, $from = null, $subject = null, $content = null)
{
$found = (bool)$this->findEmail($to, $from, $subject, $content);
$found = (bool)static::findEmail($to, $from, $subject, $content);
$infoParts = "";
$infoParts = '';
$withParts = array();
if ($to) {
$infoParts .= " to '$to'";
@ -578,10 +627,10 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
$withParts[] = "content '$content'";
}
if ($withParts) {
$infoParts .= " with " . implode(" and ", $withParts);
$infoParts .= ' with ' . implode(' and ', $withParts);
}
$this->assertTrue(
static::assertTrue(
$found,
"Failed asserting that an email was sent$infoParts."
);
@ -594,91 +643,103 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
*
* @param SS_List|array $matches The patterns to match. Each pattern is a map of key-value pairs. You can
* either pass a single pattern or an array of patterns.
* @param SS_List $dataObjectSet The {@link SS_List} to test.
* @param SS_List $list The {@link SS_List} to test.
* @param string $message
*
* Examples
* --------
* Check that $members includes an entry with Email = sam@example.com:
* $this->assertDOSContains(array('Email' => '...@example.com'), $members);
* $this->assertListContains(['Email' => '...@example.com'], $members);
*
* Check that $members includes entries with Email = sam@example.com and with
* Email = ingo@example.com:
* $this->assertDOSContains(array(
* array('Email' => '...@example.com'),
* array('Email' => 'i...@example.com'),
* ), $members);
* $this->assertListContains([
* ['Email' => '...@example.com'],
* ['Email' => 'i...@example.com'],
* ], $members);
*/
public static function assertListContains($matches, SS_List $list, $message = '')
{
if (!is_array($matches)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(
1,
'array'
);
}
static::assertThat(
$list,
new SSListContains(
$matches
),
$message
);
}
/**
* @deprecated 4.0.0:5.0.0 Use assertListContains() instead
*
* @param $matches
* @param $dataObjectSet
*/
public function assertDOSContains($matches, $dataObjectSet)
{
$extracted = array();
foreach ($dataObjectSet as $object) {
/** @var DataObject $object */
$extracted[] = $object->toMap();
}
foreach ($matches as $match) {
$matched = false;
foreach ($extracted as $i => $item) {
if ($this->dataObjectArrayMatch($item, $match)) {
// Remove it from $extracted so that we don't get duplicate mapping.
unset($extracted[$i]);
$matched = true;
break;
}
}
// We couldn't find a match - assertion failed
$this->assertTrue(
$matched,
"Failed asserting that the SS_List contains an item matching "
. var_export($match, true) . "\n\nIn the following SS_List:\n"
. $this->DOSSummaryForMatch($dataObjectSet, $match)
);
}
Deprecation::notice('5.0', 'Use assertListContains() instead');
return static::assertListContains($matches, $dataObjectSet);
}
/**
* Asserts that no items in a given list appear in the given dataobject list
*
* @param SS_List|array $matches The patterns to match. Each pattern is a map of key-value pairs. You can
* either pass a single pattern or an array of patterns.
* @param SS_List $dataObjectSet The {@link SS_List} to test.
* @param SS_List $list The {@link SS_List} to test.
* @param string $message
*
* Examples
* --------
* Check that $members doesn't have an entry with Email = sam@example.com:
* $this->assertNotDOSContains(array('Email' => '...@example.com'), $members);
* $this->assertListNotContains(['Email' => '...@example.com'], $members);
*
* Check that $members doesn't have entries with Email = sam@example.com and with
* Email = ingo@example.com:
* $this->assertNotDOSContains(array(
* array('Email' => '...@example.com'),
* array('Email' => 'i...@example.com'),
* ), $members);
* $this->assertListNotContains([
* ['Email' => '...@example.com'],
* ['Email' => 'i...@example.com'],
* ], $members);
*/
public function assertNotDOSContains($matches, $dataObjectSet)
public static function assertListNotContains($matches, SS_List $list, $message = '')
{
$extracted = array();
foreach ($dataObjectSet as $object) {
/** @var DataObject $object */
$extracted[] = $object->toMap();
}
$matched = [];
foreach ($matches as $match) {
foreach ($extracted as $i => $item) {
if ($this->dataObjectArrayMatch($item, $match)) {
$matched[] = $extracted[$i];
break;
}
}
// We couldn't find a match - assertion failed
$this->assertEmpty(
$matched,
"Failed asserting that the SS_List dosn't contain a set of objects. "
. "Found objects were: " . var_export($matched, true)
if (!is_array($matches)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(
1,
'array'
);
}
$constraint = new PHPUnit_Framework_Constraint_Not(
new SSListContains(
$matches
)
);
static::assertThat(
$list,
$constraint,
$message
);
}
/**
* @deprecated 4.0.0:5.0.0 Use assertListNotContains() instead
*
* @param $matches
* @param $dataObjectSet
*/
public static function assertNotDOSContains($matches, $dataObjectSet)
{
Deprecation::notice('5.0', 'Use assertListNotContains() instead');
return static::assertListNotContains($matches, $dataObjectSet);
}
/**
@ -689,58 +750,47 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* --------
* Check that *only* the entries Sam Minnee and Ingo Schommer exist in $members. Order doesn't
* matter:
* $this->assertDOSEquals(array(
* array('FirstName' =>'Sam', 'Surname' => 'Minnee'),
* array('FirstName' => 'Ingo', 'Surname' => 'Schommer'),
* ), $members);
* $this->assertListEquals([
* ['FirstName' =>'Sam', 'Surname' => 'Minnee'],
* ['FirstName' => 'Ingo', 'Surname' => 'Schommer'],
* ], $members);
*
* @param mixed $matches The patterns to match. Each pattern is a map of key-value pairs. You can
* either pass a single pattern or an array of patterns.
* @param mixed $dataObjectSet The {@link SS_List} to test.
* @param mixed $list The {@link SS_List} to test.
* @param string $message
*/
public static function assertListEquals($matches, SS_List $list, $message = '')
{
if (!is_array($matches)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(
1,
'array'
);
}
static::assertThat(
$list,
new SSListContainsOnly(
$matches
),
$message
);
}
/**
* @deprecated 4.0.0:5.0.0 Use assertListEquals() instead
*
* @param $matches
* @param SS_List $dataObjectSet
*/
public function assertDOSEquals($matches, $dataObjectSet)
{
// Extract dataobjects
$extracted = array();
if ($dataObjectSet) {
foreach ($dataObjectSet as $object) {
/** @var DataObject $object */
$extracted[] = $object->toMap();
}
}
// Check all matches
if ($matches) {
foreach ($matches as $match) {
$matched = false;
foreach ($extracted as $i => $item) {
if ($this->dataObjectArrayMatch($item, $match)) {
// Remove it from $extracted so that we don't get duplicate mapping.
unset($extracted[$i]);
$matched = true;
break;
}
}
// We couldn't find a match - assertion failed
$this->assertTrue(
$matched,
"Failed asserting that the SS_List contains an item matching "
. var_export($match, true) . "\n\nIn the following SS_List:\n"
. $this->DOSSummaryForMatch($dataObjectSet, $match)
);
}
}
// If we have leftovers than the DOS has extra data that shouldn't be there
$this->assertTrue(
(count($extracted) == 0),
// If we didn't break by this point then we couldn't find a match
"Failed asserting that the SS_List contained only the given items, the "
. "following items were left over:\n" . var_export($extracted, true)
);
Deprecation::notice('5.0', 'Use assertListEquals() instead');
return static::assertListEquals($matches, $dataObjectSet);
}
/**
* Assert that the every record in the given {@link SS_List} matches the given key-value
* pairs.
@ -748,26 +798,40 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* Example
* --------
* Check that every entry in $members has a Status of 'Active':
* $this->assertDOSAllMatch(array('Status' => 'Active'), $members);
* $this->assertListAllMatch(['Status' => 'Active'], $members);
*
* @param mixed $match The pattern to match. The pattern is a map of key-value pairs.
* @param mixed $dataObjectSet The {@link SS_List} to test.
* @param mixed $list The {@link SS_List} to test.
* @param string $message
*/
public function assertDOSAllMatch($match, $dataObjectSet)
public static function assertListAllMatch($match, SS_List $list, $message = '')
{
$extracted = array();
foreach ($dataObjectSet as $object) {
/** @var DataObject $object */
$extracted[] = $object->toMap();
}
foreach ($extracted as $i => $item) {
$this->assertTrue(
$this->dataObjectArrayMatch($item, $match),
"Failed asserting that the the following item matched "
. var_export($match, true) . ": " . var_export($item, true)
if (!is_array($match)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(
1,
'array'
);
}
static::assertThat(
$list,
new SSListContainsOnlyMatchingItems(
$match
),
$message
);
}
/**
* @deprecated 4.0.0:5.0.0 Use assertListAllMatch() instead
*
* @param $match
* @param SS_List $dataObjectSet
*/
public function assertDOSAllMatch($match, SS_List $dataObjectSet)
{
Deprecation::notice('5.0', 'Use assertListAllMatch() instead');
return static::assertListAllMatch($match, $dataObjectSet);
}
/**
@ -777,7 +841,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @param string $sql
* @return string The cleaned and normalised SQL string
*/
protected function normaliseSQL($sql)
protected static function normaliseSQL($sql)
{
return trim(preg_replace('/\s+/m', ' ', $sql));
}
@ -793,7 +857,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @param boolean $canonicalize
* @param boolean $ignoreCase
*/
public function assertSQLEquals(
public static function assertSQLEquals(
$expectedSQL,
$actualSQL,
$message = '',
@ -803,10 +867,10 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
$ignoreCase = false
) {
// Normalise SQL queries to remove patterns of repeating whitespace
$expectedSQL = $this->normaliseSQL($expectedSQL);
$actualSQL = $this->normaliseSQL($actualSQL);
$expectedSQL = static::normaliseSQL($expectedSQL);
$actualSQL = static::normaliseSQL($actualSQL);
$this->assertEquals($expectedSQL, $actualSQL, $message, $delta, $maxDepth, $canonicalize, $ignoreCase);
static::assertEquals($expectedSQL, $actualSQL, $message, $delta, $maxDepth, $canonicalize, $ignoreCase);
}
/**
@ -818,17 +882,17 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @param boolean $ignoreCase
* @param boolean $checkForObjectIdentity
*/
public function assertSQLContains(
public static function assertSQLContains(
$needleSQL,
$haystackSQL,
$message = '',
$ignoreCase = false,
$checkForObjectIdentity = true
) {
$needleSQL = $this->normaliseSQL($needleSQL);
$haystackSQL = $this->normaliseSQL($haystackSQL);
$needleSQL = static::normaliseSQL($needleSQL);
$haystackSQL = static::normaliseSQL($haystackSQL);
$this->assertContains($needleSQL, $haystackSQL, $message, $ignoreCase, $checkForObjectIdentity);
static::assertContains($needleSQL, $haystackSQL, $message, $ignoreCase, $checkForObjectIdentity);
}
/**
@ -840,50 +904,17 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @param boolean $ignoreCase
* @param boolean $checkForObjectIdentity
*/
public function assertSQLNotContains(
public static function assertSQLNotContains(
$needleSQL,
$haystackSQL,
$message = '',
$ignoreCase = false,
$checkForObjectIdentity = true
) {
$needleSQL = $this->normaliseSQL($needleSQL);
$haystackSQL = $this->normaliseSQL($haystackSQL);
$needleSQL = static::normaliseSQL($needleSQL);
$haystackSQL = static::normaliseSQL($haystackSQL);
$this->assertNotContains($needleSQL, $haystackSQL, $message, $ignoreCase, $checkForObjectIdentity);
}
/**
* Helper function for the DOS matchers
*
* @param array $item
* @param array $match
* @return bool
*/
private function dataObjectArrayMatch($item, $match)
{
foreach ($match as $k => $v) {
if (!array_key_exists($k, $item) || $item[$k] != $v) {
return false;
}
}
return true;
}
/**
* Helper function for the DOS matchers
*
* @param SS_List|array $dataObjectSet
* @param array $match
* @return string
*/
private function DOSSummaryForMatch($dataObjectSet, $match)
{
$extracted = array();
foreach ($dataObjectSet as $item) {
$extracted[] = array_intersect_key($item->toMap(), $match);
}
return var_export($extracted, true);
static::assertNotContains($needleSQL, $haystackSQL, $message, $ignoreCase, $checkForObjectIdentity);
}
/**
@ -897,7 +928,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
// Health check
if (InjectorLoader::inst()->countManifests()) {
throw new LogicException("SapphireTest::start() cannot be called within another application");
throw new LogicException('SapphireTest::start() cannot be called within another application');
}
static::set_is_running_test(true);
@ -1001,7 +1032,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
}
$member->FirstName = $permCode;
$member->Surname = "User";
$member->Surname = 'User';
$member->Email = "$permCode@example.org";
$member->write();
$group->Members()->add($member);
@ -1018,7 +1049,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
* @param string|array $permCode Either a permission, or list of permissions
* @return int Member ID
*/
public function logInWithPermission($permCode = "ADMIN")
public function logInWithPermission($permCode = 'ADMIN')
{
$member = $this->createMemberWithPermission($permCode);
$this->logInAs($member);
@ -1091,7 +1122,7 @@ class SapphireTest extends PHPUnit_Framework_TestCase implements TestOnly
return [];
}
$fixtureFiles = (is_array($fixtureFile)) ? $fixtureFile : [$fixtureFile];
$fixtureFiles = is_array($fixtureFile) ? $fixtureFile : [$fixtureFile];
return array_map(function ($fixtureFilePath) {
return $this->resolveFixturePath($fixtureFilePath);

5
tests/php/Control/ControllerTest.php
View File

@ -292,9 +292,12 @@ class ControllerTest extends FunctionalTest
Security::setCurrentUser(null);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Invalid allowed_action '*'
*/
public function testWildcardAllowedActions()
{
$this->setExpectedException(InvalidArgumentException::class, "Invalid allowed_action '*'");
$this->get('AccessWildcardSecuredController');
}

42
tests/php/Dev/SSListContainsOnlyMatchingItemsTest.php Normal file
View File

@ -0,0 +1,42 @@
<?php
namespace SilverStripe\Dev\Tests;
use SilverStripe\Dev\Constraint\SSListContainsOnly;
use SilverStripe\Dev\Constraint\SSListContainsOnlyMatchingItems;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Security\Member;
class SSListContainsOnlyMatchingItemsTest extends SapphireTest
{
public function testEvaluateListMatchesCorrectly()
{
$constraint = new SSListContainsOnlyMatchingItems(['IsActive' => 1]);
$this->assertTrue($constraint->evaluate($this->getListToMatch(), '', true));
}
/**
* @return ArrayList|Member[]
*/
private function getListToMatch()
{
$list = ArrayList::create();
$list->push(Member::create(['FirstName' => 'Ingo', 'Surname' => 'Schommer', 'IsActive' => 1]));
$list->push(Member::create(['FirstName' => 'Sam', 'Surname' => 'Minnee', 'IsActive' => 1]));
return $list;
}
public function testEvaluateListDoesNotMatchWrongMatches()
{
$constraint = new SSListContainsOnlyMatchingItems(['IsActive' => 1]);
$failingList = $this->getListToMatch();
$failingList->push(Member::create(['FirstName' => 'Foo', 'IsActive' => 0]));
$this->assertFalse($constraint->evaluate($failingList, '', true));
}
}

87
tests/php/Dev/SSListContainsOnlyTest.php Normal file
View File

@ -0,0 +1,87 @@
<?php
namespace SilverStripe\Dev\Tests;
use SilverStripe\Dev\Constraint\SSListContainsOnly;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Security\Member;
class SSListContainsOnlyTest extends SapphireTest
{
public function provideMatchesForList()
{
return [
[
[
['FirstName' => 'Ingo'],
['Surname' => 'Minnee']
]
],
[
[
['FirstName' => 'Sam', 'Surname' => 'Minnee'], //Sam Minee or Ingo
['FirstName' => 'Ingo']
]
],
];
}
public function provideInvalidMatchesForList()
{
return [
[
[['FirstName' => 'AnyoneNotInList']]
],
[
[['Surname' => 'NotInList']]
],
[
[['FirstName' => 'Ingo', 'Surname' => 'Minnee']] //more matches in List
],
[
[
['FirstName' => 'Ingo', 'Surname' => 'Minnee'], //mixed
['FirstName' => 'NotInList']
]
],
];
}
/**
* @dataProvider provideMatchesForList()
*
* @param $matches
*/
public function testEvaluateListMatchesCorrectly($matches)
{
$constraint = new SSListContainsOnly($matches);
$this->assertTrue($constraint->evaluate($this->getListToMatch(), '', true));
}
/**
* @return ArrayList|Member[]
*/
private function getListToMatch()
{
$list = ArrayList::create();
$list->push(Member::create(['FirstName' => 'Ingo', 'Surname' => 'Schommer']));
$list->push(Member::create(['FirstName' => 'Sam', 'Surname' => 'Minnee']));
return $list;
}
/**
* @dataProvider provideInvalidMatchesForList()
*
* @param $matches
*/
public function testEvaluateListDoesNotMatchWrongMatches($matches)
{
$constraint = new SSListContainsOnly($matches);
$this->assertFalse($constraint->evaluate($this->getListToMatch(), '', true));
}
}

91
tests/php/Dev/SSListContainsTest.php Normal file
View File

@ -0,0 +1,91 @@
<?php
namespace SilverStripe\Dev\Tests;
use SilverStripe\Dev\Constraint\SSListContains;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Security\Member;
class SSListContainsTest extends SapphireTest
{
public function provideMatchesForList()
{
return [
[
[['FirstName' => 'Ingo']]
],
[
[['Surname' => 'Minnee']]
],
[
[['FirstName' => 'Sam', 'Surname' => 'Minnee']]
],
[
[
['FirstName' => 'Sam', 'Surname' => 'Minnee'], //Sam Minee or Ingo
['FirstName' => 'Ingo']
]
],
];
}
public function provideInvalidMatchesForList()
{
return [
[
[['FirstName' => 'AnyoneNotInList']]
],
[
[['Surname' => 'NotInList']]
],
[
[['FirstName' => 'Ingo', 'Surname' => 'Minnee']]
],
[
[
['FirstName' => 'Ingo', 'Surname' => 'Minnee'],
['FirstName' => 'NotInList']
]
],
];
}
/**
* @dataProvider provideMatchesForList()
*
* @param $matches
*/
public function testEvaluateListMatchesCorrectly($matches)
{
$constraint = new SSListContains($matches);
$this->assertTrue($constraint->evaluate($this->getListToMatch(), '', true));
}
/**
* @dataProvider provideInvalidMatchesForList()
*
* @param $matches
*/
public function testEvaluateListDoesNotMatchWrongMatches($matches)
{
$constraint = new SSListContains($matches);
$this->assertFalse($constraint->evaluate($this->getListToMatch(), '', true));
}
/**
* @return ArrayList|Member[]
*/
private function getListToMatch()
{
$list = ArrayList::create();
$list->push(Member::create(['FirstName' => 'Ingo', 'Surname' => 'Schommer']));
$list->push(Member::create(['FirstName' => 'Sam', 'Surname' => 'Minnee']));
$list->push(Member::create(['FirstName' => 'Foo', 'Surname' => 'Bar']));
return $list;
}
}

85
tests/php/Dev/SSListExporterTest.php Normal file
View File

@ -0,0 +1,85 @@
<?php
namespace SilverStripe\Dev\Tests;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Dev\SSListExporter;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\Member;
use SilverStripe\View\ArrayData;
class SSListExporterTest extends SapphireTest
{
/**
* @var SSListExporter
*/
private $exporter;
public function setUp()
{
parent::setUp();
$this->exporter = new SSListExporter();
}
public function provideClassesForExport()
{
return [
[ArrayList::class, false],
[DataObject::class, false],
[DataList::class, Member::class],
[ArrayData::class, false]
];
}
/**
* @dataProvider provideClassesForExport()
* @param $className
* @param $constructorParam
*/
public function testExportStartsWithClassName($className, $constructorParam)
{
$obj = $constructorParam
? $className::create($constructorParam)
: $className::create();
$export = ltrim($this->exporter->export($obj));
$this->assertStringStartsWith(get_class($obj), $export, 'Export should start with object\'s class name');
}
/**
* @testdox toMap() returns DataObjects's data
*/
public function testToMapReturnsDataOfDataObjects()
{
$data = [
'Foo' => 'Bar',
'Baz' => 'Boom',
'One' => 'Two'
];
$map = $this->exporter->toMap(DataObject::create($data));
$this->assertEquals($data, $map, 'Map should match data passed to DataObject');
}
/**
* @testdox toMap() returns ArrayData's data
*/
public function testToMapReturnsDataOfArrayData()
{
$data = [
'Foo' => 'Bar',
'Baz' => 'Boom',
'One' => 'Two'
];
$map = $this->exporter->toMap(ArrayData::create($data));
$this->assertEquals($data, $map, 'Map should match data passed to ArrayData');
}
}

201
tests/php/Dev/SapphireTestTest.php
View File

@ -3,35 +3,44 @@
namespace SilverStripe\Dev\Tests;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Security\Member;
use SilverStripe\Security\Permission;
class SapphireTestTest extends SapphireTest
{
public function testResolveFixturePath()
/**
* @return array
*/
public function provideResolveFixturePath()
{
return [
[__DIR__ . '/CsvBulkLoaderTest.yml', './CsvBulkLoaderTest.yml'],
//same dir
[__DIR__ . '/CsvBulkLoaderTest.yml', 'CsvBulkLoaderTest.yml'],
// Filename only
[dirname(__DIR__) . '/ORM/DataObjectTest.yml', '../ORM/DataObjectTest.yml'],
// Parent path
[dirname(__DIR__) . '/ORM/DataObjectTest.yml', dirname(__DIR__) . '/ORM/DataObjectTest.yml'],
// Absolute path
];
}
/**
* @dataProvider provideResolveFixturePath
*/
public function testResolveFixturePath($expected, $path)
{
// Same directory
$this->assertEquals(
__DIR__ . '/CsvBulkLoaderTest.yml',
$this->resolveFixturePath('./CsvBulkLoaderTest.yml')
);
// Filename only
$this->assertEquals(
__DIR__ . '/CsvBulkLoaderTest.yml',
$this->resolveFixturePath('CsvBulkLoaderTest.yml')
);
// Parent path
$this->assertEquals(
dirname(__DIR__) . '/ORM/DataObjectTest.yml',
$this->resolveFixturePath('../ORM/DataObjectTest.yml')
);
// Absolute path
$this->assertEquals(
dirname(__DIR__) . '/ORM/DataObjectTest.yml',
$this->resolveFixturePath(dirname(__DIR__) .'/ORM/DataObjectTest.yml')
$expected,
$this->resolveFixturePath($path)
);
}
/**
* @useDatabase
*/
public function testActWithPermission()
{
$this->logOut();
@ -45,10 +54,160 @@ class SapphireTestTest extends SapphireTest
});
}
/**
* @useDatabase
*/
public function testCreateMemberWithPermission()
{
$this->assertCount(0, Member::get()->filter([ 'Email' => 'TESTPERM@example.org' ]));
$this->assertCount(0, Member::get()->filter(['Email' => 'TESTPERM@example.org']));
$this->createMemberWithPermission('TESTPERM');
$this->assertCount(1, Member::get()->filter([ 'Email' => 'TESTPERM@example.org' ]));
$this->assertCount(1, Member::get()->filter(['Email' => 'TESTPERM@example.org']));
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideAllMatchingList()
*
* @param $match
* @param $itemsForList
* @testdox Has assertion assertListAllMatch
*/
public function testAssertListAllMatch($match, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$this->assertListAllMatch($match, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideNotMatchingList()
*
* @param $match
* @param $itemsForList
*
* @testdox assertion assertListAllMatch fails when not all items are matching
*
* @expectedException \PHPUnit_Framework_ExpectationFailedException
*/
public function testAssertListAllMatchFailsWhenNotMatchingAllItems($match, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$this->assertListAllMatch($match, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideEqualListsWithEmptyList()
*
* @param $matches
* @param $itemsForList
* @testdox Has assertion assertListContains
*/
public function testAssertListContains($matches, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$list->push(Member::create(['FirstName' => 'Foo', 'Surname' => 'Foo']));
$list->push(Member::create(['FirstName' => 'Bar', 'Surname' => 'Bar']));
$list->push(Member::create(['FirstName' => 'Baz', 'Surname' => 'Baz']));
$this->assertListContains($matches, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideNotContainingList
* @testdox assertion assertListEquals fails on non equal Lists
*
* @param $matches
* @param $itemsForList array
*
* @expectedException \PHPUnit_Framework_ExpectationFailedException
*/
public function testAssertListContainsFailsIfListDoesNotContainMatch($matches, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$list->push(Member::create(['FirstName' => 'Foo', 'Surname' => 'Foo']));
$list->push(Member::create(['FirstName' => 'Bar', 'Surname' => 'Bar']));
$list->push(Member::create(['FirstName' => 'Baz', 'Surname' => 'Baz']));
$this->assertListContains($matches, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideNotContainingList
*
* @testdox Has assertion assertListNotContains
*
* @param $matches
* @param $itemsForList
*/
public function testAssertListNotContains($matches, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$this->assertListNotContains($matches, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideEqualLists
*
* @param $matches
* @param $itemsForList
* @testdox assertion assertListNotContains throws a exception when a matching item is found in the list
*
* @expectedException \PHPUnit_Framework_ExpectationFailedException
*/
public function testAssertListNotContainsFailsWhenListContainsAMatch($matches, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$list->push(Member::create(['FirstName' => 'Foo', 'Surname' => 'Foo']));
$list->push(Member::create(['FirstName' => 'Bar', 'Surname' => 'Bar']));
$list->push(Member::create(['FirstName' => 'Baz', 'Surname' => 'Baz']));
$this->assertListNotContains($matches, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideEqualListsWithEmptyList()
* @testdox Has assertion assertListEquals
*
* @param $matches
* @param $itemsForList
*/
public function testAssertListEquals($matches, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$this->assertListEquals($matches, $list);
}
/**
* @dataProvider \SilverStripe\Dev\Tests\SapphireTestTest\DataProvider::provideNonEqualLists
* @testdox assertion assertListEquals fails on non equal Lists
*
* @param $matches
* @param $itemsForList
*
* @expectedException \PHPUnit_Framework_ExpectationFailedException
*/
public function testAssertListEqualsFailsOnNonEqualLists($matches, $itemsForList)
{
$list = $this->generateArrayListFromItems($itemsForList);
$this->assertListEquals($matches, $list);
}
/**
* generate SS_List as this is not possible in dataProvider
*
* @param $itemsForList array
* @return ArrayList
*/
private function generateArrayListFromItems($itemsForList)
{
$list = ArrayList::create();
foreach ($itemsForList as $data) {
$list->push(Member::create($data));
}
return $list;
}
}

187
tests/php/Dev/SapphireTestTest/DataProvider.php Normal file
View File

@ -0,0 +1,187 @@
<?php
namespace SilverStripe\Dev\Tests\SapphireTestTest;
use SilverStripe\Dev\TestOnly;
class DataProvider implements TestOnly
{
protected static $oneItemList = [
['FirstName' => 'Ingo', 'Surname' => 'Schommer']
];
protected static $twoItemList = [
['FirstName' => 'Ingo', 'Surname' => 'Schommer'],
['FirstName' => 'Sam', 'Surname' => 'Minnee']
];
/**
* @return array
*/
public static function provideEqualListsWithEmptyList()
{
return array_merge(
[ //empty list
[
[],
[]
]
],
self::provideEqualLists()
);
}
/**
* @return array
*/
public static function provideEqualLists()
{
return [
[
[ //one param
['FirstName' => 'Ingo']
],
self::$oneItemList
],
[
[ //two params
['FirstName' => 'Ingo', 'Surname' => 'Schommer']
],
self::$oneItemList
],
[ //only one param
[
['FirstName' => 'Ingo'],
['FirstName' => 'Sam']
],
self::$twoItemList
],
[
[ //two params
['FirstName' => 'Ingo', 'Surname' => 'Schommer'],
['FirstName' => 'Sam', 'Surname' => 'Minnee']
],
self::$twoItemList
],
[
[ //mixed
['FirstName' => 'Ingo', 'Surname' => 'Schommer'],
['FirstName' => 'Sam']
],
self::$twoItemList
],
];
}
/**
* @return array
*/
public static function provideNonEqualLists()
{
return [
[ //empty list
[
['FirstName' => 'Ingo']
],
[]
],
[
[ //one item expected
['FirstName' => 'Ingo']
]
,
self::$twoItemList
],
[ //one item with wrong param
[
['FirstName' => 'IngoXX'],
['FirstName' => 'Sam']
]
,
self::$twoItemList
],
[
[ //two params wrong
['FirstName' => 'IngoXXX', 'Surname' => 'Schommer'],
['FirstName' => 'Sam', 'Surname' => 'MinneeXXX']
],
self::$twoItemList
],
[
[ //mixed
['FirstName' => 'Daniel', 'Surname' => 'Foo'],
['FirstName' => 'Dan']
],
self::$twoItemList
],
];
}
/**
* @return array
*/
public static function provideNotContainingList()
{
return [
[ //empty list
[
['FirstName' => 'Ingo']
],
[]
],
[
[ //one item expected
['FirstName' => 'Sam']
]
,
self::$oneItemList
],
[
[ //two params wrong
['FirstName' => 'IngoXXX', 'Surname' => 'Schommer'],
['FirstName' => 'Sam', 'Surname' => 'MinneeXXX']
],
self::$twoItemList
],
[
[ //mixed
['FirstName' => 'Daniel', 'Surname' => 'Foo'],
['FirstName' => 'Dan']
],
self::$twoItemList
],
];
}
/**
* @return array
*/
public static function provideAllMatchingList()
{
$list = [
['FirstName' => 'Ingo', 'Surname' => 'Schommer', 'Locale' => 'en_US'],
['FirstName' => 'Sam', 'Surname' => 'Minnee', 'Locale' => 'en_US']
];
return [
[[], $list], //empty match
[['Locale' => 'en_US'], $list] //all items have this field set
];
}
/**
* @return array
*/
public static function provideNotMatchingList()
{
$list = [
['FirstName' => 'Ingo', 'Surname' => 'Schommer', 'Locale' => 'en_US'],
['FirstName' => 'Sam', 'Surname' => 'Minnee', 'Locale' => 'en_US']
];
return [
[['FirstName' => 'Ingo'], $list] //not all items have this field set
];
}
}

103
tests/php/Dev/ViewableDataContainsTest.php Normal file
View File

@ -0,0 +1,103 @@
<?php
namespace SilverStripe\Dev\Tests;
use SilverStripe\Dev\Constraint\ViewableDataContains;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Security\Member;
use SilverStripe\View\ArrayData;
class ViewableDataContainsTest extends SapphireTest
{
private $test_data = [
'FirstName' => 'Ingo',
'Surname' => 'Schommer'
];
public function provideMatchesForList()
{
return [
[
['FirstName' => 'Ingo']
],
[
['Surname' => 'Schommer']
],
[
['FirstName' => 'Ingo', 'Surname' => 'Schommer']
]
];
}
public function provideInvalidMatchesForList()
{
return [
[
['FirstName' => 'AnyoneNotInList']
],
[
['Surname' => 'NotInList']
],
[
['FirstName' => 'Ingo', 'Surname' => 'Minnee']
]
];
}
/**
* @dataProvider provideMatchesForList()
*
* @param $match
*/
public function testEvaluateMatchesCorrectlyArrayData($match)
{
$constraint = new ViewableDataContains($match);
$item = ArrayData::create($this->test_data);
$this->assertTrue($constraint->evaluate($item, '', true));
}
/**
* @dataProvider provideMatchesForList()
*
* @param $match
*/
public function testEvaluateMatchesCorrectlyDataObject($match)
{
$constraint = new ViewableDataContains($match);
$item = Member::create($this->test_data);
$this->assertTrue($constraint->evaluate($item, '', true));
}
/**
* @dataProvider provideInvalidMatchesForList()
*
* @param $matches
*/
public function testEvaluateDoesNotMatchWrongMatchInArrayData($match)
{
$constraint = new ViewableDataContains($match);
$item = ArrayData::create($this->test_data);
$this->assertFalse($constraint->evaluate($item, '', true));
}
/**
* @dataProvider provideInvalidMatchesForList()
*
* @param $matches
*/
public function testEvaluateDoesNotMatchWrongMatchInDataObject($match)
{
$constraint = new ViewableDataContains($match);
$item = Member::create($this->test_data);
$this->assertFalse($constraint->evaluate($item, '', true));
}
}

2
tests/php/Forms/GridField/GridFieldAddExistingAutocompleterTest.php
View File

@ -119,7 +119,7 @@ class GridFieldAddExistingAutocompleterTest extends FunctionalTest
$parser = new CSSContentParser($response->getBody());
$items = $parser->getBySelector('.grid-field .ss-gridfield-items .ss-gridfield-item');
$this->assertEquals(2, count($items));
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('ID' => (int)$items[0]['data-id']),
array('ID' => (int)$items[1]['data-id']),

3
tests/php/Forms/GridField/GridFieldDataColumnsTest.php
View File

@ -41,10 +41,11 @@ class GridFieldDataColumnsTest extends SapphireTest
/**
* @covers \SilverStripe\Forms\GridField\GridFieldDataColumns::setDisplayFields
* @covers \SilverStripe\Forms\GridField\GridFieldDataColumns::getDisplayFields
*
* @expectedException \InvalidArgumentException
*/
public function testGridFieldDisplayFieldsWithBadArguments()
{
$this->setExpectedException('InvalidArgumentException');
$obj = new GridField('testfield', 'testfield', Member::get());
$columns = $obj->getConfig()->getComponentByType(GridFieldDataColumns::class);
$columns->setDisplayFields(new stdClass());

2
tests/php/Forms/GridField/GridFieldDetailFormTest.php
View File

@ -176,7 +176,7 @@ class GridFieldDetailFormTest extends FunctionalTest
->filter('Name', 'My Group')
->sort('Name')
->First();
$this->assertDOSContains(array(array('Surname' => 'Baggins')), $group->People());
$this->assertListContains(array(array('Surname' => 'Baggins')), $group->People());
}
public function testEditFormWithManyMany()

26
tests/php/Forms/GridField/GridFieldTest.php
View File

@ -2,6 +2,7 @@
namespace SilverStripe\Forms\Tests\GridField;
use Psr\Log\InvalidArgumentException;
use SilverStripe\Dev\CSSContentParser;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Forms\FieldList;
@ -123,10 +124,11 @@ class GridFieldTest extends SapphireTest
/**
* @covers \SilverStripe\Forms\GridField\GridField::getModelClass
*
* @expectedException \LogicException
*/
public function testGridFieldModelClassThrowsException()
{
$this->setExpectedException('LogicException');
$obj = new GridField('testfield', 'testfield', ArrayList::create());
$obj->getModelClass();
}
@ -247,10 +249,11 @@ class GridFieldTest extends SapphireTest
/**
* @skipUpgrade
* @covers \SilverStripe\Forms\GridField\GridField::getColumnContent
*
* @expectedException \InvalidArgumentException
*/
public function testGetColumnContentBadArguments()
{
$this->setExpectedException('InvalidArgumentException');
$list = new ArrayList(
array(
new Member(array("ID" => 1, "Email" => "test@example.org"))
@ -293,10 +296,11 @@ class GridFieldTest extends SapphireTest
/**
* @covers \SilverStripe\Forms\GridField\GridField::getColumnAttributes
*
* @expectedException \InvalidArgumentException
*/
public function testGetColumnAttributesBadArguments()
{
$this->setExpectedException('InvalidArgumentException');
$list = new ArrayList(
array(
new Member(array("ID" => 1, "Email" => "test@example.org"))
@ -307,9 +311,11 @@ class GridFieldTest extends SapphireTest
$obj->getColumnAttributes($list->first(), 'Non-existing');
}
/**
* @expectedException \LogicException
*/
public function testGetColumnAttributesBadResponseFromComponent()
{
$this->setExpectedException('LogicException');
$list = new ArrayList(
array(
new Member(array("ID" => 1, "Email" => "test@example.org"))
@ -338,10 +344,11 @@ class GridFieldTest extends SapphireTest
/**
* @covers \SilverStripe\Forms\GridField\GridField::getColumnMetadata
*
* @expectedException \LogicException
*/
public function testGetColumnMetadataBadResponseFromComponent()
{
$this->setExpectedException('LogicException');
$list = new ArrayList(
array(
new Member(array("ID" => 1, "Email" => "test@example.org"))
@ -354,10 +361,11 @@ class GridFieldTest extends SapphireTest
/**
* @covers \SilverStripe\Forms\GridField\GridField::getColumnMetadata
*
* @expectedException \InvalidArgumentException
*/
public function testGetColumnMetadataBadArguments()
{
$this->setExpectedException('InvalidArgumentException');
$list = ArrayList::create();
$config = GridFieldConfig::create()->addComponent(new Component);
$obj = new GridField('testfield', 'testfield', $list, $config);
@ -366,10 +374,11 @@ class GridFieldTest extends SapphireTest
/**
* @covers \SilverStripe\Forms\GridField\GridField::handleAction
*
* @expectedException \InvalidArgumentException
*/
public function testHandleActionBadArgument()
{
$this->setExpectedException('InvalidArgumentException');
$obj = new GridField('testfield', 'testfield');
$obj->handleAlterAction('prft', array(), array());
}
@ -506,6 +515,8 @@ class GridFieldTest extends SapphireTest
/**
* Test that circular dependencies throw an exception
*
* @expectedException \LogicException
*/
public function testGridFieldCustomFragmentsCircularDependencyThrowsException()
{
@ -534,7 +545,6 @@ class GridFieldTest extends SapphireTest
$field = new GridField('testfield', 'testfield', ArrayList::create(), $config);
$form = new Form(null, 'testform', new FieldList(array($field)), new FieldList());
$this->setExpectedException('LogicException');
$field->FieldHolder();
}

20
tests/php/ORM/CascadeDeleteTest.php
View File

@ -22,14 +22,14 @@ class CascadeDeleteTest extends SapphireTest
{
/** @var CascadeDeleteTest\ChildObject $child1 */
$child1 = $this->objFromFixture(CascadeDeleteTest\ChildObject::class, 'child1');
$this->assertDOSEquals(
$this->assertListEquals(
[
[ 'Title' => 'Grandchild 1'],
[ 'Title' => 'Grandchild 2'],
],
$child1->findCascadeDeletes(true)
);
$this->assertDOSEquals(
$this->assertListEquals(
[
[ 'Title' => 'Grandchild 1'],
[ 'Title' => 'Grandchild 2'],
@ -39,7 +39,7 @@ class CascadeDeleteTest extends SapphireTest
/** @var CascadeDeleteTest\ParentObject $parent1 */
$parent1 = $this->objFromFixture(CascadeDeleteTest\ParentObject::class, 'parent1');
$this->assertDOSEquals(
$this->assertListEquals(
[
[ 'Title' => 'Child 1'],
[ 'Title' => 'Grandchild 1'],
@ -47,7 +47,7 @@ class CascadeDeleteTest extends SapphireTest
],
$parent1->findCascadeDeletes(true)
);
$this->assertDOSEquals(
$this->assertListEquals(
[
[ 'Title' => 'Child 1'],
],
@ -65,7 +65,7 @@ class CascadeDeleteTest extends SapphireTest
$this->assertNotEmpty($this->objFromFixture(CascadeDeleteTest\ParentObject::class, 'parent1'));
// Related objects never deleted
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Related 1'],
['Title' => 'Related 2'],
@ -75,7 +75,7 @@ class CascadeDeleteTest extends SapphireTest
);
// Ensure only remaining grandchild are those outside the relation
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Grandchild 3'],
],
@ -90,13 +90,13 @@ class CascadeDeleteTest extends SapphireTest
$parent1->delete();
// Ensure affected cascading tables have expected content
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Child 2'],
],
CascadeDeleteTest\ChildObject::get()
);
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Grandchild 3'],
],
@ -104,7 +104,7 @@ class CascadeDeleteTest extends SapphireTest
);
// Related objects never deleted
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Related 1'],
['Title' => 'Related 2'],
@ -116,7 +116,7 @@ class CascadeDeleteTest extends SapphireTest
// Ensure that other parents which share cascade deleted objects have the correct result
/** @var CascadeDeleteTest\ChildObject $child2 */
$child2 = $this->objFromFixture(CascadeDeleteTest\ChildObject::class, 'child2');
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Grandchild 3'],
],

16
tests/php/ORM/DBDateTest.php
View File

@ -92,21 +92,21 @@ class DBDateTest extends SapphireTest
);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Invalid date: '3/16/2003'. Use y-MM-dd to prevent this error.
*/
public function testMDYConversion()
{
$this->setExpectedException(
\InvalidArgumentException::class,
"Invalid date: '3/16/2003'. Use " . DBDate::ISO_DATE . " to prevent this error."
);
DBField::create_field('Date', '3/16/2003');
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Invalid date: '03-03-04'. Use y-MM-dd to prevent this error.
*/
public function testY2kCorrection()
{
$this->setExpectedException(
\InvalidArgumentException::class,
"Invalid date: '03-03-04'. Use " . DBDate::ISO_DATE . " to prevent this error."
);
DBField::create_field('Date', '03-03-04');
}

3
tests/php/ORM/DataExtensionTest.php
View File

@ -301,7 +301,8 @@ class DataExtensionTest extends SapphireTest
$this->assertNull($extension->getOwner());
// Another clearOwner should error
$this->setExpectedException("BadMethodCallException", "clearOwner() called more than setOwner()");
$this->expectExceptionMessage(\BadMethodCallException::class);
$this->expectExceptionMessage('clearOwner() called more than setOwner()');
$extension->clearOwner();
}
}

75
tests/php/ORM/DataListTest.php
View File

@ -2,6 +2,7 @@
namespace SilverStripe\ORM\Tests;
use InvalidArgumentException;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Injector\InjectorNotFoundException;
use SilverStripe\ORM\DataList;
@ -88,9 +89,11 @@ class DataListTest extends SapphireTest
$this->assertEquals(2, $newList->Count(), 'List should only contain two objects after subtraction');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testSubtractBadDataclassThrowsException()
{
$this->setExpectedException('InvalidArgumentException');
$teamsComments = TeamComment::get();
$teams = Team::get();
$teamsComments->subtract($teams);
@ -579,12 +582,12 @@ class DataListTest extends SapphireTest
$this->assertEquals('Phil', $list->last()->Name);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Fans is not a linear relation on model SilverStripe\ORM\Tests\DataObjectTest\Player
*/
public function testSortInvalidParameters()
{
$this->setExpectedException(
'InvalidArgumentException',
'Fans is not a linear relation on model '.Player::class
);
$list = Team::get();
$list->sort('Founder.Fans.Surname'); // Can't sort on has_many
}
@ -747,23 +750,24 @@ class DataListTest extends SapphireTest
$this->assertEquals('Bob', $list->first()->Name, 'First comment should be from Bob');
}
/**
* @expectedException \SilverStripe\Core\Injector\InjectorNotFoundException
* @expectedExceptionMessage Class DataListFilter.Bogus does not exist
*/
public function testSimpleFilterWithNonExistingComparisator()
{
$this->setExpectedException(
InjectorNotFoundException::class,
'Class DataListFilter.Bogus does not exist'
);
$list = TeamComment::get();
$list->filter('Comment:Bogus', 'team comment');
}
/**
* Invalid modifiers are treated as failed filter construction
*
* @expectedException \SilverStripe\Core\Injector\InjectorNotFoundException
* @expectedExceptionMessage Class DataListFilter.invalidmodifier does not exist
*/
public function testInvalidModifier()
{
// Invalid modifiers are treated as failed filter construction
$this->setExpectedException(
InjectorNotFoundException::class,
'Class DataListFilter.invalidmodifier does not exist'
);
$list = TeamComment::get();
$list->filter('Comment:invalidmodifier', 'team comment');
}
@ -870,21 +874,21 @@ class DataListTest extends SapphireTest
// grand child can be found from parent
$found = Bracket::get()->filter('Next.Next.Title', $final1->Title);
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => $semifinal1->Title]],
$found
);
// grand child can be found from child
$found = Bracket::get()->filter('Next.Title', $prefinal1->Title);
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => $semifinal1->Title]],
$found
);
// child can be found from parent
$found = Bracket::get()->filter('Next.Title', $final1->Title);
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => $prefinal1->Title],
['Title' => $prefinal2->Title]
@ -895,7 +899,7 @@ class DataListTest extends SapphireTest
// Complex filter, get brackets where the following bracket was won by team 1
// Note: Includes results from multiple levels
$found = Bracket::get()->filter('Next.Winner.Title', $team2->Title);
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => $prefinal1->Title],
['Title' => $prefinal2->Title],
@ -1058,12 +1062,12 @@ class DataListTest extends SapphireTest
$this->assertEquals('007', $list->first()->ShirtNumber);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage MascotAnimal is not a relation on model SilverStripe\ORM\Tests\DataObjectTest\Team
*/
public function testFilterOnInvalidRelation()
{
$this->setExpectedException(
'InvalidArgumentException',
"MascotAnimal is not a relation on model ".Team::class
);
// Filter on missing relation 'MascotAnimal'
Team::get()
->filter('MascotAnimal.Name', 'Richard')
@ -1093,7 +1097,7 @@ class DataListTest extends SapphireTest
// Filter by null email
$nullEmails = $list->filter('Email', null);
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Stephen',
@ -1107,7 +1111,7 @@ class DataListTest extends SapphireTest
// Filter by non-null
$nonNullEmails = $list->filter('Email:not', null);
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Damian',
@ -1126,7 +1130,7 @@ class DataListTest extends SapphireTest
// Filter by empty only
$emptyOnly = $list->filter('Email', '');
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Hamish',
@ -1138,7 +1142,7 @@ class DataListTest extends SapphireTest
// Non-empty only. This should include null values, since ExactMatchFilter works around
// the caveat that != '' also excludes null values in ANSI SQL-92 behaviour.
$nonEmptyOnly = $list->filter('Email:not', '');
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Damian',
@ -1160,7 +1164,7 @@ class DataListTest extends SapphireTest
// Filter by many including null, empty string, and non-empty
$items1 = $list->filter('Email', array(null, '', 'damian@thefans.com'));
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Damian',
@ -1181,7 +1185,7 @@ class DataListTest extends SapphireTest
// Filter exclusion of above list
$items2 = $list->filter('Email:not', array(null, '', 'damian@thefans.com'));
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Richard',
@ -1193,7 +1197,7 @@ class DataListTest extends SapphireTest
// Filter by many including empty string and non-empty
$items3 = $list->filter('Email', array('', 'damian@thefans.com'));
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Damian',
@ -1209,7 +1213,7 @@ class DataListTest extends SapphireTest
// Filter by many including empty string and non-empty
// This also relies no the workaround for null comparison as in the $nonEmptyOnly test
$items4 = $list->filter('Email:not', array('', 'damian@thefans.com'));
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Richard',
@ -1233,7 +1237,7 @@ class DataListTest extends SapphireTest
'Email' => null
)
);
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Richard',
@ -1251,7 +1255,7 @@ class DataListTest extends SapphireTest
// Filter by null or empty values
$items6 = $list->filter('Email', array(null, ''));
$this->assertDOSEquals(
$this->assertListEquals(
array(
array(
'Name' => 'Stephen',
@ -1528,13 +1532,12 @@ class DataListTest extends SapphireTest
/**
* Test exact match filter with empty array items
*
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage Cannot filter "DataObjectTest_TeamComment"."Name" against an empty set
*/
public function testEmptyFilter()
{
$this->setExpectedException(
"InvalidArgumentException",
'Cannot filter "DataObjectTest_TeamComment"."Name" against an empty set'
);
$list = TeamComment::get();
$list->exclude('Name', array());
}

12
tests/php/ORM/DataObjectDuplicationTest.php
View File

@ -183,7 +183,7 @@ class DataObjectDuplicationTest extends SapphireTest
// Duplcating $child should only duplicate grandchild
$childDuplicate = $child->duplicate(true, 'many_many');
$this->assertEquals(0, $childDuplicate->Parents()->count());
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => 'GrandChild']],
$childDuplicate->Children()
);
@ -191,18 +191,18 @@ class DataObjectDuplicationTest extends SapphireTest
// Duplicate belongs_many_many only
$belongsDuplicate = $child->duplicate(true, 'belongs_many_many');
$this->assertEquals(0, $belongsDuplicate->Children()->count());
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => 'Parent']],
$belongsDuplicate->Parents()
);
// Duplicate all
$allDuplicate = $child->duplicate(true, true);
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => 'Parent']],
$allDuplicate->Parents()
);
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => 'GrandChild']],
$allDuplicate->Children()
);
@ -218,14 +218,14 @@ class DataObjectDuplicationTest extends SapphireTest
$three = new DataObjectDuplicationTest\Class3();
$three->text = "Test Text 3";
$one->threes()->add($three);
$this->assertDOSEquals(
$this->assertListEquals(
[['text' => 'Test Text 3']],
$one->threes()
);
// Test duplicate
$dupe = $one->duplicate(false, true);
$this->assertEquals('Test Text 1', $dupe->text);
$this->assertDOSEquals(
$this->assertListEquals(
[['text' => 'Test Text 3']],
$dupe->threes()
);

4
tests/php/ORM/DataObjectSchemaTest.php
View File

@ -2,6 +2,7 @@
namespace SilverStripe\ORM\Tests;
use InvalidArgumentException;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
@ -237,7 +238,8 @@ class DataObjectSchemaTest extends SapphireTest
$this->assertEquals(BaseClass::class, $schema->baseDataClass(GrandChildClass::class));
$this->assertEquals(BaseClass::class, $schema->baseDataClass(ucfirst(GrandChildClass::class)));
$this->setExpectedException('InvalidArgumentException');
$this->expectException(InvalidArgumentException::class);
$schema->baseDataClass(DataObject::class);
}

41
tests/php/ORM/DataObjectTest.php
View File

@ -517,10 +517,10 @@ class DataObjectTest extends SapphireTest
];
// Test the IDs on the DataObjects are set correctly
$this->assertDOSEquals($team1Comments, $team1->Comments());
$this->assertListEquals($team1Comments, $team1->Comments());
// Test that has_many can be infered from the has_one via getNonReciprocalComponent
$this->assertDOSEquals(
$this->assertListEquals(
$team1Comments,
$team1->inferReciprocalComponent(DataObjectTest\TeamComment::class, 'Team')
);
@ -1259,10 +1259,13 @@ class DataObjectTest extends SapphireTest
$this->assertEquals('New and improved team 1', $reloadedTeam1->Title);
}
/**
* @expectedException \SilverStripe\ORM\ValidationException
*/
public function testWritingInvalidDataObjectThrowsException()
{
$validatedObject = new DataObjectTest\ValidatedObject();
$this->setExpectedException(ValidationException::class);
$validatedObject->write();
}
@ -1339,7 +1342,9 @@ class DataObjectTest extends SapphireTest
$this->assertFalse($schema->classHasTable(ViewableData::class));
// Invalid class
$this->setExpectedException(ReflectionException::class, 'Class ThisIsntADataObject does not exist');
$this->expectException(ReflectionException::class);
$this->expectExceptionMessage('Class ThisIsntADataObject does not exist');
$this->assertFalse($schema->classHasTable("ThisIsntADataObject"));
}
@ -1405,24 +1410,30 @@ class DataObjectTest extends SapphireTest
);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testValidateModelDefinitionsFailsWithArray()
{
Config::modify()->merge(DataObjectTest\Team::class, 'has_one', array('NotValid' => array('NoArraysAllowed')));
$this->setExpectedException(InvalidArgumentException::class);
DataObject::getSchema()->hasOneComponent(DataObjectTest\Team::class, 'NotValid');
}
/**
* @expectedException \InvalidArgumentException
*/
public function testValidateModelDefinitionsFailsWithIntKey()
{
Config::modify()->set(DataObjectTest\Team::class, 'has_many', array(0 => DataObjectTest\Player::class));
$this->setExpectedException(InvalidArgumentException::class);
DataObject::getSchema()->hasManyComponent(DataObjectTest\Team::class, 0);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testValidateModelDefinitionsFailsWithIntValue()
{
Config::modify()->merge(DataObjectTest\Team::class, 'many_many', array('Players' => 12));
$this->setExpectedException(InvalidArgumentException::class);
DataObject::getSchema()->manyManyComponent(DataObjectTest\Team::class, 'Players');
}
@ -1448,7 +1459,8 @@ class DataObjectTest extends SapphireTest
$this->assertEquals($changedDO->ClassName, DataObjectTest\SubTeam::class);
// Test invalid classes fail
$this->setExpectedException('InvalidArgumentException', "Controller is not a valid subclass of DataObject");
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Controller is not a valid subclass of DataObject');
/**
* @skipUpgrade
*/
@ -1493,7 +1505,7 @@ class DataObjectTest extends SapphireTest
$this->assertEquals(0, $teamWithoutSponsor->Sponsors()->count());
// Test that belongs_many_many can be infered from with getNonReciprocalComponent
$this->assertDOSEquals(
$this->assertListEquals(
[
['Name' => 'Company corp'],
['Name' => 'Team co.'],
@ -1502,7 +1514,7 @@ class DataObjectTest extends SapphireTest
);
// Test that many_many can be infered from getNonReciprocalComponent
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'Team 1'],
['Title' => 'Team 2'],
@ -1902,7 +1914,7 @@ class DataObjectTest extends SapphireTest
// Test belongs_to can be infered via getNonReciprocalComponent
// Note: Will be returned as has_many since the belongs_to is ignored.
$this->assertDOSEquals(
$this->assertListEquals(
[['Name' => 'New Company']],
$ceo->inferReciprocalComponent(DataObjectTest\Company::class, 'CEO')
);
@ -2078,14 +2090,17 @@ class DataObjectTest extends SapphireTest
$this->assertInstanceOf(DataObjectTest\Player::class, DataObjectTest\Player::get()->first());
// You can't pass arguments to LSB syntax - use the DataList methods instead.
$this->setExpectedException('InvalidArgumentException');
$this->expectException(InvalidArgumentException::class);
DataObjectTest\Player::get(null, "\"ID\" = 1");
}
/**
* @expectedException \InvalidArgumentException
*/
public function testBrokenLateStaticBindingStyle()
{
// If you call DataObject::get() you have to pass a first argument
$this->setExpectedException('InvalidArgumentException');
DataObject::get();
}

16
tests/php/ORM/ManyManyThroughListTest.php
View File

@ -33,7 +33,7 @@ class ManyManyThroughListTest extends SapphireTest
{
/** @var ManyManyThroughListTest\TestObject $parent */
$parent = $this->objFromFixture(ManyManyThroughListTest\TestObject::class, 'parent1');
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'item 1'],
['Title' => 'item 2']
@ -68,7 +68,7 @@ class ManyManyThroughListTest extends SapphireTest
// Test sorting on join table
$items = $parent->Items()->sort('"ManyManyThroughListTest_JoinObject"."Sort"');
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'item 2'],
['Title' => 'item 1'],
@ -77,7 +77,7 @@ class ManyManyThroughListTest extends SapphireTest
);
$items = $parent->Items()->sort('"ManyManyThroughListTest_JoinObject"."Sort" ASC');
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'item 1'],
['Title' => 'item 2'],
@ -85,7 +85,7 @@ class ManyManyThroughListTest extends SapphireTest
$items
);
$items = $parent->Items()->sort('"ManyManyThroughListTest_JoinObject"."Title" DESC');
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'item 2'],
['Title' => 'item 1'],
@ -122,7 +122,7 @@ class ManyManyThroughListTest extends SapphireTest
{
/** @var ManyManyThroughListTest\TestObject $parent */
$parent = $this->objFromFixture(ManyManyThroughListTest\TestObject::class, 'parent1');
$this->assertDOSEquals(
$this->assertListEquals(
[
['Title' => 'item 1'],
['Title' => 'item 2']
@ -131,7 +131,7 @@ class ManyManyThroughListTest extends SapphireTest
);
$item1 = $parent->Items()->filter(['Title' => 'item 1'])->first();
$parent->Items()->remove($item1);
$this->assertDOSEquals(
$this->assertListEquals(
[['Title' => 'item 2']],
$parent->Items()
);
@ -139,6 +139,8 @@ class ManyManyThroughListTest extends SapphireTest
/**
* Test validation
*
* @expectedException \InvalidArgumentException
*/
public function testValidateModelValidatesJoinType()
{
@ -149,7 +151,7 @@ class ManyManyThroughListTest extends SapphireTest
ManyManyThroughListTest\JoinObject::class => 'Text'
]
);
$this->setExpectedException(InvalidArgumentException::class);
DataObject::getSchema()->manyManyComponent(ManyManyThroughListTest\TestObject::class, 'Items');
}

31
tests/php/ORM/PaginatedListTest.php
View File

@ -103,30 +103,33 @@ class PaginatedListTest extends SapphireTest
);
$list->setPageLength(2);
$this->assertDOSEquals(
$this->assertListEquals(
array(array('Num' => 1), array('Num' => 2)),
$list->getIterator()
ArrayList::create($list->getIterator()->getInnerIterator()->getArrayCopy())
);
$list->setCurrentPage(2);
$this->assertDOSEquals(
$this->assertListEquals(
array(array('Num' => 3), array('Num' => 4)),
$list->getIterator()
ArrayList::create($list->getIterator()->getInnerIterator()->getArrayCopy())
);
$list->setCurrentPage(3);
$this->assertDOSEquals(
$this->assertListEquals(
array(array('Num' => 5)),
$list->getIterator()
ArrayList::create($list->getIterator()->getInnerIterator()->getArrayCopy())
);
$list->setCurrentPage(999);
$this->assertDOSEquals(array(), $list->getIterator());
$this->assertListEquals(
array(),
ArrayList::create($list->getIterator()->getInnerIterator()->getArrayCopy())
);
// Test disabled paging
$list->setPageLength(0);
$list->setCurrentPage(1);
$this->assertDOSEquals(
$this->assertListEquals(
[
array('Num' => 1),
array('Num' => 2),
@ -134,7 +137,7 @@ class PaginatedListTest extends SapphireTest
array('Num' => 4),
array('Num' => 5),
],
$list->getIterator()
ArrayList::create($list->getIterator()->getInnerIterator()->getArrayCopy())
);
// Test with dataobjectset
@ -168,21 +171,21 @@ class PaginatedListTest extends SapphireTest
array('PageNum' => 4),
array('PageNum' => 5),
);
$this->assertDOSEquals($expectAll, $list->Pages());
$this->assertListEquals($expectAll, $list->Pages());
$expectLimited = array(
array('PageNum' => 2),
array('PageNum' => 3, 'CurrentBool' => true),
array('PageNum' => 4),
);
$this->assertDOSEquals($expectLimited, $list->Pages(3));
$this->assertListEquals($expectLimited, $list->Pages(3));
// Disable paging
$list->setPageLength(0);
$expectAll = array(
array('PageNum' => 1, 'CurrentBool' => true),
);
$this->assertDOSEquals($expectAll, $list->Pages());
$this->assertListEquals($expectAll, $list->Pages());
}
public function testPaginationSummary()
@ -204,14 +207,14 @@ class PaginatedListTest extends SapphireTest
array('PageNum' => null),
array('PageNum' => 25),
);
$this->assertDOSEquals($expect, $list->PaginationSummary(4));
$this->assertListEquals($expect, $list->PaginationSummary(4));
// Disable paging
$list->setPageLength(0);
$expect = array(
array('PageNum' => 1, 'CurrentBool' => true)
);
$this->assertDOSEquals($expect, $list->PaginationSummary(4));
$this->assertListEquals($expect, $list->PaginationSummary(4));
}
public function testLimitItems()

26
tests/php/ORM/UnsavedRelationListTest.php
View File

@ -55,7 +55,7 @@ class UnsavedRelationListTest extends SapphireTest
$children = $object->Children();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -68,7 +68,7 @@ class UnsavedRelationListTest extends SapphireTest
$this->assertNotEquals($children, $object->Children());
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -89,7 +89,7 @@ class UnsavedRelationListTest extends SapphireTest
$siblings = $object->Siblings();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -102,7 +102,7 @@ class UnsavedRelationListTest extends SapphireTest
$this->assertNotEquals($siblings, $object->Siblings());
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -123,7 +123,7 @@ class UnsavedRelationListTest extends SapphireTest
$children = $object->Children();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -136,7 +136,7 @@ class UnsavedRelationListTest extends SapphireTest
$this->assertNotEquals($children, $object->Children());
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -157,7 +157,7 @@ class UnsavedRelationListTest extends SapphireTest
$children = $object->RelatedObjects();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -170,7 +170,7 @@ class UnsavedRelationListTest extends SapphireTest
$this->assertNotEquals($children, $object->RelatedObjects());
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -191,7 +191,7 @@ class UnsavedRelationListTest extends SapphireTest
$siblings = $object->Siblings();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -204,7 +204,7 @@ class UnsavedRelationListTest extends SapphireTest
$this->assertNotEquals($siblings, $object->Siblings());
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),
@ -225,7 +225,7 @@ class UnsavedRelationListTest extends SapphireTest
$siblings = $object->Siblings();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A', 'Number' => 1),
array('Name' => 'B', 'Number' => 2),
@ -238,7 +238,7 @@ class UnsavedRelationListTest extends SapphireTest
$this->assertNotEquals($siblings, $object->Siblings());
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A', 'Number' => 1),
array('Name' => 'B', 'Number' => 2),
@ -292,7 +292,7 @@ class UnsavedRelationListTest extends SapphireTest
$children = $object->Children();
$this->assertDOSEquals(
$this->assertListEquals(
array(
array('Name' => 'A'),
array('Name' => 'B'),

4
tests/php/i18n/i18nTest.php
View File

@ -296,7 +296,9 @@ class i18nTest extends SapphireTest
);
// Passing in non-associative arrays for placeholders is now an error
$this->setExpectedException(InvalidArgumentException::class, 'Injection must be an associative array');
$this->expectExceptionMessage(InvalidArgumentException::class);
$this->expectExceptionMessage('Injection must be an associative array');
i18n::_t(
$entity, // has {name} placeholders
$default,

21
tests/php/i18n/i18nTextCollectorTest.php
View File

@ -114,10 +114,9 @@ SS;
// Test warning is raised on empty default
$c->setWarnOnEmptyDefault(true);
$this->setExpectedException(
PHPUnit_Framework_Error_Notice::class,
'Missing localisation default for key i18nTestModule.INJECTIONS_3'
);
$this->expectException(PHPUnit_Framework_Error_Notice::class);
$this->expectExceptionMessage('Missing localisation default for key i18nTestModule.INJECTIONS_3');
$c->collectFromTemplate($html, null, $mymodule);
}
@ -190,10 +189,9 @@ SS;
// Test warning is raised on empty default
$c->setWarnOnEmptyDefault(true);
$this->setExpectedException(
PHPUnit_Framework_Error_Notice::class,
'Missing localisation default for key Test.PRIOANDCOMMENT'
);
$this->expectException(PHPUnit_Framework_Error_Notice::class);
$this->expectExceptionMessage('Missing localisation default for key Test.PRIOANDCOMMENT');
$c->collectFromTemplate($html, 'Test', $mymodule);
}
@ -419,10 +417,9 @@ PHP;
$this->assertEquals($expectedArray, $collectedTranslatables);
// Test warning is raised on empty default
$this->setExpectedException(
PHPUnit_Framework_Error_Notice::class,
'Missing localisation default for key i18nTestModule.INJECTIONS4'
);
$this->expectException(PHPUnit_Framework_Error_Notice::class);
$this->expectExceptionMessage('Missing localisation default for key i18nTestModule.INJECTIONS4');
$php = <<<PHP
_t('i18nTestModule.INJECTIONS4', array("name"=>"Cat", "greeting"=>"meow", "goodbye"=>"meow"));
PHP;