php mock,vps 吧,防关联 vps,vlture vps,韩国 cn2 vps

🗣 Wd提问: php mock

🤖 Ai回答:
PHP Mocking Guide

Mocking is a crucial technique in PHP testing that allows you to replace real dependencies with fake implementations、Here's a comprehensive guide to PHP mocking.

Popular Mocking Libraries

1、PHPUnit Mock Objects (Built-in)
php
use PHPUnit\Framework\TestCase;

class UserServiceTest extends TestCase
{
public function testGetUserReturnsUser()
{
// Create a mock of UserRepository
$userRepository = $this-createMock(UserRepository::class);

// Configure the mock
$userRepository-expects($this-once())
-method('findById')
-with($this-equalTo(1))
-willReturn(new User('John Doe'));

// Use the mock
$userService = new UserService($userRepository);
$user = $userService-getUser(1);

$this-assertEquals('John Doe', $user-getName());
}
}

2、Mockery
php
use Mockery\Adapter\Phpunit\MockeryTestCase;

class OrderServiceTest extends MockeryTestCase
{
public function testProcessOrder()
{
// Create a mock
$paymentGateway = \Mockery::mock(PaymentGateway::class);

// Configure expectations
$paymentGateway-shouldReceive('charge')
-once()
-with(100.00, 'credit_card_token')
-andReturn(true);

// Use the mock
$orderService = new OrderService($paymentGateway);
$result = $orderService-processOrder(100.00, 'credit_card_token');

$this-assertTrue($result);
}
}

Common Mocking Patterns

Creating Simple Mocks
php
// PHPUnit
$mock = $this-createMock(ClassName::class);

// Mockery
$mock = \Mockery::mock(ClassName::class);

Configuring Return Values
php
// PHPUnit
$mock-method('methodName')-willReturn('value');

// Mockery
$mock-shouldReceive('methodName')-andReturn('value');

Verifying Method Calls
php
// PHPUnit
$mock-expects($this-once())-method('methodName');

// Mockery
$mock-shouldReceive('methodName')-once();

Mocking with Arguments
php
// PHPUnit
$mock-expects($this-once())
-method('process')
-with($this-equalTo('arg1'), $this-greaterThan(5));

// Mockery
$mock-shouldReceive('process')
-once()
-with('arg1', \Mockery::greaterThan(5));

Practical Examples

Example 1: Testing with Database Dependencies
php
interface UserRepositoryInterface
{
public function findById(int $id): ?User;
public function save(User $user): bool;
}

class UserService
{
private $userRepository;

public function __construct(UserRepositoryInterface $userRepository)
{
$this-userRepository = $userRepository;
}

public function getUserProfile(int $userId): array
{
$user = $this-userRepository-findById($userId);

if (!$user) {
throw new UserNotFoundException(User not found);
}

return [
'id' = $user-getId(),
'name' = $user-getName(),
'email' = $user-getEmail()
];
}
}

// Test
class UserServiceTest extends TestCase
{
public function testGetUserProfileReturnsUserData()
{
$user = new User(1, 'John Doe', 'john@65.hk');

$userRepository = $this-createMock(UserRepositoryInterface::class);
$userRepository-method('findById')
-with(1)
-willReturn($user);

$userService = new UserService($userRepository);
$profile = $userService-getUserProfile(1);

$expected = [
'id' = 1,
'name' = 'John Doe',
'email' = 'john@65.hk'
];

$this-assertEquals($expected, $profile);
}

public function testGetUserProfileThrowsExceptionWhenUserNotFound()
{
$userRepository = $this-createMock(UserRepositoryInterface::class);
$userRepository-method('findById')
-with(999)
-willReturn(null);

$userService = new UserService($userRepository);

$this-expectException(UserNotFoundException::class);
$userService-getUserProfile(999);
}
}

Example 2: Mocking External API Calls
php
interface HttpClientInterface
{
public function get(string $url): Response;
public function post(string $url, array $data): Response;
}

class WeatherService
{
private $httpClient;
private $apiKey;

public function __construct(HttpClientInterface $httpClient, string $apiKey)
{
$this-httpClient = $httpClient;
$this-apiKey = $apiKey;
}

public function getCurrentTemperature(string $city): float
{
$url = http://api.weather.com/v1/current?city={$city}&key={$this-apiKey};
$response = $this-httpClient-get($url);

$data = json_decode($response-getBody(), true);
return $data['temperature'];
}
}

// Test
class WeatherServiceTest extends TestCase
{
public function testGetCurrentTemperatureReturnsCorrectValue()
{
$response = $this-createMock(Response::class);
$response-method('getBody')
-willReturn('{temperature: 25.5, humidity: 60}');

$httpClient = $this-createMock(HttpClientInterface::class);
$httpClient-expects($this-once())
-method('get')
-with('http://api.weather.com/v1/current?city=London&key=test-key')
-willReturn($response);

$weatherService = new WeatherService($httpClient, 'test-key');
$temperature = $weatherService-getCurrentTemperature('London');

$this-assertEquals(25.5, $temperature);
}
}

Example 3: Partial Mocks
php
class Calculator
{
public function add(int $a, int $b): int
{
return $a + $b;
}

public function multiply(int $a, int $b): int
{
return $a * $b;
}

public function calculateArea(int $length, int $width): int
{
// This method uses other methods we might want to mock them
return $this-multiply($length, $width);
}
}

// Test with partial mock
class CalculatorTest extends TestCase
{
public function testCalculateAreaUsesMultiply()
{
$calculator = $this-getMockBuilder(Calculator::class)
-onlyMethods(['multiply'])
-getMock();

$calculator-expects($this-once())
-method('multiply')
-with(5, 3)
-willReturn(15);

$result = $calculator-calculateArea(5, 3);
$this-assertEquals(15, $result);
}
}

Advanced Mocking Techniques

Spies (Verify behavior after execution)
php
// Mockery spy example
public function testEmailIsSentAfterRegistration()
{
$mailer = \Mockery::spy(Mailer::class);

$userService = new UserService($mailer);
$userService-registerUser('john@65.hk', 'password');

// Verify after the fact
$mailer-shouldHaveReceived('sendWelcomeEmail')-once();
}

Stubbing Exceptions
php
// PHPUnit
$mock-method('dangerousMethod')
-willThrowException(new \Exception('Something went wrong'));

// Mockery
$mock-shouldReceive('dangerousMethod')
-andThrow(new \Exception('Something went wrong'));

Mocking Static Methods (with Mockery)
php
// For classes with static methods
\Mockery::mock('alias:Config')
-shouldReceive('get')
-with('database.host')
-andReturn('localhost');

Best Practices

1、Don't mock value objects Create real instances instead
2、Mock roles, not concrete classes Prefer interfaces
3、Keep mocks simple Complex mocks indicate design issues
4、Verify only what's necessary Don't over-specify expectations
5、Use descriptive test names Make it clear what you're testing

Installation

For Mockery:
bash
composer require dev mockery/mockery

PHPUnit is typically included with most PHP projects, but if needed:
bash
composer require dev phpunit/phpunit

This guide covers the essential aspects of PHP mocking、Choose the approach that best fits your testing framework and requirements.

Ai作答

📣 商家广告：