370 lines
12 KiB
PHP
370 lines
12 KiB
PHP
<?php
|
|
|
|
namespace think\tests;
|
|
|
|
use Closure;
|
|
use Mockery as m;
|
|
use Mockery\MockInterface;
|
|
use PHPUnit\Framework\TestCase;
|
|
use think\helper\Str;
|
|
use think\Request;
|
|
use think\response\Redirect;
|
|
use think\response\View;
|
|
use think\Route;
|
|
|
|
class RouteTest extends TestCase
|
|
{
|
|
use InteractsWithApp;
|
|
|
|
/** @var Route|MockInterface */
|
|
protected $route;
|
|
|
|
protected function tearDown(): void
|
|
{
|
|
m::close();
|
|
}
|
|
|
|
protected function setUp(): void
|
|
{
|
|
$this->prepareApp();
|
|
|
|
$this->config->shouldReceive('get')->with('route')->andReturn(['url_route_must' => true]);
|
|
$this->route = new Route($this->app);
|
|
}
|
|
|
|
/**
|
|
* @param $path
|
|
* @param string $method
|
|
* @param string $host
|
|
* @return m\Mock|Request
|
|
*/
|
|
protected function makeRequest($path, $method = 'GET', $host = 'localhost')
|
|
{
|
|
$request = m::mock(Request::class)->makePartial();
|
|
$request->shouldReceive('host')->andReturn($host);
|
|
$request->shouldReceive('pathinfo')->andReturn($path);
|
|
$request->shouldReceive('url')->andReturn('/' . $path);
|
|
$request->shouldReceive('method')->andReturn(strtoupper($method));
|
|
return $request;
|
|
}
|
|
|
|
public function testSimpleRequest()
|
|
{
|
|
$this->route->get('foo', function () {
|
|
return 'get-foo';
|
|
});
|
|
|
|
$this->route->put('foo', function () {
|
|
return 'put-foo';
|
|
});
|
|
|
|
$this->route->group(function () {
|
|
$this->route->post('foo', function () {
|
|
return 'post-foo';
|
|
});
|
|
});
|
|
|
|
$request = $this->makeRequest('foo', 'post');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals(200, $response->getCode());
|
|
$this->assertEquals('post-foo', $response->getContent());
|
|
|
|
$request = $this->makeRequest('foo', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals(200, $response->getCode());
|
|
$this->assertEquals('get-foo', $response->getContent());
|
|
}
|
|
|
|
public function testGroup()
|
|
{
|
|
$this->route->group(function () {
|
|
$this->route->group('foo', function () {
|
|
$this->route->post('bar', function () {
|
|
return 'hello,world!';
|
|
});
|
|
});
|
|
});
|
|
|
|
$request = $this->makeRequest('foo/bar', 'post');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals(200, $response->getCode());
|
|
$this->assertEquals('hello,world!', $response->getContent());
|
|
}
|
|
|
|
public function testAllowCrossDomain()
|
|
{
|
|
$this->route->get('foo', function () {
|
|
return 'get-foo';
|
|
})->allowCrossDomain(['some' => 'bar']);
|
|
|
|
$request = $this->makeRequest('foo', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
|
|
$this->assertEquals('bar', $response->getHeader('some'));
|
|
$this->assertArrayHasKey('Access-Control-Allow-Credentials', $response->getHeader());
|
|
|
|
//$this->expectException(RouteNotFoundException::class);
|
|
$request = $this->makeRequest('foo2', 'options');
|
|
$this->route->dispatch($request);
|
|
}
|
|
|
|
public function testControllerDispatch()
|
|
{
|
|
$this->route->get('foo', 'foo/bar');
|
|
|
|
$controller = m::Mock(\stdClass::class);
|
|
|
|
$this->app->shouldReceive('parseClass')->with('controller', 'Foo')->andReturn($controller->mockery_getName());
|
|
$this->app->shouldReceive('make')->with($controller->mockery_getName(), [], true)->andReturn($controller);
|
|
|
|
$controller->shouldReceive('bar')->andReturn('bar');
|
|
|
|
$request = $this->makeRequest('foo');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('bar', $response->getContent());
|
|
}
|
|
|
|
public function testEmptyControllerDispatch()
|
|
{
|
|
$this->route->get('foo', 'foo/bar');
|
|
|
|
$controller = m::Mock(\stdClass::class);
|
|
|
|
$this->app->shouldReceive('parseClass')->with('controller', 'Error')->andReturn($controller->mockery_getName());
|
|
$this->app->shouldReceive('make')->with($controller->mockery_getName(), [], true)->andReturn($controller);
|
|
|
|
$controller->shouldReceive('bar')->andReturn('bar');
|
|
|
|
$request = $this->makeRequest('foo');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('bar', $response->getContent());
|
|
}
|
|
|
|
protected function createMiddleware($times = 1)
|
|
{
|
|
$middleware = m::mock(Str::random(5));
|
|
$middleware->shouldReceive('handle')->times($times)->andReturnUsing(function ($request, Closure $next) {
|
|
return $next($request);
|
|
});
|
|
$this->app->shouldReceive('make')->with($middleware->mockery_getName())->andReturn($middleware);
|
|
|
|
return $middleware;
|
|
}
|
|
|
|
public function testControllerWithMiddleware()
|
|
{
|
|
$this->route->get('foo', 'foo/bar');
|
|
|
|
$controller = m::mock(FooClass::class);
|
|
|
|
$controller->middleware = [
|
|
$this->createMiddleware()->mockery_getName() . ":params1:params2",
|
|
$this->createMiddleware(0)->mockery_getName() => ['except' => 'bar'],
|
|
$this->createMiddleware()->mockery_getName() => ['only' => 'bar'],
|
|
[
|
|
'middleware' => [$this->createMiddleware()->mockery_getName(), [new \stdClass()]],
|
|
'options' => ['only' => 'bar'],
|
|
],
|
|
];
|
|
|
|
$this->app->shouldReceive('parseClass')->with('controller', 'Foo')->andReturn($controller->mockery_getName());
|
|
$this->app->shouldReceive('make')->with($controller->mockery_getName(), [], true)->andReturn($controller);
|
|
|
|
$controller->shouldReceive('bar')->once()->andReturn('bar');
|
|
|
|
$request = $this->makeRequest('foo');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('bar', $response->getContent());
|
|
}
|
|
|
|
public function testRedirectDispatch()
|
|
{
|
|
$this->route->redirect('foo', 'http://localhost', 302);
|
|
|
|
$request = $this->makeRequest('foo');
|
|
$this->app->shouldReceive('make')->with(Request::class)->andReturn($request);
|
|
$response = $this->route->dispatch($request);
|
|
|
|
$this->assertInstanceOf(Redirect::class, $response);
|
|
$this->assertEquals(302, $response->getCode());
|
|
$this->assertEquals('http://localhost', $response->getData());
|
|
}
|
|
|
|
public function testViewDispatch()
|
|
{
|
|
$this->route->view('foo', 'index/hello', ['city' => 'shanghai']);
|
|
|
|
$request = $this->makeRequest('foo');
|
|
$response = $this->route->dispatch($request);
|
|
|
|
$this->assertInstanceOf(View::class, $response);
|
|
$this->assertEquals(['city' => 'shanghai'], $response->getVars());
|
|
$this->assertEquals('index/hello', $response->getData());
|
|
}
|
|
|
|
public function testDomainBindResponse()
|
|
{
|
|
$this->route->domain('test', function () {
|
|
$this->route->get('/', function () {
|
|
return 'Hello,ThinkPHP';
|
|
});
|
|
});
|
|
|
|
$request = $this->makeRequest('', 'get', 'test.domain.com');
|
|
$response = $this->route->dispatch($request);
|
|
|
|
$this->assertEquals('Hello,ThinkPHP', $response->getContent());
|
|
$this->assertEquals(200, $response->getCode());
|
|
}
|
|
|
|
public function testResourceRouting()
|
|
{
|
|
// Test basic resource registration (returns ResourceRegister when not lazy)
|
|
$resource = $this->route->resource('users', 'Users');
|
|
$this->assertTrue($resource instanceof \think\route\Resource || $resource instanceof \think\route\ResourceRegister);
|
|
|
|
// Test REST methods configuration
|
|
$restMethods = $this->route->getRest();
|
|
$this->assertIsArray($restMethods);
|
|
$this->assertArrayHasKey('index', $restMethods);
|
|
$this->assertArrayHasKey('create', $restMethods);
|
|
$this->assertArrayHasKey('save', $restMethods);
|
|
$this->assertArrayHasKey('read', $restMethods);
|
|
$this->assertArrayHasKey('edit', $restMethods);
|
|
$this->assertArrayHasKey('update', $restMethods);
|
|
$this->assertArrayHasKey('delete', $restMethods);
|
|
|
|
// Test custom REST method modification
|
|
$this->route->rest('custom', ['get', '/custom', 'customAction']);
|
|
$customMethod = $this->route->getRest('custom');
|
|
$this->assertEquals(['get', '/custom', 'customAction'], $customMethod);
|
|
}
|
|
|
|
public function testUrlGeneration()
|
|
{
|
|
$this->route->get('user/<id>', 'User/detail')->name('user.detail');
|
|
$this->route->post('user', 'User/save')->name('user.save');
|
|
|
|
$urlBuild = $this->route->buildUrl('user.detail', ['id' => 123]);
|
|
$this->assertInstanceOf(\think\route\Url::class, $urlBuild);
|
|
|
|
$urlBuild = $this->route->buildUrl('user.save');
|
|
$this->assertInstanceOf(\think\route\Url::class, $urlBuild);
|
|
}
|
|
|
|
public function testRouteParameterBinding()
|
|
{
|
|
$this->route->get('user/<id>', function ($id) {
|
|
return "User ID: $id";
|
|
});
|
|
|
|
$request = $this->makeRequest('user/123', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('User ID: 123', $response->getContent());
|
|
|
|
// Test multiple parameters
|
|
$this->route->get('post/<year>/<month>', function ($year, $month) {
|
|
return "Year: $year, Month: $month";
|
|
});
|
|
|
|
$request = $this->makeRequest('post/2024/12', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('Year: 2024, Month: 12', $response->getContent());
|
|
}
|
|
|
|
public function testRoutePatternValidation()
|
|
{
|
|
$this->route->get('user/<id>', function ($id) {
|
|
return "User ID: $id";
|
|
})->pattern(['id' => '\d+']);
|
|
|
|
// Valid numeric ID
|
|
$request = $this->makeRequest('user/123', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('User ID: 123', $response->getContent());
|
|
|
|
// Test pattern with name validation
|
|
$this->route->get('profile/<name>', function ($name) {
|
|
return "Profile: $name";
|
|
})->pattern(['name' => '[a-zA-Z]+']);
|
|
|
|
$request = $this->makeRequest('profile/john', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('Profile: john', $response->getContent());
|
|
}
|
|
|
|
public function testMissRoute()
|
|
{
|
|
$this->route->get('home', function () {
|
|
return 'home page';
|
|
});
|
|
|
|
$this->route->miss(function () {
|
|
return 'Page not found';
|
|
});
|
|
|
|
// Test existing route
|
|
$request = $this->makeRequest('home', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('home page', $response->getContent());
|
|
|
|
// Test miss route
|
|
$request = $this->makeRequest('nonexistent', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('Page not found', $response->getContent());
|
|
}
|
|
|
|
public function testRouteMiddleware()
|
|
{
|
|
$middleware = $this->createMiddleware();
|
|
|
|
$this->route->get('protected', function () {
|
|
return 'protected content';
|
|
})->middleware($middleware->mockery_getName());
|
|
|
|
$request = $this->makeRequest('protected', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('protected content', $response->getContent());
|
|
}
|
|
|
|
public function testRouteOptions()
|
|
{
|
|
$this->route->get('api/<version>/users', function ($version) {
|
|
return "API Version: $version";
|
|
})->option(['version' => '1.0']);
|
|
|
|
$request = $this->makeRequest('api/v2/users', 'get');
|
|
$response = $this->route->dispatch($request);
|
|
$this->assertEquals('API Version: v2', $response->getContent());
|
|
}
|
|
|
|
public function testRouteCache()
|
|
{
|
|
// Test route configuration
|
|
$config = $this->route->config();
|
|
$this->assertIsArray($config);
|
|
|
|
$caseConfig = $this->route->config('url_case_sensitive');
|
|
$this->assertIsBool($caseConfig);
|
|
|
|
// Test route name management
|
|
$this->route->get('test', function () {
|
|
return 'test';
|
|
})->name('test.route');
|
|
|
|
$names = $this->route->getName('test.route');
|
|
$this->assertIsArray($names);
|
|
}
|
|
|
|
}
|
|
|
|
class FooClass
|
|
{
|
|
public $middleware = [];
|
|
|
|
public function bar()
|
|
{
|
|
|
|
}
|
|
}
|