Featured image of post PestPHP v3 单元测试：expect() 验证测试资料方法介绍
PHP Unit Test Laravel

PestPHP v3 单元测试：expect() 验证测试资料方法介绍

PestPHP v3 单元测试：expect() 验证测试资料方法介绍

验证测试资料 expect()

Expectations | Pest - The elegant PHP Testing Framework

toBe()

确认两个值是否相等。

expect(1)->toBe(1);
expect('1')->not->toBe(1);
expect(new StdClass())->not->toBe(new StdClass());

toBeBetween()

确认值是否在指定范围内。

expect(2)->toBeBetween(1, 3);
expect(1.5)->toBeBetween(1, 2);
 
$expectationDate = new DateTime('2023-09-22');
$oldestDate = new DateTime('2023-09-21');
$latestDate = new DateTime('2023-09-23');
 
expect($expectationDate)->toBeBetween($oldestDate, $latestDate);

toBeEmpty()

确认值是否为空。

expect('')->toBeEmpty();
expect([])->toBeEmpty();
expect(null)->toBeEmpty();

toBeTrue()

确认值是否为 true。

expect(true)->toBeTrue();
expect(false)->not->toBeTrue();

toBeTruthy()

确认值是否为 true。

expect(true)->toBeTruthy();
expect(false)->not->toBeTruthy();
expect(1)->toBeTruthy();
expect('1')->toBeTruthy();

toBeFalse()

确认值是否为 false。

expect(false)->toBeFalse();
expect(true)->not->toBeFalse();

toBeFalsy()

确认值是否为 false。

expect(false)->toBeFalsy();
expect(true)->not->toBeFalsy();
expect(0)->toBeFalsy();
expect('')->toBeFalsy();

toBeGreaterThan($expected)

确认值是否大于指定值。

expect(2)->toBeGreaterThan(1);
expect(1)->not->toBeGreaterThan(2);

toBeGreaterThanOrEqual($expected)

确认值是否大于或等于指定值。

expect(2)->toBeGreaterThanOrEqual(2);
expect(1)->not->toBeGreaterThanOrEqual(2);

toBeLessThan($expected)

确认值是否小于指定值。

expect(1)->toBeLessThan(2);
expect(2)->not->toBeLessThan(1);

toBeLessThanOrEqual($expected)

确认值是否小于或等于指定值。

expect(1)->toBeLessThanOrEqual(2);
expect(2)->toBeLessThanOrEqual(2);
expect(3)->not->toBeLessThanOrEqual(2);

toContain($needles)

确认值是否包含指定值。

expect('Hello World')->toContain('Hello');
expect('Pest: an elegant PHP Testing Framework')->toContain('Pest', 'PHP', 'Framework');
expect([1, 2, 3])->toContain(2);
expect([1, 2, 3, 4])->toContain(2, 4);

toContainEqual($needles)

确认值是否包含指定值。

expect([1, 2, 3])->toContainEqual(2);
expect([1, 2, 3, 4])->toContainEqual(2, 4);

toContainOnlyInstancesOf($class)

确认值是否包含指定类别的实例。

$dates = [new DateTime(), new DateTime()];
 
expect($dates)->toContainOnlyInstancesOf(DateTime::class);

toHaveCount(int $count)

确认值的数量是否等于指定值。

expect([1, 2, 3])->toHaveCount(3);
expect([1, 2, 3])->not->toHaveCount(2);
expect(['Nuno', 'Luke', 'Alex', 'Dan'])->toHaveCount(4);

toHaveProperty(string $name, $value = null)

确认值是否包含指定属性。

expect($user)->toHaveProperty('name');
expect($user)->toHaveProperty('name', 'Nuno');
expect($user)->toHaveProperty('is_active', 'true');

toHaveProperties(iterable $name)

确认值是否包含指定属性。

expect($user)->toHaveProperties(['name', 'is_active']);
expect($user)->toHaveProperties(['name', 'email']);

expect($user)->toHaveProperties([
    'name' => 'Nuno',
    'email' => 'enunomaduro@gmail.com'
]);

toMatchArray($array)

确认值是否包含指定阵列。

expect([1, 2, 3])->toMatchArray([1, 2, 3]);
expect([1, 2, 3])->not->toMatchArray([1, 2]);

$user = [
    'id'    => 1,
    'name'  => 'Nuno',
    'email' => 'enunomaduro@gmail.com',
    'is_active' => true,
];
 
expect($user)->toMatchArray([
    'email' => 'enunomaduro@gmail.com',
    'name' => 'Nuno'
]);

toMatchObject($object)

确认值是否包含指定物件。

$user = new stdClass();
$user->id = 1;
$user->email = 'enunomaduro@gmail.com';
$user->name = 'Nuno';
 
expect($user)->toMatchObject([
    'email' => 'enunomaduro@gmail.com',
    'name' => 'Nuno'
]);

toEqual($expected)

确认两个值是否相等。

expect(1)->toEqual(1);
expect(1)->not->toEqual(2);
expect($title)->toEqual('Hello World');
expect('1')->toEqual(1);
expect(new StdClass())->toEqual(new StdClass());

toEqualCanonicalizing($expected)

确认两个值是否相等，忽略顺序。

expect('Hello World')->toEqualCanonicalizing('hello world');

$usersAsc = ['Dan', 'Fabio', 'Nuno'];
$usersDesc = ['Nuno', 'Fabio', 'Dan'];
 
expect($usersAsc)->toEqualCanonicalizing($usersDesc);
expect($usersAsc)->not->toEqual($usersDesc);

toEqualWithDelta($expected, float $delta)

允许一定的误差范围。

expect($durationInMinutes)->toEqualWithDelta(10, 5); //duration of 10 minutes with 5 minutes tolerance
 
expect(14)->toEqualWithDelta(10, 5);    // Pass
expect(14)->toEqualWithDelta(10, 0.1); // Fail


expect(1.001)->toEqualWithDelta(1, 0.01);
expect(1.001)->not->toEqualWithDelta(1, 0.001);

toBeIn()

确认值是否在指定范围内。

expect($newUser->status)->toBeIn(['pending', 'new', 'active']);
expect(1)->toBeIn([1, 2, 3]);
expect(4)->not->toBeIn([1, 2, 3]);

toBeInfinite()

确认值是否为无限大。

expect(log(0))->toBeInfinite();
expect(INF)->toBeInfinite();
expect(-INF)->toBeInfinite();
expect(1)->not->toBeInfinite();

toBeInstanceOf($class)

确认值是否为指定类别的实例。

expect($user)->toBeInstanceOf(User::class);
expect(new DateTime())->toBeInstanceOf(DateTime::class);
expect(new stdClass())->not->toBeInstanceOf(DateTime::class);

toBeArray()

确认值是否为阵列。

expect(['Pest','PHP','Laravel'])->toBeArray();
expect([1, 2, 3])->toBeArray();
expect(new stdClass())->not->toBeArray();

toBeBool()

确认值是否为布林值。

expect(true)->toBeBool();
expect(false)->toBeBool();
expect(0)->not->toBeBool();

toBeCallable()

确认值是否为可呼叫的。

expect(fn () => 'Hello World')->toBeCallable();
expect(1)->not->toBeCallable();

$myFunction = function () {};
expect($myFunction)->toBeCallable();

toBeFile()

确认值是否为档案。

expect('/path/to/file.txt')->toBeFile();
expect(1)->not->toBeFile();

toBeFloat()

确认值是否为浮点数。

expect(1.0)->toBeFloat();
expect(1)->not->toBeFloat();

toBeInt()

确认值是否为整数。

expect(1)->toBeInt();
expect(1.0)->not->toBeInt();

toBeIterable()

确认值是否为可迭代的。

expect([1, 2, 3])->toBeIterable();
expect(1)->not->toBeIterable();
expect($array)->toBeIterable();

toBeNumeric()

确认值是否为数字。

expect(1)->toBeNumeric();
expect('1')->toBeNumeric();
expect(1.0)->toBeNumeric();
expect(1.001)->toBeNumeric();
expect(INF)->toBeNumeric();

toBeDigits()

确认值是否为数字。

expect('12345')->toBeDigits();
expect(12345)->toBeDigits();
expect('12345a')->not->toBeDigits();
expect($year)->toBeDigits();
expect(15)->toBeDigits();
expect('15')->toBeDigits();
expect(0.123)->not->toBeDigits();
expect('0.123')->not->toBeDigits();

toBeObject()

确认值是否为物件。

expect(new stdClass())->toBeObject();
expect(1)->not->toBeObject();

toBeResource()

确认值是否为资源。

expect(fopen('/path/to/file.txt', 'r'))->toBeResource();
expect(1)->not->toBeResource();

$handle = fopen('php://memory', 'r+');
expect($handle)->toBeResource();

toBeScalar()

确认是否为纯量值。

expect(1)->toBeScalar();
expect('1')->toBeScalar();
expect(1.0)->toBeScalar();
expect(INF)->toBeScalar();
expect(true)->toBeScalar();
expect([1, '1'])->not->toBeScalar();

toBeString()

确认值是否为字串。

expect('Hello World')->toBeString();
expect(1)->not->toBeString();

toBeJson()

确认值是否为 JSON 格式。

expect('{"name": "Nuno"}')->toBeJson();
expect(1)->not->toBeJson();

toBeNan()

确认值是否为 NaN。

expect(NAN)->toBeNan();
expect(1)->not->toBeNan();
expect(sqrt(-1))->toBeNan();

toBeNull()

确认值是否为 null。

expect(null)->toBeNull();
expect(0)->not->toBeNull();

toHaveKey(string $key)

确认值是否包含指定键。

expect($user)->toHaveKey('name');
expect($user)->toHaveKey('name', 'Nuno');
expect($user)->toHaveKey('is_active', true);
expect(['name' => 'Nuno', 'surname' => 'Maduro'])->toHaveKey('name');
expect(['name' => 'Nuno', 'surname' => 'Maduro'])->toHaveKey('name', 'Nuno');
expect(['user' => ['name' => 'Nuno', 'surname' => 'Maduro']])->toHaveKey('user.name');
expect(['user' => ['name' => 'Nuno', 'surname' => 'Maduro']])->toHaveKey('user.name', 'Nuno');

toHaveKeys(array $keys)

确认值是否包含指定键。

expect($user)->toHaveKeys(['name', 'is_active']);
expect($user)->toHaveKeys(['name', 'email']);
expect(['id' => 1, 'name' => 'Nuno'])->toHaveKeys(['id', 'name']);
expect(['message' => ['from' => 'Nuno', 'to' => 'Luke'] ])->toHaveKeys(['message.from', 'message.to']);

toHaveLength(int $number)

确认值的长度。

expect('Hello World')->toHaveLength(11);
expect([1, 2, 3])->toHaveLength(3);
expect(new stdClass())->not->toHaveLength(0);
expect('Pest')->toHaveLength(4);
expect(['Nuno', 'Maduro'])->toHaveLength(2);

toBeDirectory()

确认值是否为目录。

expect('/path/to/directory')->toBeDirectory();
expect(1)->not->toBeDirectory();
expect('/tmp')->toBeDirectory();

toBeReadableDirectory()

确认值是否为可读目录。

expect('/path/to/directory')->toBeReadableDirectory();
expect(1)->not->toBeReadableDirectory();
expect('/tmp')->toBeReadableDirectory();

toBeReadableFile()

确认值是否为可读档案。

expect('/path/to/file.txt')->toBeReadableFile();
expect(1)->not->toBeReadableFile();
expect('/tmp')->not->toBeReadableFile();

toBeWritableDirectory()

确认值是否为可写目录。

expect('/path/to/directory')->toBeWritableDirectory();
expect(1)->not->toBeWritableDirectory();
expect('/tmp')->toBeWritableDirectory();

toBeWritableFile()

确认值是否为可写档案。

expect('/path/to/file.txt')->toBeWritableFile();
expect(1)->not->toBeWritableFile();
expect('/tmp')->not->toBeWritableFile();

toStartWith(string $expected)

确认值是否以指定字串开头。

expect('Hello World')->toStartWith('Hello');
expect('Hello World')->not->toStartWith('World');

toThrow()

确认值是否抛出指定例外。

expect(fn() => throw new Exception('Error'))->toThrow(Exception::class);
expect(fn() => throw new Exception('Error'))->toThrow(Exception::class, 'Error');
expect(fn() => throw new Exception('Something happened.'))->toThrow(Exception::class);
expect(fn() => throw new Exception('Something happened.'))->toThrow('Something happened.');
expect(fn() => throw new Exception('Something happened.'))->toThrow(Exception::class, 'Something happened.');
expect(fn() => throw new Exception('Something happened.'))->toThrow(new Exception('Something happened.'));

toMatch(string $expression)

确认值是否符合正规表示式。

expect('Hello World')->toMatch('/^Hello/');
expect('Hello World')->not->toMatch('/^World/');
expect('Hello World')->toMatch('/^hello wo.*$/i');

toEndWith(string $expected)

确认值是否以指定字串结尾。

expect('Hello World')->toEndWith('World');
expect('Hello World')->not->toEndWith('Hello');

toMatchConstraint(Constraint $constraint)

确认值是否符合指定限制。

use PHPUnit\Framework\Constraint\IsTrue;
 
expect(true)->toMatchConstraint(new IsTrue());

toBeUppercase(string $expected)

确认值是否为大写。

expect('HELLO WORLD')->toBeUppercase();
expect('Hello World')->not->toBeUppercase();

toBeLowercase(string $expected)

确认值是否为小写。

expect('hello world')->toBeLowercase();
expect('Hello World')->not->toBeLowercase();

toBeAlpha(string $expected)

确认值是否为字母。

expect('Hello World')->toBeAlpha();
expect('Hello World123')->not->toBeAlpha();

toBeAlphaNumeric(string $expected)

确认值是否为字母和数字。

expect('HelloWorld123')->toBeAlphaNumeric();
expect('Hello World123')->not->toBeAlphaNumeric();

toBeSnakeCase()

确认值是否为 SnakeCase 命名。

expect('hello_world')->toBeSnakeCase();
expect('HelloWorld')->not->toBeSnakeCase();

toBeKebabCase()

确认值是否为 KebabCase 命名。

expect('hello-world')->toBeKebabCase();
expect('HelloWorld')->not->toBeKebabCase();

toBeCamelCase()

确认值是否为 CamelCase 命名。

expect('helloWorld')->toBeCamelCase();
expect('hello_world')->not->toBeCamelCase();

toBeStudlyCase()

确认值是否为 StudlyCase 命名。

expect('HelloWorld')->toBeStudlyCase();
expect('hello_world')->not->toBeStudlyCase();

toHaveSnakeCaseKeys()

确认值是否为 SnakeCase 键。

expect(['hello_world' => 'Hello World'])->toHaveSnakeCaseKeys();
expect(['helloWorld' => 'Hello World'])->not->toHaveSnakeCaseKeys();

toHaveKebabCaseKeys()

确认值是否为 KebabCase 键。

expect(['hello-world' => 'Hello World'])->toHaveKebabCaseKeys();
expect(['helloWorld' => 'Hello World'])->not->toHaveKebabCaseKeys();

toHaveCamelCaseKeys()

确认值是否为 CamelCase 键。

expect(['helloWorld' => 'Hello World'])->toHaveCamelCaseKeys();
expect(['hello_world' => 'Hello World'])->not->toHaveCamelCaseKeys();

toHaveStudlyCaseKeys()

确认值是否为 StudlyCase 键。

expect(['HelloWorld' => 'Hello World'])->toHaveStudlyCaseKeys();
expect(['hello_world' => 'Hello World'])->not->toHaveStudlyCaseKeys();

toHaveSameSize($other)

确认值的大小是否相同。

expect([1, 2, 3])->toHaveSameSize([1, 2, 3]);
expect([1, 2, 3])->not->toHaveSameSize([1, 2]);
expect(['foo', 'bar'])->toHaveSameSize(['baz', 'bazz']);

toBeUrl()

确认值是否为 URL。

expect('https://example.com')->toBeUrl();
expect('example.com')->not->toBeUrl();

toBeUuid()

确认值是否为 UUID。

expect('123e4567-e89b-12d3-a456-426614174000')->toBeUuid();
expect('123e4567-e89b-12d3-a456-426614174000')->toBeUuid('v4');
expect('123e4567-e89b-12d3-a456-426614174000')->not->toBeUuid('v3');

and($value)

串接多个限制。

expect($id)->toBe(14)
    ->and($name)->toBe('Nuno');

expect(1)->toEqual(1)
    ->and(2)->toEqual(2);

dd()

输出并终止。

expect(1)->toEqual(1)->dd();

expect(14)->dd(); // 14
expect([1, 2])->sequence(
    fn ($number) => $number->toBe(1),
    fn ($number) => $number->dd(), // 2
);

ddWhen($condition)

当条件成立时，输出并终止。

expect(14)->toEqual(14)->ddWhen(true);
expect(14)->toEqual(14)->not->ddWhen(false);

expect([1, 2])->each(
    fn ($number) => $number->ddWhen(fn (int $number) => $number === 2) // 2
);

ddUnless($condition)

当条件不成立时，输出并终止。

expect(14)->toEqual(14)->ddUnless(false);
expect(14)->toEqual(14)->not->ddUnless(true);

expect([1, 2])->each(
    fn ($number) => $number->ddUnless(fn (int $number) => $number === 1) // 2
);

each()

迭代每个元素。

expect([1, 2])->each(fn ($number) => $number->toBe(1));

expect([1, 2, 3])->each->toBeInt();
expect([1, 2, 3])->each->not->toBeString();
expect([1, 2, 3])->each(fn ($number) => $number->toBeLessThan(4));

json()

确认是否为 JSON 格式。

expect('{"name":"Nuno","credit":1000.00}')
    ->json()
    ->toHaveCount(2)
    ->name->toBe('Nuno')
    ->credit->toBeFloat();
 
expect('not-a-json')->json(); //Fails

match()

确认是否符合条件。

expect($user->miles)
    ->match($user->status, [
        'new'  => fn ($userMiles) => $userMiles->ToBe(0),
        'gold'  => fn ($userMiles) => $userMiles->toBeGreaterThan(500),
        'platinum' => fn ($userMiles) => $userMiles->toBeGreaterThan(1000),
    ]);

expect($user->default_language)
    ->match($user->country, [
        'PT' => 'Português',
        'US' => 'English',
        'TR' => 'Türkçe',
    ]);

not

反向条件。

expect(1)->toEqual(1)->not->toEqual(2);
expect(1)->toEqual(1)->not->toBeLessThan(1);
expect(10)->not->toBeGreaterThan(100);
expect(true)->not->toBeFalse();

ray()

输出并终止。

expect(1)->toEqual(1)->ray();

expect(14)->ray(); // 14
expect([1, 2])->sequence(
    fn ($number) => $number->toBe(1),
    fn ($number) => $number->ray(), // 2
);

sequence()

串接多个限制。

expect([1, 2, 3])->sequence(
    fn ($number) => $number->toBe(1),
    fn ($number) => $number->toBe(2),
    fn ($number) => $number->toBe(3),
);

expect(['hello' => 'world', 'foo' => 'bar', 'john' => 'doe'])->sequence(
    fn ($value, $key) => $value->toEqual('world'),
    fn ($value, $key) => $key->toEqual('foo'),
    fn ($value, $key) => $value->toBeString(),
);

expect(['foo', 'bar', 'baz'])->sequence('foo', 'bar', 'baz');

when()

条件限制。

expect(1)->when(true, fn ($value) => $value->toBe(1));
expect(1)->when(false, fn ($value) => $value->toBe(2));

expect($user)
    ->when($user->is_verified === true, fn ($user) => $user->daily_limit->toBeGreaterThan(10))
    ->email->not->toBeEmpty();

unless()

条件限制。

expect(1)->unless(false, fn ($value) => $value->toBe(1));
expect(1)->unless(true, fn ($value) => $value->toBe(2));

expect($user)
    ->unless($user->is_verified === true, fn ($user) => $user->daily_limit->toBe(10))
    ->email->not->toBeEmpty();

Reference

© 2023 - 2024 Dev TLDRLSS
All rights reserved，未經允許不得隨意轉載
Built with Hugo
主题 Stack 由 Jimmy 设计