SADM/pest
1
0
Fork 0
mirror of https://github.com/pestphp/pest.git synced 2026-03-07 00:07:22 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into performs_no_expectations

Browse Source 
# Conflicts:
#	src/PendingCalls/TestCall.php
This commit is contained in:
Luke Downing
2022-03-22 13:20:31 +00:00
parent 53c20d9cd2 fca0c8fc0c
commit f3ed9bdf8e
33 changed files with 456 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Bootstrappers/BootFiles.php
View File

@ -48,6 +48,7 @@ final class BootFiles
if (is_dir($filename)) {
$directory = new RecursiveDirectoryIterator($filename);
$iterator = new RecursiveIteratorIterator($directory);
/** @var \DirectoryIterator $file */
foreach ($iterator as $file) {
$this->load($file->__toString());
}

2
src/Concerns/Pipeable.php
View File

@ -43,7 +43,7 @@ trait Pipeable
$this->pipe($name, function ($next, ...$arguments) use ($handler, $filter) {
/* @phpstan-ignore-next-line */
if ($filter($this->value, ...$arguments)) {
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
$handler->bindTo($this, get_class($this))(...$arguments);
return;

19
src/Expectation.php
View File

@ -76,6 +76,22 @@ final class Expectation
return $this->toBeJson()->and($value);
}
/**
* Dump the expectation value.
*
* @return self<TValue>
*/
public function dump(mixed ...$arguments): self
{
if (function_exists('dump')) {
dump($this->value, ...$arguments);
} else {
var_dump($this->value);
}
return $this;
}
/**
* Dump the expectation value and end the script.
*
@ -151,7 +167,6 @@ final class Expectation
throw new BadMethodCallException('Expectation value is not iterable.');
}
//@phpstan-ignore-next-line
$value = is_array($this->value) ? $this->value : iterator_to_array($this->value);
$keys = array_keys($value);
$values = array_values($value);
@ -292,7 +307,7 @@ final class Expectation
private function getExpectationClosure(string $name): Closure
{
if (method_exists(Mixins\Expectation::class, $name)) {
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
return Closure::fromCallable([new Mixins\Expectation($this->value), $name]);
}

30
src/Factories/Annotations/CoversNothing.php Normal file
View File

@ -0,0 +1,30 @@
<?php
declare(strict_types=1);
namespace Pest\Factories\Annotations;
use Pest\Factories\Covers\CoversNothing as CoversNothingFactory;
use Pest\Factories\TestCaseMethodFactory;
/**
* @internal
*/
final class CoversNothing
{
/**
* Adds annotations regarding the "depends" feature.
*
* @param array<int, string> $annotations
*
* @return array<int, string>
*/
public function __invoke(TestCaseMethodFactory $method, array $annotations): array
{
if (($method->covers[0] ?? null) instanceof CoversNothingFactory) {
$annotations[] = '@coversNothing';
}
return $annotations;
}
}

30
src/Factories/Attributes/Attribute.php Normal file
View File

@ -0,0 +1,30 @@
<?php
declare(strict_types=1);
namespace Pest\Factories\Attributes;
use Pest\Factories\TestCaseMethodFactory;
/**
* @internal
*/
abstract class Attribute
{
/**
* Determine if the attribute should be placed above the class instead of above the method.
*
* @var bool
*/
public const ABOVE_CLASS = false;
/**
* @param array<int, string> $attributes
*
* @return array<int, string>
*/
public function __invoke(TestCaseMethodFactory $method, array $attributes): array // @phpstan-ignore-line
{
return $attributes;
}
}

47
src/Factories/Attributes/Covers.php Normal file
View File

@ -0,0 +1,47 @@
<?php
declare(strict_types=1);
namespace Pest\Factories\Attributes;
use Pest\Factories\Covers\CoversClass;
use Pest\Factories\Covers\CoversFunction;
use Pest\Factories\TestCaseMethodFactory;
/**
* @internal
*/
final class Covers extends Attribute
{
/**
* Determine if the attribute should be placed above the classe instead of above the method.
*
* @var bool
*/
public const ABOVE_CLASS = true;
/**
* Adds attributes regarding the "covers" feature.
*
* @param array<int, string> $attributes
*
* @return array<int, string>
*/
public function __invoke(TestCaseMethodFactory $method, array $attributes): array
{
foreach ($method->covers as $covering) {
if ($covering instanceof CoversClass) {
// Prepend a backslash for FQN classes
if (str_contains($covering->class, '\\')) {
$covering->class = '\\' . $covering->class;
}
$attributes[] = "#[\PHPUnit\Framework\Attributes\CoversClass({$covering->class}::class)]";
} elseif ($covering instanceof CoversFunction) {
$attributes[] = "#[\PHPUnit\Framework\Attributes\CoversFunction('{$covering->function}')]";
}
}
return $attributes;
}
}

15
src/Factories/Covers/CoversClass.php Normal file
View File

@ -0,0 +1,15 @@
<?php
declare(strict_types=1);
namespace Pest\Factories\Covers;
/**
* @internal
*/
final class CoversClass
{
public function __construct(public string $class)
{
}
}

15
src/Factories/Covers/CoversFunction.php Normal file
View File

@ -0,0 +1,15 @@
<?php
declare(strict_types=1);
namespace Pest\Factories\Covers;
/**
* @internal
*/
final class CoversFunction
{
public function __construct(public string $function)
{
}
}

12
src/Factories/Covers/CoversNothing.php Normal file
View File

@ -0,0 +1,12 @@
<?php
declare(strict_types=1);
namespace Pest\Factories\Covers;
/**
* @internal
*/
final class CoversNothing
{
}

35
src/Factories/TestCaseFactory.php
View File

@ -33,6 +33,16 @@ final class TestCaseFactory
private static array $annotations = [
Annotations\Depends::class,
Annotations\Groups::class,
Annotations\CoversNothing::class,
];
/**
* The list of attributes.
*
* @var array<int, class-string<\Pest\Factories\Attributes\Attribute>>
*/
private static array $attributes = [
Attributes\Covers::class,
];
/**
@ -141,11 +151,33 @@ final class TestCaseFactory
$classFQN .= $className;
}
$classAvailableAttributes = array_filter(self::$attributes, fn (string $attribute) => $attribute::ABOVE_CLASS);
$methodAvailableAttributes = array_filter(self::$attributes, fn (string $attribute) => !$attribute::ABOVE_CLASS);
$classAttributes = [];
foreach ($classAvailableAttributes as $attribute) {
$classAttributes = array_reduce(
$methods,
fn (array $carry, TestCaseMethodFactory $methodFactory) => (new $attribute())->__invoke($methodFactory, $carry),
$classAttributes
);
}
$methodsCode = implode('', array_map(
fn (TestCaseMethodFactory $methodFactory) => $methodFactory->buildForEvaluation($classFQN, self::$annotations),
fn (TestCaseMethodFactory $methodFactory) => $methodFactory->buildForEvaluation(
$classFQN,
self::$annotations,
$methodAvailableAttributes
),
$methods
));
$classAttributesCode = implode('', array_map(
static fn (string $attribute) => sprintf("\n %s", $attribute),
array_unique($classAttributes),
));
try {
eval("
namespace $namespace;
@ -153,6 +185,7 @@ final class TestCaseFactory
use Pest\Repositories\DatasetsRepository as __PestDatasets;
use Pest\TestSuite as __PestTestSuite;
$classAttributesCode
final class $className extends $baseClass implements $hasPrintableTestCaseClassFQN {
$traitsCode

22
src/Factories/TestCaseMethodFactory.php
View File

@ -47,6 +47,13 @@ final class TestCaseMethodFactory
*/
public array $groups = [];
/**
* The covered classes and functions, if any.
*
* @var array<int, \Pest\Factories\Covers\CoversClass|\Pest\Factories\Covers\CoversFunction|\Pest\Factories\Covers\CoversNothing>
*/
public array $covers = [];
/**
* Creates a new Factory instance.
*/
@ -106,9 +113,10 @@ final class TestCaseMethodFactory
/**
* Creates a PHPUnit method as a string ready for evaluation.
*
* @param array<int, class-string> $annotationsToUse
* @param array<int, class-string> $annotationsToUse
* @param array<int, class-string<\Pest\Factories\Attributes\Attribute>> $attributesToUse
*/
public function buildForEvaluation(string $classFQN, array $annotationsToUse): string
public function buildForEvaluation(string $classFQN, array $annotationsToUse, array $attributesToUse): string
{
if ($this->description === null) {
throw ShouldNotHappen::fromMessage('The test description may not be empty.');
@ -122,12 +130,17 @@ final class TestCaseMethodFactory
$datasetsCode = '';
$annotations = ['@test'];
$attributes = [];
foreach ($annotationsToUse as $annotation) {
/** @phpstan-ignore-next-line */
$annotations = (new $annotation())->__invoke($this, $annotations);
}
foreach ($attributesToUse as $attribute) {
$attributes = (new $attribute())->__invoke($this, $attributes);
}
if (count($this->datasets) > 0) {
$dataProviderName = $methodName . '_dataset';
$annotations[] = "@dataProvider $dataProviderName";
@ -138,10 +151,15 @@ final class TestCaseMethodFactory
static fn ($annotation) => sprintf("\n * %s", $annotation), $annotations,
));
$attributes = implode('', array_map(
static fn ($attribute) => sprintf("\n %s", $attribute), $attributes,
));
return <<<EOF
/**$annotations
*/
$attributes
public function $methodName()
{
return \$this->__runTest(

2
src/Kernel.php
View File

@ -37,7 +37,7 @@ final class Kernel
public static function boot(): self
{
foreach (self::$bootstrappers as $bootstrapper) {
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
(new $bootstrapper())->__invoke();
}

13
src/Mixins/Expectation.php
View File

@ -6,6 +6,7 @@ namespace Pest\Mixins;
use BadMethodCallException;
use Closure;
use Error;
use InvalidArgumentException;
use Pest\Exceptions\InvalidExpectationValue;
use Pest\Support\Arr;
@ -282,7 +283,7 @@ final class Expectation
{
$this->toBeObject();
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
Assert::assertTrue(property_exists($this->value, $name));
if (func_num_args() > 1) {
@ -533,7 +534,7 @@ final class Expectation
{
Assert::assertIsString($this->value);
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
Assert::assertJson($this->value);
return $this;
@ -579,7 +580,7 @@ final class Expectation
try {
Assert::assertTrue(Arr::has($array, $key));
/* @phpstan-ignore-next-line */
/* @phpstan-ignore-next-line */
} catch (ExpectationFailedException $exception) {
throw new ExpectationFailedException("Failed asserting that an array has the key '$key'", $exception->getComparisonFailure());
}
@ -822,8 +823,12 @@ final class Expectation
try {
($this->value)();
} catch (Throwable $e) { // @phpstan-ignore-line
} catch (Throwable $e) {
if (!class_exists($exception)) {
if ($e instanceof Error && $e->getMessage() === "Class \"$exception\" not found") {
throw $e;
}
Assert::assertStringContainsString($exception, $e->getMessage());
return $this;

77
src/PendingCalls/TestCall.php
View File

@ -5,6 +5,10 @@ declare(strict_types=1);
namespace Pest\PendingCalls;
use Closure;
use InvalidArgumentException;
use Pest\Factories\Covers\CoversClass;
use Pest\Factories\Covers\CoversFunction;
use Pest\Factories\Covers\CoversNothing;
use Pest\Factories\TestCaseMethodFactory;
use Pest\Support\Backtrace;
use Pest\Support\HigherOrderCallables;
@ -45,9 +49,11 @@ final class TestCall
/**
* Asserts that the test throws the given `$exceptionClass` when called.
*/
public function throws(string $exception, string $exceptionMessage = null): TestCall
public function throws(string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): TestCall
{
if (class_exists($exception)) {
if (is_int($exception)) {
$exceptionCode = $exception;
} elseif (class_exists($exception)) {
$this->testCaseMethod
->proxies
->add(Backtrace::file(), Backtrace::line(), 'expectException', [$exception]);
@ -61,6 +67,12 @@ final class TestCall
->add(Backtrace::file(), Backtrace::line(), 'expectExceptionMessage', [$exceptionMessage]);
}
if (is_int($exceptionCode)) {
$this->testCaseMethod
->proxies
->add(Backtrace::file(), Backtrace::line(), 'expectExceptionCode', [$exceptionCode]);
}
return $this;
}
@ -69,7 +81,7 @@ final class TestCall
*
* @param (callable(): bool)|bool $condition
*/
public function throwsIf(callable|bool $condition, string $exception, string $exceptionMessage = null): TestCall
public function throwsIf(callable|bool $condition, string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): TestCall
{
$condition = is_callable($condition)
? $condition
@ -78,7 +90,7 @@ final class TestCall
};
if ($condition()) {
return $this->throws($exception, $exceptionMessage);
return $this->throws($exception, $exceptionMessage, $exceptionCode);
}
return $this;
@ -160,6 +172,63 @@ final class TestCall
return $this;
}
/**
* Sets the covered classes or methods.
*/
public function covers(string ...$classesOrFunctions): TestCall
{
foreach ($classesOrFunctions as $classOrFunction) {
$isClass = class_exists($classOrFunction);
$isMethod = function_exists($classOrFunction);
if (!$isClass && !$isMethod) {
throw new InvalidArgumentException(sprintf('No class or method named "%s" has been found.', $classOrFunction));
}
if ($isClass) {
$this->coversClass($classOrFunction);
} else {
$this->coversFunction($classOrFunction);
}
}
return $this;
}
/**
* Sets the covered classes.
*/
public function coversClass(string ...$classes): TestCall
{
foreach ($classes as $class) {
$this->testCaseMethod->covers[] = new CoversClass($class);
}
return $this;
}
/**
* Sets the covered functions.
*/
public function coversFunction(string ...$functions): TestCall
{
foreach ($functions as $function) {
$this->testCaseMethod->covers[] = new CoversFunction($function);
}
return $this;
}
/**
* Sets that the current test covers nothing.
*/
public function coversNothing(): TestCall
{
$this->testCaseMethod->covers = [new CoversNothing()];
return $this;
}
/**
* Informs the test runner that no expectations happen in this test,
* and its purpose is simply to check whether the given code can

6
src/Repositories/DatasetsRepository.php
View File

@ -156,11 +156,11 @@ final class DatasetsRepository
$datasets[$index] = iterator_to_array($datasets[$index]);
}
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
foreach ($datasets[$index] as $key => $values) {
$values = is_array($values) ? $values : [$values];
$processedDataset[] = [
'label' => self::getDatasetDescription($key, $values), //@phpstan-ignore-line
'label' => self::getDatasetDescription($key, $values), // @phpstan-ignore-line
'values' => $values,
];
}
@ -189,7 +189,7 @@ final class DatasetsRepository
$result = $tmp;
}
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
return $result;
}

2
src/Support/Container.php
View File

@ -85,7 +85,7 @@ final class Container
}
}
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
return $this->get($candidate);
},
$constructor->getParameters()

2
src/Support/HigherOrderMessageCollection.php
View File

@ -40,7 +40,7 @@ final class HigherOrderMessageCollection
public function chain(object $target): void
{
foreach ($this->messages as $message) {
//@phpstan-ignore-next-line
// @phpstan-ignore-next-line
$target = $message->call($target) ?? $target;
}
}