2013-01-10 15:28:59 -06:00
|
|
|
<?php
|
|
|
|
|
|
2017-01-17 14:30:19 +00:00
|
|
|
namespace Illuminate\Tests\Http;
|
|
|
|
|
|
2026-03-06 16:23:29 +01:00
|
|
|
use Carbon\CarbonInterval;
|
|
|
|
|
use Carbon\Unit;
|
2013-01-10 15:28:59 -06:00
|
|
|
use Illuminate\Http\Request;
|
2019-09-10 17:16:05 +02:00
|
|
|
use Illuminate\Http\UploadedFile;
|
2015-09-30 21:58:35 -03:00
|
|
|
use Illuminate\Routing\Route;
|
2018-10-05 14:48:10 +02:00
|
|
|
use Illuminate\Session\Store;
|
2021-12-17 12:23:31 -03:00
|
|
|
use Illuminate\Support\Carbon;
|
2021-09-17 12:53:28 -05:00
|
|
|
use Illuminate\Support\Collection;
|
2023-02-12 23:33:50 +09:00
|
|
|
use Illuminate\Support\Stringable;
|
2022-04-06 20:03:13 +01:00
|
|
|
use Illuminate\Tests\Database\Fixtures\Models\Money\Price;
|
2021-12-17 12:23:31 -03:00
|
|
|
use InvalidArgumentException;
|
2019-09-10 17:16:05 +02:00
|
|
|
use Mockery as m;
|
2023-10-26 22:09:14 +08:00
|
|
|
use PHPUnit\Framework\Attributes\DataProvider;
|
2016-12-30 21:31:11 +01:00
|
|
|
use PHPUnit\Framework\TestCase;
|
2019-09-10 17:16:05 +02:00
|
|
|
use RuntimeException;
|
2022-01-15 14:59:57 +00:00
|
|
|
use Symfony\Component\HttpFoundation\Exception\SessionNotFoundException;
|
2018-10-05 14:48:10 +02:00
|
|
|
use Symfony\Component\HttpFoundation\File\UploadedFile as SymfonyUploadedFile;
|
2023-07-26 13:12:33 +10:00
|
|
|
use Symfony\Component\HttpFoundation\InputBag;
|
2019-09-10 17:16:05 +02:00
|
|
|
use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
|
2022-01-15 14:59:57 +00:00
|
|
|
use Symfony\Component\HttpFoundation\Session\SessionInterface;
|
2013-01-10 15:28:59 -06:00
|
|
|
|
2023-09-15 15:17:52 +02:00
|
|
|
include_once 'Enums.php';
|
2022-07-17 17:13:12 +03:00
|
|
|
|
2016-12-30 21:31:11 +01:00
|
|
|
class HttpRequestTest extends TestCase
|
2015-06-01 16:26:53 +01:00
|
|
|
{
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testInstanceMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('');
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertSame($request, $request->instance());
|
|
|
|
|
}
|
2014-02-27 19:30:59 +00:00
|
|
|
|
2016-02-25 21:04:11 +01:00
|
|
|
public function testMethodMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('', 'GET');
|
|
|
|
|
$this->assertSame('GET', $request->method());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('', 'HEAD');
|
|
|
|
|
$this->assertSame('HEAD', $request->method());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('', 'POST');
|
|
|
|
|
$this->assertSame('POST', $request->method());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('', 'PUT');
|
|
|
|
|
$this->assertSame('PUT', $request->method());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('', 'PATCH');
|
|
|
|
|
$this->assertSame('PATCH', $request->method());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('', 'DELETE');
|
|
|
|
|
$this->assertSame('DELETE', $request->method());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('', 'OPTIONS');
|
|
|
|
|
$this->assertSame('OPTIONS', $request->method());
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testRootMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('http://example.com/foo/bar/script.php?test');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('http://example.com', $request->root());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
2013-01-10 15:28:59 -06:00
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testPathMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('/', $request->path());
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/foo/bar');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('foo/bar', $request->path());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testDecodedPathMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/foo%20bar');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('foo bar', $request->decodedPath());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2023-10-26 22:09:14 +08:00
|
|
|
#[DataProvider('segmentProvider')]
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testSegmentMethod($path, $segment, $expected)
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create($path);
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertEquals($expected, $request->segment($segment, 'default'));
|
|
|
|
|
}
|
|
|
|
|
|
2022-11-23 05:10:22 +08:00
|
|
|
public static function segmentProvider()
|
2015-06-01 15:56:31 +01:00
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
return [
|
|
|
|
|
['', 1, 'default'],
|
2018-07-26 22:28:48 +07:00
|
|
|
['foo/bar//baz', 1, 'foo'],
|
|
|
|
|
['foo/bar//baz', 2, 'bar'],
|
|
|
|
|
['foo/bar//baz', 3, 'baz'],
|
2015-06-01 16:35:44 +01:00
|
|
|
];
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2023-10-26 22:09:14 +08:00
|
|
|
#[DataProvider('segmentsProvider')]
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testSegmentsMethod($path, $expected)
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create($path);
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertEquals($expected, $request->segments());
|
|
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('foo/bar');
|
2015-06-01 16:35:44 +01:00
|
|
|
$this->assertEquals(['foo', 'bar'], $request->segments());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2022-11-23 05:10:22 +08:00
|
|
|
public static function segmentsProvider()
|
2015-06-01 15:56:31 +01:00
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
return [
|
|
|
|
|
['', []],
|
|
|
|
|
['foo/bar', ['foo', 'bar']],
|
|
|
|
|
['foo/bar//baz', ['foo', 'bar', 'baz']],
|
|
|
|
|
['foo/0/bar', ['foo', '0', 'bar']],
|
|
|
|
|
];
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testUrlMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('http://foo.com/foo/bar', $request->url());
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://foo.com/foo/bar/?');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('http://foo.com/foo/bar', $request->url());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFullUrlMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('http://foo.com/foo/bar?name=taylor', $request->fullUrl());
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://foo.com');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('https://foo.com', $request->fullUrl());
|
2016-02-10 15:58:35 +02:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://foo.com');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('https://foo.com/?coupon=foo', $request->fullUrlWithQuery(['coupon' => 'foo']));
|
2016-02-24 10:26:04 -06:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://foo.com?a=b');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('https://foo.com/?a=b', $request->fullUrl());
|
2016-02-24 10:26:04 -06:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://foo.com?a=b');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('https://foo.com/?a=b&coupon=foo', $request->fullUrlWithQuery(['coupon' => 'foo']));
|
2016-02-24 20:26:45 +00:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://foo.com?a=b');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('https://foo.com/?a=c', $request->fullUrlWithQuery(['a' => 'c']));
|
2016-06-16 18:55:47 +05:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('http://foo.com/foo/bar?name=taylor', $request->fullUrlWithQuery(['name' => 'taylor']));
|
2016-06-16 18:55:47 +05:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://foo.com/foo/bar/?name=taylor');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('http://foo.com/foo/bar?name=graham', $request->fullUrlWithQuery(['name' => 'graham']));
|
2018-04-30 16:55:49 -06:00
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://foo.com');
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('https://foo.com/?key=value%20with%20spaces', $request->fullUrlWithQuery(['key' => 'value with spaces']));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2026-02-14 17:05:39 +03:30
|
|
|
public function testFullUrlWithoutQueryMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor&age=30');
|
|
|
|
|
$this->assertSame('http://foo.com/foo/bar?age=30', $request->fullUrlWithoutQuery('name'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor&age=30');
|
|
|
|
|
$this->assertSame('http://foo.com/foo/bar?age=30', $request->fullUrlWithoutQuery(['name']));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor&age=30&city=nyc');
|
|
|
|
|
$this->assertSame('http://foo.com/foo/bar?city=nyc', $request->fullUrlWithoutQuery(['name', 'age']));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://foo.com/foo/bar?name=taylor');
|
|
|
|
|
$this->assertSame('http://foo.com/foo/bar', $request->fullUrlWithoutQuery('name'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://foo.com/foo/bar');
|
|
|
|
|
$this->assertSame('http://foo.com/foo/bar', $request->fullUrlWithoutQuery('name'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://foo.com?a=b&c=d');
|
|
|
|
|
$this->assertSame('https://foo.com/?c=d', $request->fullUrlWithoutQuery('a'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://foo.com/?name=taylor&age=30');
|
|
|
|
|
$this->assertSame('https://foo.com/?age=30', $request->fullUrlWithoutQuery('name'));
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testIsMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/foo/bar');
|
2015-06-01 15:56:31 +01:00
|
|
|
|
|
|
|
|
$this->assertTrue($request->is('foo*'));
|
|
|
|
|
$this->assertFalse($request->is('bar*'));
|
|
|
|
|
$this->assertTrue($request->is('*bar*'));
|
|
|
|
|
$this->assertTrue($request->is('bar*', 'foo*', 'baz'));
|
|
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2015-06-01 15:56:31 +01:00
|
|
|
|
|
|
|
|
$this->assertTrue($request->is('/'));
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-05 22:45:53 +01:00
|
|
|
public function testFullUrlIsMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://example.com/foo/bar');
|
2018-01-05 22:45:53 +01:00
|
|
|
|
|
|
|
|
$this->assertTrue($request->fullUrlIs('http://example.com/foo/bar'));
|
|
|
|
|
$this->assertFalse($request->fullUrlIs('example.com*'));
|
|
|
|
|
$this->assertTrue($request->fullUrlIs('http://*'));
|
|
|
|
|
$this->assertTrue($request->fullUrlIs('*foo*'));
|
|
|
|
|
$this->assertTrue($request->fullUrlIs('*bar'));
|
|
|
|
|
$this->assertTrue($request->fullUrlIs('*'));
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-16 10:26:00 +03:00
|
|
|
public function testRouteIsMethod()
|
2017-05-15 01:44:59 -04:00
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/foo/bar');
|
2017-05-15 01:44:59 -04:00
|
|
|
|
2017-05-23 07:28:35 +02:00
|
|
|
$this->assertFalse($request->routeIs('foo.bar'));
|
|
|
|
|
|
2017-05-15 01:44:59 -04:00
|
|
|
$request->setRouteResolver(function () use ($request) {
|
|
|
|
|
$route = new Route('GET', '/foo/bar', ['as' => 'foo.bar']);
|
|
|
|
|
$route->bind($request);
|
|
|
|
|
|
|
|
|
|
return $route;
|
|
|
|
|
});
|
|
|
|
|
|
2017-05-15 12:27:51 -05:00
|
|
|
$this->assertTrue($request->routeIs('foo.bar'));
|
2017-05-18 22:34:12 +02:00
|
|
|
$this->assertTrue($request->routeIs('foo*', '*bar'));
|
2017-05-15 12:27:51 -05:00
|
|
|
$this->assertFalse($request->routeIs('foo.foo'));
|
2017-05-15 01:44:59 -04:00
|
|
|
}
|
|
|
|
|
|
2018-02-17 18:52:11 -05:00
|
|
|
public function testRouteMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/foo/bar');
|
2018-02-17 18:52:11 -05:00
|
|
|
|
|
|
|
|
$request->setRouteResolver(function () use ($request) {
|
|
|
|
|
$route = new Route('GET', '/foo/{required}/{optional?}', []);
|
|
|
|
|
$route->bind($request);
|
|
|
|
|
|
|
|
|
|
return $route;
|
|
|
|
|
});
|
|
|
|
|
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('bar', $request->route('required'));
|
|
|
|
|
$this->assertSame('bar', $request->route('required', 'default'));
|
2018-02-17 18:52:11 -05:00
|
|
|
$this->assertNull($request->route('optional'));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('default', $request->route('optional', 'default'));
|
2018-02-17 18:52:11 -05:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testAjaxMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertFalse($request->ajax());
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'], '{}');
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->ajax());
|
|
|
|
|
$request = Request::create('/', 'POST');
|
|
|
|
|
$request->headers->set('X-Requested-With', 'XMLHttpRequest');
|
|
|
|
|
$this->assertTrue($request->ajax());
|
|
|
|
|
$request->headers->set('X-Requested-With', '');
|
|
|
|
|
$this->assertFalse($request->ajax());
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-31 16:01:12 +01:00
|
|
|
public function testPrefetchMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2018-12-31 16:01:12 +01:00
|
|
|
$this->assertFalse($request->prefetch());
|
|
|
|
|
|
|
|
|
|
$request->server->set('HTTP_X_MOZ', '');
|
|
|
|
|
$this->assertFalse($request->prefetch());
|
|
|
|
|
$request->server->set('HTTP_X_MOZ', 'prefetch');
|
|
|
|
|
$this->assertTrue($request->prefetch());
|
|
|
|
|
$request->server->set('HTTP_X_MOZ', 'Prefetch');
|
|
|
|
|
$this->assertTrue($request->prefetch());
|
|
|
|
|
|
|
|
|
|
$request->server->remove('HTTP_X_MOZ');
|
|
|
|
|
|
|
|
|
|
$request->headers->set('Purpose', '');
|
|
|
|
|
$this->assertFalse($request->prefetch());
|
|
|
|
|
$request->headers->set('Purpose', 'prefetch');
|
|
|
|
|
$this->assertTrue($request->prefetch());
|
|
|
|
|
$request->headers->set('Purpose', 'Prefetch');
|
|
|
|
|
$this->assertTrue($request->prefetch());
|
2023-11-06 21:49:50 +00:00
|
|
|
|
|
|
|
|
$request->headers->remove('Purpose');
|
|
|
|
|
|
|
|
|
|
$request->headers->set('Sec-Purpose', '');
|
|
|
|
|
$this->assertFalse($request->prefetch());
|
|
|
|
|
$request->headers->set('Sec-Purpose', 'prefetch');
|
|
|
|
|
$this->assertTrue($request->prefetch());
|
|
|
|
|
$request->headers->set('Sec-Purpose', 'Prefetch');
|
|
|
|
|
$this->assertTrue($request->prefetch());
|
2018-12-31 16:01:12 +01:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testPjaxMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_X_PJAX' => 'true'], '{}');
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->pjax());
|
|
|
|
|
$request->headers->set('X-PJAX', 'false');
|
|
|
|
|
$this->assertTrue($request->pjax());
|
|
|
|
|
$request->headers->set('X-PJAX', null);
|
|
|
|
|
$this->assertFalse($request->pjax());
|
|
|
|
|
$request->headers->set('X-PJAX', '');
|
|
|
|
|
$this->assertFalse($request->pjax());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testSecureMethod()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('http://example.com');
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertFalse($request->secure());
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('https://example.com');
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->secure());
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-02 10:10:06 -03:00
|
|
|
public function testUserAgentMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], [
|
|
|
|
|
'HTTP_USER_AGENT' => 'Laravel',
|
|
|
|
|
]);
|
|
|
|
|
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Laravel', $request->userAgent());
|
2017-08-02 10:10:06 -03:00
|
|
|
}
|
|
|
|
|
|
2022-06-14 09:12:36 +09:00
|
|
|
public function testHostMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('http://example.com');
|
|
|
|
|
$this->assertSame('example.com', $request->host());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://example.com');
|
|
|
|
|
$this->assertSame('example.com', $request->host());
|
2022-09-08 18:25:22 +04:30
|
|
|
|
|
|
|
|
$request = Request::create('https://example.com:8080');
|
|
|
|
|
$this->assertSame('example.com', $request->host());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://example.com:8080');
|
|
|
|
|
$this->assertSame('example.com', $request->host());
|
2022-06-14 09:12:36 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testHttpHostMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('http://example.com');
|
|
|
|
|
$this->assertSame('example.com', $request->httpHost());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://example.com');
|
|
|
|
|
$this->assertSame('example.com', $request->httpHost());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://example.com:8080');
|
|
|
|
|
$this->assertSame('example.com:8080', $request->httpHost());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://example.com:8080');
|
|
|
|
|
$this->assertSame('example.com:8080', $request->httpHost());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testSchemeAndHttpHostMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('http://example.com');
|
|
|
|
|
$this->assertSame('http://example.com', $request->schemeAndHttpHost());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://example.com');
|
|
|
|
|
$this->assertSame('https://example.com', $request->schemeAndHttpHost());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('http://example.com:8080');
|
|
|
|
|
$this->assertSame('http://example.com:8080', $request->schemeAndHttpHost());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('https://example.com:8080');
|
|
|
|
|
$this->assertSame('https://example.com:8080', $request->schemeAndHttpHost());
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-07 18:15:09 +02:00
|
|
|
public function testHasMethod()
|
2015-06-01 15:56:31 +01:00
|
|
|
{
|
2017-04-07 18:15:09 +02:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
$this->assertTrue($request->has('name'));
|
|
|
|
|
$this->assertTrue($request->has('age'));
|
|
|
|
|
$this->assertTrue($request->has('city'));
|
|
|
|
|
$this->assertFalse($request->has('foo'));
|
|
|
|
|
$this->assertFalse($request->has('name', 'email'));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->has('name'));
|
|
|
|
|
$this->assertTrue($request->has('name', 'email'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertTrue($request->has(['name', 'email']));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar', 'bar']]);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->has('foo'));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => '', 'bar' => null]);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->has('foo'));
|
|
|
|
|
$this->assertTrue($request->has('bar'));
|
2016-08-06 16:08:02 +02:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar' => null, 'baz' => '']]);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->has('foo.bar'));
|
|
|
|
|
$this->assertTrue($request->has('foo.baz'));
|
2019-10-18 15:07:46 +02:00
|
|
|
}
|
|
|
|
|
|
2020-08-12 23:39:44 +02:00
|
|
|
public function testWhenHasMethod()
|
2020-08-11 22:42:45 +02:00
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
|
2021-07-19 20:24:28 +02:00
|
|
|
$name = $age = $city = $foo = $bar = false;
|
2020-08-11 22:42:45 +02:00
|
|
|
|
2020-08-12 23:39:44 +02:00
|
|
|
$request->whenHas('name', function ($value) use (&$name) {
|
2020-08-11 22:42:45 +02:00
|
|
|
$name = $value;
|
|
|
|
|
});
|
|
|
|
|
|
2020-08-12 23:39:44 +02:00
|
|
|
$request->whenHas('age', function ($value) use (&$age) {
|
2020-08-11 22:42:45 +02:00
|
|
|
$age = $value;
|
|
|
|
|
});
|
|
|
|
|
|
2020-08-12 23:39:44 +02:00
|
|
|
$request->whenHas('city', function ($value) use (&$city) {
|
2020-08-11 22:42:45 +02:00
|
|
|
$city = $value;
|
|
|
|
|
});
|
|
|
|
|
|
2020-08-12 23:39:44 +02:00
|
|
|
$request->whenHas('foo', function () use (&$foo) {
|
2020-08-11 22:42:45 +02:00
|
|
|
$foo = 'test';
|
|
|
|
|
});
|
|
|
|
|
|
2021-07-19 20:24:28 +02:00
|
|
|
$request->whenHas('bar', function () use (&$bar) {
|
|
|
|
|
$bar = 'test';
|
|
|
|
|
}, function () use (&$bar) {
|
|
|
|
|
$bar = true;
|
|
|
|
|
});
|
|
|
|
|
|
2020-08-11 22:42:45 +02:00
|
|
|
$this->assertSame('Taylor', $name);
|
|
|
|
|
$this->assertSame('', $age);
|
|
|
|
|
$this->assertNull($city);
|
2020-08-12 23:39:44 +02:00
|
|
|
$this->assertFalse($foo);
|
2021-07-19 20:24:28 +02:00
|
|
|
$this->assertTrue($bar);
|
2020-08-12 23:39:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testWhenFilledMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
|
2021-07-19 20:24:28 +02:00
|
|
|
$name = $age = $city = $foo = $bar = false;
|
2020-08-12 23:39:44 +02:00
|
|
|
|
|
|
|
|
$request->whenFilled('name', function ($value) use (&$name) {
|
|
|
|
|
$name = $value;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenFilled('age', function ($value) use (&$age) {
|
|
|
|
|
$age = 'test';
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenFilled('city', function ($value) use (&$city) {
|
|
|
|
|
$city = 'test';
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenFilled('foo', function () use (&$foo) {
|
|
|
|
|
$foo = 'test';
|
|
|
|
|
});
|
|
|
|
|
|
2021-07-19 20:24:28 +02:00
|
|
|
$request->whenFilled('bar', function () use (&$bar) {
|
|
|
|
|
$bar = 'test';
|
|
|
|
|
}, function () use (&$bar) {
|
|
|
|
|
$bar = true;
|
|
|
|
|
});
|
|
|
|
|
|
2020-08-12 23:39:44 +02:00
|
|
|
$this->assertSame('Taylor', $name);
|
|
|
|
|
$this->assertFalse($age);
|
|
|
|
|
$this->assertFalse($city);
|
|
|
|
|
$this->assertFalse($foo);
|
2021-07-19 20:24:28 +02:00
|
|
|
$this->assertTrue($bar);
|
2020-08-11 22:42:45 +02:00
|
|
|
}
|
|
|
|
|
|
2019-10-18 15:07:46 +02:00
|
|
|
public function testMissingMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
$this->assertFalse($request->missing('name'));
|
|
|
|
|
$this->assertFalse($request->missing('age'));
|
|
|
|
|
$this->assertFalse($request->missing('city'));
|
|
|
|
|
$this->assertTrue($request->missing('foo'));
|
|
|
|
|
$this->assertTrue($request->missing('name', 'email'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertTrue($request->missing(['name', 'email']));
|
2019-10-18 15:07:46 +02:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
|
|
|
|
$this->assertFalse($request->missing('name'));
|
|
|
|
|
$this->assertFalse($request->missing('name', 'email'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar', 'bar']]);
|
|
|
|
|
$this->assertFalse($request->missing('foo'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => '', 'bar' => null]);
|
|
|
|
|
$this->assertFalse($request->missing('foo'));
|
|
|
|
|
$this->assertFalse($request->missing('bar'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar' => null, 'baz' => '']]);
|
|
|
|
|
$this->assertFalse($request->missing('foo.bar'));
|
|
|
|
|
$this->assertFalse($request->missing('foo.baz'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2022-11-19 19:46:43 +01:00
|
|
|
public function testWhenMissingMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['bar' => null]);
|
|
|
|
|
|
|
|
|
|
$name = $age = $city = $foo = $bar = true;
|
|
|
|
|
|
|
|
|
|
$request->whenMissing('name', function ($value) use (&$name) {
|
|
|
|
|
$name = 'Taylor';
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenMissing('age', function ($value) use (&$age) {
|
|
|
|
|
$age = '';
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenMissing('city', function ($value) use (&$city) {
|
|
|
|
|
$city = null;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenMissing('foo', function () use (&$foo) {
|
|
|
|
|
$foo = false;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$request->whenMissing('bar', function () use (&$bar) {
|
|
|
|
|
$bar = 'test';
|
|
|
|
|
}, function () use (&$bar) {
|
|
|
|
|
$bar = true;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$this->assertSame('Taylor', $name);
|
|
|
|
|
$this->assertSame('', $age);
|
|
|
|
|
$this->assertNull($city);
|
|
|
|
|
$this->assertFalse($foo);
|
|
|
|
|
$this->assertTrue($bar);
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-28 03:29:23 +02:00
|
|
|
public function testHasAnyMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
$this->assertTrue($request->hasAny('name'));
|
|
|
|
|
$this->assertTrue($request->hasAny('age'));
|
|
|
|
|
$this->assertTrue($request->hasAny('city'));
|
|
|
|
|
$this->assertFalse($request->hasAny('foo'));
|
|
|
|
|
$this->assertTrue($request->hasAny('name', 'email'));
|
2018-01-29 18:37:01 +02:00
|
|
|
$this->assertTrue($request->hasAny(['name', 'email']));
|
2017-05-28 03:29:23 +02:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
|
|
|
|
$this->assertTrue($request->hasAny('name', 'email'));
|
|
|
|
|
$this->assertFalse($request->hasAny('surname', 'password'));
|
2018-01-29 18:37:01 +02:00
|
|
|
$this->assertFalse($request->hasAny(['surname', 'password']));
|
2017-05-28 03:29:23 +02:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar' => null, 'baz' => '']]);
|
|
|
|
|
$this->assertTrue($request->hasAny('foo.bar'));
|
|
|
|
|
$this->assertTrue($request->hasAny('foo.baz'));
|
|
|
|
|
$this->assertFalse($request->hasAny('foo.bax'));
|
2018-01-29 18:37:01 +02:00
|
|
|
$this->assertTrue($request->hasAny(['foo.bax', 'foo.baz']));
|
2017-05-28 03:29:23 +02:00
|
|
|
}
|
|
|
|
|
|
2017-04-07 18:15:09 +02:00
|
|
|
public function testFilledMethod()
|
2015-06-01 15:56:31 +01:00
|
|
|
{
|
2017-04-07 18:15:09 +02:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
$this->assertTrue($request->filled('name'));
|
|
|
|
|
$this->assertFalse($request->filled('age'));
|
|
|
|
|
$this->assertFalse($request->filled('city'));
|
|
|
|
|
$this->assertFalse($request->filled('foo'));
|
|
|
|
|
$this->assertFalse($request->filled('name', 'email'));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->filled('name'));
|
|
|
|
|
$this->assertTrue($request->filled('name', 'email'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertTrue($request->filled(['name', 'email']));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2020-04-07 19:26:52 +01:00
|
|
|
// test arrays within query string
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar', 'baz']]);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->filled('foo'));
|
2016-08-06 16:08:02 +02:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar' => 'baz']]);
|
2017-04-07 18:15:09 +02:00
|
|
|
$this->assertTrue($request->filled('foo.bar'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2020-08-05 12:37:17 -03:00
|
|
|
public function testIsNotFilledMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
$this->assertFalse($request->isNotFilled('name'));
|
|
|
|
|
$this->assertTrue($request->isNotFilled('age'));
|
|
|
|
|
$this->assertTrue($request->isNotFilled('city'));
|
|
|
|
|
$this->assertTrue($request->isNotFilled('foo'));
|
|
|
|
|
$this->assertFalse($request->isNotFilled(['name', 'email']));
|
|
|
|
|
$this->assertTrue($request->isNotFilled(['foo', 'age']));
|
|
|
|
|
$this->assertTrue($request->isNotFilled(['age', 'city']));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => ['bar', 'baz' => '0']]);
|
|
|
|
|
$this->assertFalse($request->isNotFilled('foo'));
|
|
|
|
|
$this->assertTrue($request->isNotFilled('foo.bar'));
|
|
|
|
|
$this->assertFalse($request->isNotFilled('foo.baz'));
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-12 14:07:42 +11:00
|
|
|
public function testFilledAnyMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => '', 'city' => null]);
|
|
|
|
|
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertTrue($request->anyFilled(['name']));
|
|
|
|
|
$this->assertTrue($request->anyFilled('name'));
|
2018-03-12 14:07:42 +11:00
|
|
|
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertFalse($request->anyFilled(['age']));
|
|
|
|
|
$this->assertFalse($request->anyFilled('age'));
|
2018-03-12 14:16:34 +11:00
|
|
|
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertFalse($request->anyFilled(['foo']));
|
|
|
|
|
$this->assertFalse($request->anyFilled('foo'));
|
2018-03-12 14:16:34 +11:00
|
|
|
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertTrue($request->anyFilled(['age', 'name']));
|
|
|
|
|
$this->assertTrue($request->anyFilled('age', 'name'));
|
2018-03-12 14:07:42 +11:00
|
|
|
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertTrue($request->anyFilled(['foo', 'name']));
|
|
|
|
|
$this->assertTrue($request->anyFilled('foo', 'name'));
|
2018-03-12 14:07:42 +11:00
|
|
|
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertFalse($request->anyFilled(['age', 'city']));
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertFalse($request->anyFilled('age', 'city'));
|
2018-03-12 14:16:34 +11:00
|
|
|
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertFalse($request->anyFilled(['foo', 'bar']));
|
2018-03-12 08:37:01 -05:00
|
|
|
$this->assertFalse($request->anyFilled('foo', 'bar'));
|
2018-03-12 14:07:42 +11:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testInputMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $request->input('name'));
|
|
|
|
|
$this->assertSame('Taylor', $request['name']);
|
|
|
|
|
$this->assertSame('Bob', $request->input('foo', 'Bob'));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2018-10-05 14:48:10 +02:00
|
|
|
$request = Request::create('/', 'GET', [], [], ['file' => new SymfonyUploadedFile(__FILE__, 'foo.php')]);
|
|
|
|
|
$this->assertInstanceOf(SymfonyUploadedFile::class, $request['file']);
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2025-11-20 19:20:34 +02:00
|
|
|
public function testFluentMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'user' => [
|
|
|
|
|
'name' => 'Michael',
|
|
|
|
|
'role' => 'admin',
|
|
|
|
|
],
|
|
|
|
|
'users' => null,
|
|
|
|
|
]);
|
|
|
|
|
$this->assertSame(['name' => 'Michael', 'role' => 'admin'], $request->fluent('user')->toArray());
|
|
|
|
|
$this->assertSame([], $request->fluent('users')->toArray());
|
|
|
|
|
$this->assertSame([], $request->fluent('not_found')->toArray());
|
|
|
|
|
}
|
|
|
|
|
|
2023-02-12 23:33:50 +09:00
|
|
|
public function testStringMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'int' => 123,
|
|
|
|
|
'int_str' => '456',
|
|
|
|
|
'float' => 123.456,
|
|
|
|
|
'float_str' => '123.456',
|
|
|
|
|
'float_zero' => 0.000,
|
|
|
|
|
'float_str_zero' => '0.000',
|
|
|
|
|
'str' => 'abc',
|
|
|
|
|
'empty_str' => '',
|
|
|
|
|
'null' => null,
|
|
|
|
|
]);
|
|
|
|
|
$this->assertTrue($request->string('int') instanceof Stringable);
|
|
|
|
|
$this->assertTrue($request->string('unknown_key') instanceof Stringable);
|
|
|
|
|
$this->assertSame('123', $request->string('int')->value());
|
|
|
|
|
$this->assertSame('456', $request->string('int_str')->value());
|
|
|
|
|
$this->assertSame('123.456', $request->string('float')->value());
|
|
|
|
|
$this->assertSame('123.456', $request->string('float_str')->value());
|
|
|
|
|
$this->assertSame('0', $request->string('float_zero')->value());
|
|
|
|
|
$this->assertSame('0.000', $request->string('float_str_zero')->value());
|
|
|
|
|
$this->assertSame('', $request->string('empty_str')->value());
|
|
|
|
|
$this->assertSame('', $request->string('null')->value());
|
|
|
|
|
$this->assertSame('', $request->string('unknown_key')->value());
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 12:06:40 +00:00
|
|
|
public function testBooleanMethod()
|
|
|
|
|
{
|
2022-11-27 14:41:23 +02:00
|
|
|
$request = Request::create('/', 'GET', ['with_trashed' => 'false', 'download' => true, 'checked' => 1, 'unchecked' => '0', 'with_on' => 'on', 'with_yes' => 'yes']);
|
2020-01-17 12:06:40 +00:00
|
|
|
$this->assertTrue($request->boolean('checked'));
|
|
|
|
|
$this->assertTrue($request->boolean('download'));
|
|
|
|
|
$this->assertFalse($request->boolean('unchecked'));
|
|
|
|
|
$this->assertFalse($request->boolean('with_trashed'));
|
|
|
|
|
$this->assertFalse($request->boolean('some_undefined_key'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertTrue($request->boolean('with_on'));
|
|
|
|
|
$this->assertTrue($request->boolean('with_yes'));
|
2020-01-17 12:06:40 +00:00
|
|
|
}
|
|
|
|
|
|
2022-09-21 12:08:36 -04:00
|
|
|
public function testIntegerMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'int' => '123',
|
|
|
|
|
'raw_int' => 456,
|
|
|
|
|
'zero_padded' => '078',
|
|
|
|
|
'space_padded' => ' 901',
|
|
|
|
|
'nan' => 'nan',
|
2022-11-27 14:41:23 +02:00
|
|
|
'mixed' => '1ab',
|
|
|
|
|
'underscore_notation' => '2_000',
|
2023-02-12 00:05:39 +09:00
|
|
|
'null' => null,
|
2022-09-21 12:08:36 -04:00
|
|
|
]);
|
|
|
|
|
$this->assertSame(123, $request->integer('int'));
|
|
|
|
|
$this->assertSame(456, $request->integer('raw_int'));
|
|
|
|
|
$this->assertSame(78, $request->integer('zero_padded'));
|
|
|
|
|
$this->assertSame(901, $request->integer('space_padded'));
|
|
|
|
|
$this->assertSame(0, $request->integer('nan'));
|
|
|
|
|
$this->assertSame(1, $request->integer('mixed'));
|
|
|
|
|
$this->assertSame(2, $request->integer('underscore_notation'));
|
|
|
|
|
$this->assertSame(123456, $request->integer('unknown_key', 123456));
|
2023-02-12 00:05:39 +09:00
|
|
|
$this->assertSame(0, $request->integer('null'));
|
|
|
|
|
$this->assertSame(0, $request->integer('null', 123456));
|
2022-09-21 12:08:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFloatMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'float' => '1.23',
|
|
|
|
|
'raw_float' => 45.6,
|
|
|
|
|
'decimal_only' => '.6',
|
|
|
|
|
'zero_padded' => '0.78',
|
|
|
|
|
'space_padded' => ' 90.1',
|
|
|
|
|
'nan' => 'nan',
|
2022-11-27 14:41:23 +02:00
|
|
|
'mixed' => '1.ab',
|
|
|
|
|
'scientific_notation' => '1e3',
|
2023-02-12 00:05:39 +09:00
|
|
|
'null' => null,
|
2022-09-21 12:08:36 -04:00
|
|
|
]);
|
|
|
|
|
$this->assertSame(1.23, $request->float('float'));
|
|
|
|
|
$this->assertSame(45.6, $request->float('raw_float'));
|
|
|
|
|
$this->assertSame(.6, $request->float('decimal_only'));
|
|
|
|
|
$this->assertSame(0.78, $request->float('zero_padded'));
|
|
|
|
|
$this->assertSame(90.1, $request->float('space_padded'));
|
|
|
|
|
$this->assertSame(0.0, $request->float('nan'));
|
|
|
|
|
$this->assertSame(1.0, $request->float('mixed'));
|
|
|
|
|
$this->assertSame(1e3, $request->float('scientific_notation'));
|
|
|
|
|
$this->assertSame(123.456, $request->float('unknown_key', 123.456));
|
2023-02-12 00:05:39 +09:00
|
|
|
$this->assertSame(0.0, $request->float('null'));
|
|
|
|
|
$this->assertSame(0.0, $request->float('null', 123.456));
|
2022-09-21 12:08:36 -04:00
|
|
|
}
|
|
|
|
|
|
2025-01-13 11:41:27 -05:00
|
|
|
public function testArrayMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', []);
|
|
|
|
|
$this->assertIsArray($request->array());
|
|
|
|
|
$this->assertEmpty($request->array());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'users' => [1, 2, 3],
|
|
|
|
|
'roles' => [4, 5, 6],
|
|
|
|
|
'email' => 'test@example.com',
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$this->assertEmpty($request->array('missing'));
|
|
|
|
|
$this->assertEmpty($request->array(['missing']));
|
|
|
|
|
$this->assertEquals([1, 2, 3], $request->array('users'));
|
|
|
|
|
$this->assertEquals(['users' => [1, 2, 3]], $request->array(['users']));
|
|
|
|
|
$this->assertEquals(['users' => [1, 2, 3], 'email' => 'test@example.com'], $request->array(['users', 'email']));
|
|
|
|
|
|
|
|
|
|
$this->assertEquals([
|
|
|
|
|
'users' => [1, 2, 3],
|
|
|
|
|
'roles' => [4, 5, 6],
|
|
|
|
|
'email' => 'test@example.com',
|
|
|
|
|
], $request->array());
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-17 12:53:28 -05:00
|
|
|
public function testCollectMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['users' => [1, 2, 3]]);
|
|
|
|
|
|
|
|
|
|
$this->assertInstanceOf(Collection::class, $request->collect('users'));
|
|
|
|
|
$this->assertTrue($request->collect('developers')->isEmpty());
|
|
|
|
|
$this->assertEquals([1, 2, 3], $request->collect('users')->all());
|
|
|
|
|
$this->assertEquals(['users' => [1, 2, 3]], $request->collect()->all());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['text-payload']);
|
|
|
|
|
$this->assertEquals(['text-payload'], $request->collect()->all());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['email' => 'test@example.com']);
|
|
|
|
|
$this->assertEquals(['test@example.com'], $request->collect('email')->all());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', []);
|
|
|
|
|
$this->assertInstanceOf(Collection::class, $request->collect());
|
|
|
|
|
$this->assertTrue($request->collect()->isEmpty());
|
2021-10-15 09:57:43 -05:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['users' => [1, 2, 3], 'roles' => [4, 5, 6], 'foo' => ['bar', 'baz'], 'email' => 'test@example.com']);
|
|
|
|
|
$this->assertInstanceOf(Collection::class, $request->collect(['users']));
|
|
|
|
|
$this->assertTrue($request->collect(['developers'])->isEmpty());
|
|
|
|
|
$this->assertTrue($request->collect(['roles'])->isNotEmpty());
|
|
|
|
|
$this->assertEquals(['roles' => [4, 5, 6]], $request->collect(['roles'])->all());
|
|
|
|
|
$this->assertEquals(['users' => [1, 2, 3], 'email' => 'test@example.com'], $request->collect(['users', 'email'])->all());
|
|
|
|
|
$this->assertEquals(collect(['roles' => [4, 5, 6], 'foo' => ['bar', 'baz']]), $request->collect(['roles', 'foo']));
|
|
|
|
|
$this->assertEquals(['users' => [1, 2, 3], 'roles' => [4, 5, 6], 'foo' => ['bar', 'baz'], 'email' => 'test@example.com'], $request->collect()->all());
|
2021-09-17 12:53:28 -05:00
|
|
|
}
|
|
|
|
|
|
2021-12-17 12:23:31 -03:00
|
|
|
public function testDateMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'as_null' => null,
|
|
|
|
|
'as_invalid' => 'invalid',
|
|
|
|
|
|
|
|
|
|
'as_datetime' => '20-01-01 16:30:25',
|
|
|
|
|
'as_format' => '1577896225',
|
|
|
|
|
'as_timezone' => '20-01-01 13:30:25',
|
|
|
|
|
|
|
|
|
|
'as_date' => '2020-01-01',
|
|
|
|
|
'as_time' => '16:30:25',
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$current = Carbon::create(2020, 1, 1, 16, 30, 25);
|
|
|
|
|
|
|
|
|
|
$this->assertNull($request->date('as_null'));
|
|
|
|
|
$this->assertNull($request->date('doesnt_exists'));
|
|
|
|
|
|
|
|
|
|
$this->assertEquals($current, $request->date('as_datetime'));
|
2023-07-12 04:34:13 +02:00
|
|
|
$this->assertEquals($current->format('Y-m-d H:i:s P'), $request->date('as_format', 'U')->format('Y-m-d H:i:s P'));
|
2021-12-17 12:23:31 -03:00
|
|
|
$this->assertEquals($current, $request->date('as_timezone', null, 'America/Santiago'));
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($request->date('as_date')->isSameDay($current));
|
|
|
|
|
$this->assertTrue($request->date('as_time')->isSameSecond('16:30:25'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testDateMethodExceptionWhenValueInvalid()
|
|
|
|
|
{
|
|
|
|
|
$this->expectException(InvalidArgumentException::class);
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'date' => 'invalid',
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$request->date('date');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testDateMethodExceptionWhenFormatInvalid()
|
|
|
|
|
{
|
|
|
|
|
$this->expectException(InvalidArgumentException::class);
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'date' => '20-01-01 16:30:25',
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$request->date('date', 'invalid_format');
|
|
|
|
|
}
|
|
|
|
|
|
2026-03-06 16:23:29 +01:00
|
|
|
public function testIntervalMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'as_null' => null,
|
|
|
|
|
'as_empty' => '',
|
|
|
|
|
'as_iso' => 'P1Y2M3DT4H5M6S',
|
|
|
|
|
'as_human' => '2 hours 30 minutes',
|
|
|
|
|
'as_seconds' => '90',
|
|
|
|
|
'as_minutes' => '45',
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$this->assertNull($request->interval('as_null'));
|
|
|
|
|
$this->assertNull($request->interval('as_empty'));
|
|
|
|
|
$this->assertNull($request->interval('doesnt_exist'));
|
|
|
|
|
|
|
|
|
|
$interval = $request->interval('as_iso');
|
|
|
|
|
$this->assertInstanceOf(CarbonInterval::class, $interval);
|
|
|
|
|
$this->assertSame(1, $interval->years);
|
|
|
|
|
$this->assertSame(2, $interval->months);
|
|
|
|
|
$this->assertSame(3, $interval->dayz);
|
|
|
|
|
$this->assertSame(4, $interval->hours);
|
|
|
|
|
$this->assertSame(5, $interval->minutes);
|
|
|
|
|
$this->assertSame(6, $interval->seconds);
|
|
|
|
|
|
|
|
|
|
$interval = $request->interval('as_human');
|
|
|
|
|
$this->assertInstanceOf(CarbonInterval::class, $interval);
|
|
|
|
|
$this->assertSame(2, $interval->hours);
|
|
|
|
|
$this->assertSame(30, $interval->minutes);
|
|
|
|
|
|
|
|
|
|
$interval = $request->interval('as_seconds', 'second');
|
|
|
|
|
$this->assertInstanceOf(CarbonInterval::class, $interval);
|
|
|
|
|
$this->assertSame(90, $interval->seconds);
|
|
|
|
|
|
|
|
|
|
$this->assertSame(90, $request->interval('as_seconds', 'minute')->minutes);
|
|
|
|
|
$this->assertSame(90, $request->interval('as_seconds', 'hour')->hours);
|
|
|
|
|
$this->assertSame(90, $request->interval('as_seconds', 'day')->dayz);
|
|
|
|
|
|
|
|
|
|
$this->assertSame(45, $request->interval('as_minutes', Unit::Minute)->minutes);
|
|
|
|
|
$this->assertSame(45, $request->interval('as_minutes', Unit::Second)->seconds);
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-17 17:13:12 +03:00
|
|
|
public function testEnumMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'valid_enum_value' => 'test',
|
|
|
|
|
'invalid_enum_value' => 'invalid',
|
2024-05-05 19:44:17 +04:00
|
|
|
'empty_value_request' => '',
|
2024-10-08 22:35:04 +09:00
|
|
|
'string' => [
|
|
|
|
|
'minus_1' => '-1',
|
|
|
|
|
'0' => '0',
|
|
|
|
|
'plus_1' => '1',
|
|
|
|
|
'doesnt_exist' => '-1024',
|
|
|
|
|
],
|
|
|
|
|
'int' => [
|
|
|
|
|
'minus_1' => -1,
|
|
|
|
|
'0' => 0,
|
|
|
|
|
'plus_1' => 1,
|
|
|
|
|
'doesnt_exist' => 1024,
|
|
|
|
|
],
|
2022-07-17 17:13:12 +03:00
|
|
|
]);
|
|
|
|
|
|
2024-10-08 22:35:04 +09:00
|
|
|
$this->assertNull($request->enum('doesnt_exist', TestEnumBacked::class));
|
2022-07-17 17:13:12 +03:00
|
|
|
|
2025-05-14 16:09:00 +02:00
|
|
|
$this->assertEquals(TestEnumBacked::test, $request->enum('invalid_enum_value', TestEnumBacked::class, TestEnumBacked::test));
|
|
|
|
|
$this->assertEquals(TestEnumBacked::test, $request->enum('missing_key', TestEnumBacked::class, TestEnumBacked::test));
|
|
|
|
|
|
2024-05-05 19:44:17 +04:00
|
|
|
$this->assertEquals(TestEnumBacked::test, $request->enum('valid_enum_value', TestEnumBacked::class));
|
2022-07-17 17:13:12 +03:00
|
|
|
|
2024-05-05 19:44:17 +04:00
|
|
|
$this->assertNull($request->enum('invalid_enum_value', TestEnumBacked::class));
|
|
|
|
|
$this->assertNull($request->enum('empty_value_request', TestEnumBacked::class));
|
|
|
|
|
$this->assertNull($request->enum('valid_enum_value', TestEnum::class));
|
2024-10-08 22:35:04 +09:00
|
|
|
|
|
|
|
|
$this->assertEquals(TestIntegerEnumBacked::minus_1, $request->enum('string.minus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals(TestIntegerEnumBacked::zero, $request->enum('string.0', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals(TestIntegerEnumBacked::plus_1, $request->enum('string.plus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertNull($request->enum('string.doesnt_exist', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals(TestIntegerEnumBacked::minus_1, $request->enum('int.minus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals(TestIntegerEnumBacked::zero, $request->enum('int.0', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals(TestIntegerEnumBacked::plus_1, $request->enum('int.plus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertNull($request->enum('int.doesnt_exist', TestIntegerEnumBacked::class));
|
2022-07-17 17:13:12 +03:00
|
|
|
}
|
|
|
|
|
|
2024-11-18 10:55:00 -05:00
|
|
|
public function testEnumsMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [
|
|
|
|
|
'valid_enum_values' => ['test', 'test'],
|
|
|
|
|
'invalid_enum_values' => ['invalid', 'invalid'],
|
|
|
|
|
'empty_value_request' => [],
|
|
|
|
|
'string' => [
|
|
|
|
|
'minus_1' => ['-1', '0'],
|
|
|
|
|
'0' => '0',
|
|
|
|
|
'plus_1' => '1',
|
|
|
|
|
'doesnt_exist' => '-1024',
|
|
|
|
|
],
|
|
|
|
|
'int' => [
|
|
|
|
|
'minus_1' => -1,
|
|
|
|
|
'0' => 0,
|
|
|
|
|
'plus_1' => 1,
|
|
|
|
|
'doesnt_exist' => 1024,
|
|
|
|
|
],
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$this->assertEmpty($request->enums('doesnt_exist', TestEnumBacked::class));
|
|
|
|
|
|
|
|
|
|
$this->assertEquals([TestEnumBacked::test, TestEnumBacked::test], $request->enums('valid_enum_values', TestEnumBacked::class));
|
|
|
|
|
|
|
|
|
|
$this->assertEmpty($request->enums('invalid_enum_value', TestEnumBacked::class));
|
|
|
|
|
$this->assertEmpty($request->enums('empty_value_request', TestEnumBacked::class));
|
|
|
|
|
$this->assertEmpty($request->enums('valid_enum_value', TestEnum::class));
|
|
|
|
|
|
|
|
|
|
$this->assertEquals([TestIntegerEnumBacked::minus_1, TestIntegerEnumBacked::zero], $request->enums('string.minus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals([TestIntegerEnumBacked::zero], $request->enums('string.0', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals([TestIntegerEnumBacked::plus_1], $request->enums('string.plus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEmpty($request->enums('string.doesnt_exist', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals([TestIntegerEnumBacked::minus_1], $request->enums('int.minus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals([TestIntegerEnumBacked::zero], $request->enums('int.0', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEquals([TestIntegerEnumBacked::plus_1], $request->enums('int.plus_1', TestIntegerEnumBacked::class));
|
|
|
|
|
$this->assertEmpty($request->enums('int.doesnt_exist', TestIntegerEnumBacked::class));
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-14 11:08:31 +02:00
|
|
|
public function testArrayAccess()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => null, 'foo' => ['bar' => null, 'baz' => '']]);
|
2018-03-14 07:16:34 -05:00
|
|
|
|
2018-03-14 11:08:31 +02:00
|
|
|
$request->setRouteResolver(function () use ($request) {
|
|
|
|
|
$route = new Route('GET', '/foo/bar/{id}/{name}', []);
|
|
|
|
|
$route->bind($request);
|
|
|
|
|
$route->setParameter('id', 'foo');
|
|
|
|
|
$route->setParameter('name', 'Taylor');
|
|
|
|
|
|
|
|
|
|
return $route;
|
|
|
|
|
});
|
|
|
|
|
|
2021-01-24 02:49:02 -07:00
|
|
|
$this->assertFalse(isset($request['non-existent']));
|
|
|
|
|
$this->assertNull($request['non-existent']);
|
2018-03-14 11:08:31 +02:00
|
|
|
|
|
|
|
|
$this->assertTrue(isset($request['name']));
|
2018-07-30 01:28:12 +02:00
|
|
|
$this->assertNull($request['name']);
|
2018-03-14 07:16:34 -05:00
|
|
|
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertNotSame('Taylor', $request['name']);
|
2018-03-14 11:08:31 +02:00
|
|
|
|
|
|
|
|
$this->assertTrue(isset($request['foo.bar']));
|
2018-07-30 01:28:12 +02:00
|
|
|
$this->assertNull($request['foo.bar']);
|
2018-03-14 11:08:31 +02:00
|
|
|
$this->assertTrue(isset($request['foo.baz']));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('', $request['foo.baz']);
|
2018-03-14 11:08:31 +02:00
|
|
|
|
|
|
|
|
$this->assertTrue(isset($request['id']));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('foo', $request['id']);
|
2018-03-14 11:08:31 +02:00
|
|
|
}
|
|
|
|
|
|
2022-06-10 20:50:29 +02:00
|
|
|
public function testArrayAccessWithoutRouteResolver()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor']);
|
|
|
|
|
|
|
|
|
|
$this->assertFalse(isset($request['non-existent']));
|
|
|
|
|
$this->assertNull($request['non-existent']);
|
|
|
|
|
|
|
|
|
|
$this->assertTrue(isset($request['name']));
|
|
|
|
|
$this->assertSame('Taylor', $request['name']);
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-10 17:15:48 +02:00
|
|
|
public function testAllMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => null]);
|
|
|
|
|
$this->assertEquals(['name' => 'Taylor', 'age' => null, 'email' => null], $request->all('name', 'age', 'email'));
|
|
|
|
|
$this->assertEquals(['name' => 'Taylor'], $request->all('name'));
|
|
|
|
|
$this->assertEquals(['name' => 'Taylor', 'age' => null], $request->all());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['developer' => ['name' => 'Taylor', 'age' => null]]);
|
|
|
|
|
$this->assertEquals(['developer' => ['name' => 'Taylor', 'skills' => null]], $request->all('developer.name', 'developer.skills'));
|
|
|
|
|
$this->assertEquals(['developer' => ['name' => 'Taylor', 'skills' => null]], $request->all(['developer.name', 'developer.skills']));
|
|
|
|
|
$this->assertEquals(['developer' => ['age' => null]], $request->all('developer.age'));
|
|
|
|
|
$this->assertEquals(['developer' => ['skills' => null]], $request->all('developer.skills'));
|
|
|
|
|
$this->assertEquals(['developer' => ['name' => 'Taylor', 'age' => null]], $request->all());
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-17 15:52:33 +01:00
|
|
|
public function testKeysMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => null]);
|
|
|
|
|
$this->assertEquals(['name', 'age'], $request->keys());
|
|
|
|
|
|
|
|
|
|
$files = [
|
|
|
|
|
'foo' => [
|
|
|
|
|
'size' => 500,
|
|
|
|
|
'name' => 'foo.jpg',
|
|
|
|
|
'tmp_name' => __FILE__,
|
|
|
|
|
'type' => 'blah',
|
|
|
|
|
'error' => null,
|
|
|
|
|
],
|
|
|
|
|
];
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], $files);
|
|
|
|
|
$this->assertEquals(['foo'], $request->keys());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor'], [], $files);
|
|
|
|
|
$this->assertEquals(['name', 'foo'], $request->keys());
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testOnlyMethod()
|
|
|
|
|
{
|
2017-04-07 23:48:42 +02:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => null]);
|
|
|
|
|
$this->assertEquals(['name' => 'Taylor', 'age' => null], $request->only('name', 'age', 'email'));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2017-04-07 23:48:42 +02:00
|
|
|
$request = Request::create('/', 'GET', ['developer' => ['name' => 'Taylor', 'age' => null]]);
|
|
|
|
|
$this->assertEquals(['developer' => ['name' => 'Taylor']], $request->only('developer.name', 'developer.skills'));
|
|
|
|
|
$this->assertEquals(['developer' => ['age' => null]], $request->only('developer.age'));
|
|
|
|
|
$this->assertEquals([], $request->only('developer.skills'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testExceptMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'age' => 25]);
|
|
|
|
|
$this->assertEquals(['name' => 'Taylor'], $request->except('age'));
|
|
|
|
|
$this->assertEquals([], $request->except('age', 'name'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertEquals([], $request->except(['age', 'name']));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testQueryMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor']);
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame(['name' => 'Taylor'], $request->query());
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $request->query('name'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame('Taylor', $request->query('name', 'Amir'));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Bob', $request->query('foo', 'Bob'));
|
2015-06-01 15:56:31 +01:00
|
|
|
$all = $request->query(null);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $all['name']);
|
2022-01-25 15:16:20 +01:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['hello' => 'world', 'user' => ['Taylor', 'Mohamed Said']]);
|
|
|
|
|
$this->assertSame(['Taylor', 'Mohamed Said'], $request->query('user'));
|
|
|
|
|
$this->assertSame(['hello' => 'world', 'user' => ['Taylor', 'Mohamed Said']], $request->query->all());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/?hello=world&user[]=Taylor&user[]=Mohamed%20Said', 'GET', []);
|
|
|
|
|
$this->assertSame(['Taylor', 'Mohamed Said'], $request->query('user'));
|
|
|
|
|
$this->assertSame(['hello' => 'world', 'user' => ['Taylor', 'Mohamed Said']], $request->query->all());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2017-07-25 12:30:30 +02:00
|
|
|
public function testPostMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'POST', ['name' => 'Taylor']);
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame(['name' => 'Taylor'], $request->post());
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $request->post('name'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame('Taylor', $request->post('name', 'Amir'));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Bob', $request->post('foo', 'Bob'));
|
2017-07-25 12:30:30 +02:00
|
|
|
$all = $request->post(null);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $all['name']);
|
2017-07-25 12:30:30 +02:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testCookieMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], ['name' => 'Taylor']);
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame(['name' => 'Taylor'], $request->cookie());
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $request->cookie('name'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame('Taylor', $request->cookie('name', 'Amir'));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Bob', $request->cookie('foo', 'Bob'));
|
2015-06-01 15:56:31 +01:00
|
|
|
$all = $request->cookie(null);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $all['name']);
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testHasCookieMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], ['foo' => 'bar']);
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->hasCookie('foo'));
|
|
|
|
|
$this->assertFalse($request->hasCookie('qu'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFileMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$files = [
|
|
|
|
|
'foo' => [
|
2015-06-01 15:56:31 +01:00
|
|
|
'size' => 500,
|
|
|
|
|
'name' => 'foo.jpg',
|
|
|
|
|
'tmp_name' => __FILE__,
|
|
|
|
|
'type' => 'blah',
|
|
|
|
|
'error' => null,
|
2015-06-01 16:35:44 +01:00
|
|
|
],
|
|
|
|
|
];
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], $files);
|
2018-10-05 14:48:10 +02:00
|
|
|
$this->assertInstanceOf(SymfonyUploadedFile::class, $request->file('foo'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testHasFileMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], []);
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertFalse($request->hasFile('foo'));
|
|
|
|
|
|
2015-06-01 16:35:44 +01:00
|
|
|
$files = [
|
|
|
|
|
'foo' => [
|
2015-06-01 15:56:31 +01:00
|
|
|
'size' => 500,
|
|
|
|
|
'name' => 'foo.jpg',
|
|
|
|
|
'tmp_name' => __FILE__,
|
|
|
|
|
'type' => 'blah',
|
|
|
|
|
'error' => null,
|
2015-06-01 16:35:44 +01:00
|
|
|
],
|
|
|
|
|
];
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], $files);
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->hasFile('foo'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertFalse($request->hasFile('bar'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testServerMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['foo' => 'bar']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('bar', $request->server('foo'));
|
|
|
|
|
$this->assertSame('bar', $request->server('foo.doesnt.exist', 'bar'));
|
2015-06-01 15:56:31 +01:00
|
|
|
$all = $request->server(null);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('bar', $all['foo']);
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testMergeMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor']);
|
|
|
|
|
$merge = ['buddy' => 'Dayle'];
|
2015-06-01 15:56:31 +01:00
|
|
|
$request->merge($merge);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Taylor', $request->input('name'));
|
|
|
|
|
$this->assertSame('Dayle', $request->input('buddy'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2021-12-22 20:37:02 +00:00
|
|
|
public function testMergeIfMissingMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor']);
|
|
|
|
|
$merge = ['boolean_setting' => 0];
|
|
|
|
|
$request->mergeIfMissing($merge);
|
|
|
|
|
$this->assertSame('Taylor', $request->input('name'));
|
|
|
|
|
$this->assertSame(0, $request->input('boolean_setting'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'boolean_setting' => 1]);
|
|
|
|
|
$merge = ['boolean_setting' => 0];
|
|
|
|
|
$request->mergeIfMissing($merge);
|
|
|
|
|
$this->assertSame('Taylor', $request->input('name'));
|
|
|
|
|
$this->assertSame(1, $request->input('boolean_setting'));
|
2024-07-29 09:44:38 +02:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['user' => ['first_name' => 'Taylor', 'email' => 'taylor@laravel.com']]);
|
|
|
|
|
$merge = ['user.last_name' => 'Otwell'];
|
|
|
|
|
$request->mergeIfMissing($merge);
|
|
|
|
|
$this->assertSame('Otwell', $request->input('user.last_name'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', ['user' => ['first_name' => 'Taylor', 'email' => 'taylor@laravel.com']]);
|
|
|
|
|
$merge = ['user.first_name' => 'John'];
|
|
|
|
|
$request->mergeIfMissing($merge);
|
|
|
|
|
$this->assertSame('Taylor', $request->input('user.first_name'));
|
2021-12-22 20:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testReplaceMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor']);
|
|
|
|
|
$replace = ['buddy' => 'Dayle'];
|
2015-06-01 15:56:31 +01:00
|
|
|
$request->replace($replace);
|
|
|
|
|
$this->assertNull($request->input('name'));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('Dayle', $request->input('buddy'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2018-05-03 21:22:33 +08:00
|
|
|
public function testOffsetUnsetMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'HEAD', ['name' => 'Taylor']);
|
|
|
|
|
$request->offsetUnset('name');
|
|
|
|
|
$this->assertNull($request->input('name'));
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testHeaderMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_DO_THIS' => 'foo']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('foo', $request->header('do-this'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame('default', $request->header('do-that', 'default'));
|
2015-06-01 15:56:31 +01:00
|
|
|
$all = $request->header(null);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('foo', $all['do-this'][0]);
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2021-08-18 16:12:39 +03:00
|
|
|
public function testBearerTokenMethod()
|
|
|
|
|
{
|
2021-10-08 15:49:03 +02:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_AUTHORIZATION' => 'Bearer fooBearerbar']);
|
|
|
|
|
$this->assertSame('fooBearerbar', $request->bearerToken());
|
2021-08-18 16:12:39 +03:00
|
|
|
|
2024-11-21 17:20:32 -05:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_AUTHORIZATION' => 'bearer fooBearerbar']);
|
|
|
|
|
$this->assertSame('fooBearerbar', $request->bearerToken());
|
|
|
|
|
|
2021-08-18 16:12:39 +03:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_AUTHORIZATION' => 'Basic foo, Bearer bar']);
|
|
|
|
|
$this->assertSame('bar', $request->bearerToken());
|
2022-01-17 09:23:08 -06:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_AUTHORIZATION' => 'Bearer foo,bar']);
|
|
|
|
|
$this->assertSame('foo', $request->bearerToken());
|
2022-09-08 18:25:22 +04:30
|
|
|
|
2024-11-21 17:20:32 -05:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_AUTHORIZATION' => 'bearer foo,bar']);
|
|
|
|
|
$this->assertSame('foo', $request->bearerToken());
|
|
|
|
|
|
2022-09-08 18:25:22 +04:30
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_AUTHORIZATION' => 'foo,bar']);
|
|
|
|
|
$this->assertNull($request->bearerToken());
|
2021-08-18 16:12:39 +03:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testJSONMethod()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$payload = ['name' => 'taylor'];
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['CONTENT_TYPE' => 'application/json'], json_encode($payload));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('taylor', $request->json('name'));
|
2022-09-08 18:25:22 +04:30
|
|
|
$this->assertSame('taylor', $request->json('name', 'Otwell'));
|
|
|
|
|
$this->assertSame('Moharami', $request->json('family', 'Moharami'));
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('taylor', $request->input('name'));
|
2015-06-01 15:56:31 +01:00
|
|
|
$data = $request->json()->all();
|
|
|
|
|
$this->assertEquals($payload, $data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testJSONEmulatingPHPBuiltInServer()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$payload = ['name' => 'taylor'];
|
2015-06-01 15:56:31 +01:00
|
|
|
$content = json_encode($payload);
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_CONTENT_TYPE' => 'application/json', 'HTTP_CONTENT_LENGTH' => strlen($content)], $content);
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->isJson());
|
|
|
|
|
$data = $request->json()->all();
|
|
|
|
|
$this->assertEquals($payload, $data);
|
|
|
|
|
|
|
|
|
|
$data = $request->all();
|
|
|
|
|
$this->assertEquals($payload, $data);
|
|
|
|
|
}
|
|
|
|
|
|
2022-11-23 05:10:22 +08:00
|
|
|
public static function getPrefersCases()
|
2015-06-26 19:25:03 +08:00
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
return [
|
|
|
|
|
['application/json', ['json'], 'json'],
|
|
|
|
|
['application/json', ['html', 'json'], 'json'],
|
|
|
|
|
['application/foo+json', 'application/foo+json', 'application/foo+json'],
|
|
|
|
|
['application/foo+json', 'json', 'json'],
|
|
|
|
|
['application/json;q=0.5, text/html;q=1.0', ['json', 'html'], 'html'],
|
|
|
|
|
['application/json;q=0.5, text/plain;q=1.0, text/html;q=1.0', ['json', 'txt', 'html'], 'txt'],
|
|
|
|
|
['application/*', 'json', 'json'],
|
|
|
|
|
['application/json; charset=utf-8', 'json', 'json'],
|
|
|
|
|
['application/xml; charset=utf-8', ['html', 'json'], null],
|
|
|
|
|
['application/json, text/html', ['html', 'json'], 'json'],
|
|
|
|
|
['application/json;q=0.4, text/html;q=0.6', ['html', 'json'], 'html'],
|
|
|
|
|
|
|
|
|
|
['application/json; charset=utf-8', 'application/json', 'application/json'],
|
|
|
|
|
['application/json, text/html', ['text/html', 'application/json'], 'application/json'],
|
|
|
|
|
['application/json;q=0.4, text/html;q=0.6', ['text/html', 'application/json'], 'text/html'],
|
|
|
|
|
['application/json;q=0.4, text/html;q=0.6', ['application/json', 'text/html'], 'text/html'],
|
|
|
|
|
|
|
|
|
|
['*/*; charset=utf-8', 'json', 'json'],
|
|
|
|
|
['application/*', 'application/json', 'application/json'],
|
|
|
|
|
['application/*', 'application/xml', 'application/xml'],
|
|
|
|
|
['application/*', 'text/html', null],
|
|
|
|
|
];
|
|
|
|
|
}
|
2015-06-26 19:25:03 +08:00
|
|
|
|
2023-10-26 22:09:14 +08:00
|
|
|
#[DataProvider('getPrefersCases')]
|
2021-12-03 22:33:34 +07:00
|
|
|
public function testPrefersMethod($accept, $prefers, $expected)
|
|
|
|
|
{
|
|
|
|
|
$this->assertSame(
|
|
|
|
|
$expected, Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => $accept])->prefers($prefers)
|
|
|
|
|
);
|
2015-06-20 20:56:56 +08:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testAllInputReturnsInputAndFiles()
|
|
|
|
|
{
|
2018-10-05 14:48:10 +02:00
|
|
|
$file = $this->getMockBuilder(UploadedFile::class)->setConstructorArgs([__FILE__, 'photo.jpg'])->getMock();
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/?boom=breeze', 'GET', ['foo' => 'bar'], [], ['baz' => $file]);
|
|
|
|
|
$this->assertEquals(['foo' => 'bar', 'baz' => $file, 'boom' => 'breeze'], $request->all());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAllInputReturnsNestedInputAndFiles()
|
|
|
|
|
{
|
2018-10-05 14:48:10 +02:00
|
|
|
$file = $this->getMockBuilder(UploadedFile::class)->setConstructorArgs([__FILE__, 'photo.jpg'])->getMock();
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/?boom=breeze', 'GET', ['foo' => ['bar' => 'baz']], [], ['foo' => ['photo' => $file]]);
|
|
|
|
|
$this->assertEquals(['foo' => ['bar' => 'baz', 'photo' => $file], 'boom' => 'breeze'], $request->all());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAllInputReturnsInputAfterReplace()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/?boom=breeze', 'GET', ['foo' => ['bar' => 'baz']]);
|
|
|
|
|
$request->replace(['foo' => ['bar' => 'baz'], 'boom' => 'breeze']);
|
|
|
|
|
$this->assertEquals(['foo' => ['bar' => 'baz'], 'boom' => 'breeze'], $request->all());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAllInputWithNumericKeysReturnsInputAfterReplace()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request1 = Request::create('/', 'POST', [0 => 'A', 1 => 'B', 2 => 'C']);
|
|
|
|
|
$request1->replace([0 => 'A', 1 => 'B', 2 => 'C']);
|
|
|
|
|
$this->assertEquals([0 => 'A', 1 => 'B', 2 => 'C'], $request1->all());
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2015-06-01 16:35:44 +01:00
|
|
|
$request2 = Request::create('/', 'POST', [1 => 'A', 2 => 'B', 3 => 'C']);
|
|
|
|
|
$request2->replace([1 => 'A', 2 => 'B', 3 => 'C']);
|
|
|
|
|
$this->assertEquals([1 => 'A', 2 => 'B', 3 => 'C'], $request2->all());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testInputWithEmptyFilename()
|
|
|
|
|
{
|
|
|
|
|
$invalidFiles = [
|
|
|
|
|
'file' => [
|
|
|
|
|
'name' => null,
|
|
|
|
|
'type' => null,
|
|
|
|
|
'tmp_name' => null,
|
|
|
|
|
'error' => 4,
|
2015-06-01 16:35:44 +01:00
|
|
|
'size' => 0,
|
|
|
|
|
],
|
2015-06-01 15:56:31 +01:00
|
|
|
];
|
|
|
|
|
|
2015-06-01 16:35:44 +01:00
|
|
|
$baseRequest = SymfonyRequest::create('/?boom=breeze', 'GET', ['foo' => ['bar' => 'baz']], [], $invalidFiles);
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2018-10-10 22:24:06 +02:00
|
|
|
Request::createFromBase($baseRequest);
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2016-09-02 23:34:45 +02:00
|
|
|
public function testMultipleFileUploadWithEmptyValue()
|
|
|
|
|
{
|
|
|
|
|
$invalidFiles = [
|
|
|
|
|
'file' => [
|
|
|
|
|
'name' => [''],
|
|
|
|
|
'type' => [''],
|
|
|
|
|
'tmp_name' => [''],
|
|
|
|
|
'error' => [4],
|
|
|
|
|
'size' => [0],
|
|
|
|
|
],
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
$baseRequest = SymfonyRequest::create('/?boom=breeze', 'GET', ['foo' => ['bar' => 'baz']], [], $invalidFiles);
|
|
|
|
|
|
|
|
|
|
$request = Request::createFromBase($baseRequest);
|
|
|
|
|
|
|
|
|
|
$this->assertEmpty($request->files->all());
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testOldMethodCallsSession()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2018-10-05 14:48:10 +02:00
|
|
|
$session = m::mock(Store::class);
|
2015-06-01 15:56:31 +01:00
|
|
|
$session->shouldReceive('getOldInput')->once()->with('foo', 'bar')->andReturn('boom');
|
2016-12-23 13:33:04 -06:00
|
|
|
$request->setLaravelSession($session);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('boom', $request->old('foo', 'bar'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2022-04-06 20:03:13 +01:00
|
|
|
public function testOldMethodCallsSessionWhenDefaultIsArray()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/');
|
|
|
|
|
$session = m::mock(Store::class);
|
|
|
|
|
$session->shouldReceive('getOldInput')->once()->with('foo', ['bar'])->andReturn(['bar']);
|
|
|
|
|
$request->setLaravelSession($session);
|
|
|
|
|
$this->assertSame(['bar'], $request->old('foo', ['bar']));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testOldMethodCanGetDefaultValueFromModelByKey()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/');
|
|
|
|
|
$model = m::mock(Price::class);
|
|
|
|
|
$model->shouldReceive('getAttribute')->once()->with('name')->andReturn('foobar');
|
|
|
|
|
$session = m::mock(Store::class);
|
|
|
|
|
$session->shouldReceive('getOldInput')->once()->with('name', 'foobar')->andReturn('foobar');
|
|
|
|
|
$request->setLaravelSession($session);
|
|
|
|
|
$this->assertSame('foobar', $request->old('name', $model));
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testFlushMethodCallsSession()
|
|
|
|
|
{
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2018-10-05 14:48:10 +02:00
|
|
|
$session = m::mock(Store::class);
|
2015-06-01 15:56:31 +01:00
|
|
|
$session->shouldReceive('flashInput')->once();
|
2016-12-23 13:33:04 -06:00
|
|
|
$request->setLaravelSession($session);
|
2015-06-01 15:56:31 +01:00
|
|
|
$request->flush();
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-21 12:08:46 -02:00
|
|
|
public function testExpectsJson()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json']);
|
|
|
|
|
$this->assertTrue($request->expectsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*']);
|
|
|
|
|
$this->assertFalse($request->expectsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*', 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest']);
|
|
|
|
|
$this->assertTrue($request->expectsJson());
|
|
|
|
|
|
2017-12-26 16:26:59 -02:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => null, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest']);
|
|
|
|
|
$this->assertTrue($request->expectsJson());
|
|
|
|
|
|
2017-12-21 12:08:46 -02:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*', 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest', 'HTTP_X_PJAX' => 'true']);
|
|
|
|
|
$this->assertFalse($request->expectsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html']);
|
|
|
|
|
$this->assertFalse($request->expectsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html', 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest']);
|
|
|
|
|
$this->assertFalse($request->expectsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html', 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest', 'HTTP_X_PJAX' => 'true']);
|
|
|
|
|
$this->assertFalse($request->expectsJson());
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testFormatReturnsAcceptableFormat()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('json', $request->format());
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->wantsJson());
|
|
|
|
|
|
2015-06-23 17:29:48 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json; charset=utf-8']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('json', $request->format());
|
2015-06-23 17:29:48 +01:00
|
|
|
$this->assertTrue($request->wantsJson());
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/atom+xml']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('atom', $request->format());
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertFalse($request->wantsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'is/not/known']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('html', $request->format());
|
|
|
|
|
$this->assertSame('foo', $request->format('foo'));
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2026-03-17 09:55:49 -04:00
|
|
|
public function testWantsMarkdown()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/markdown']);
|
|
|
|
|
$this->assertTrue($request->wantsMarkdown());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/markdown; charset=utf-8']);
|
|
|
|
|
$this->assertTrue($request->wantsMarkdown());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json']);
|
|
|
|
|
$this->assertFalse($request->wantsMarkdown());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html']);
|
|
|
|
|
$this->assertFalse($request->wantsMarkdown());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAcceptsMarkdown()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/markdown']);
|
|
|
|
|
$this->assertTrue($request->acceptsMarkdown());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html, text/markdown']);
|
|
|
|
|
$this->assertFalse($request->wantsMarkdown());
|
|
|
|
|
$this->assertTrue($request->acceptsMarkdown());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json']);
|
|
|
|
|
$this->assertFalse($request->acceptsMarkdown());
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testFormatReturnsAcceptsJson()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('json', $request->format());
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->accepts('application/json'));
|
|
|
|
|
$this->assertTrue($request->accepts('application/baz+json'));
|
|
|
|
|
$this->assertTrue($request->acceptsJson());
|
|
|
|
|
$this->assertFalse($request->acceptsHtml());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/foo+json']);
|
|
|
|
|
$this->assertTrue($request->accepts('application/foo+json'));
|
|
|
|
|
$this->assertFalse($request->accepts('application/bar+json'));
|
|
|
|
|
$this->assertFalse($request->accepts('application/json'));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/*']);
|
|
|
|
|
$this->assertTrue($request->accepts('application/xml'));
|
|
|
|
|
$this->assertTrue($request->accepts('application/json'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFormatReturnsAcceptsHtml()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('html', $request->format());
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->accepts('text/html'));
|
|
|
|
|
$this->assertTrue($request->acceptsHtml());
|
|
|
|
|
$this->assertFalse($request->acceptsJson());
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/*']);
|
|
|
|
|
$this->assertTrue($request->accepts('text/html'));
|
|
|
|
|
$this->assertTrue($request->accepts('text/plain'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFormatReturnsAcceptsAll()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('html', $request->format());
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->accepts('text/html'));
|
|
|
|
|
$this->assertTrue($request->accepts('foo/bar'));
|
|
|
|
|
$this->assertTrue($request->accepts('application/baz+xml'));
|
|
|
|
|
$this->assertTrue($request->acceptsHtml());
|
|
|
|
|
$this->assertTrue($request->acceptsJson());
|
2015-06-23 17:29:48 +01:00
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*']);
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('html', $request->format());
|
2015-06-23 17:29:48 +01:00
|
|
|
$this->assertTrue($request->accepts('text/html'));
|
|
|
|
|
$this->assertTrue($request->accepts('foo/bar'));
|
|
|
|
|
$this->assertTrue($request->accepts('application/baz+xml'));
|
|
|
|
|
$this->assertTrue($request->acceptsHtml());
|
|
|
|
|
$this->assertTrue($request->acceptsJson());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFormatReturnsAcceptsMultiple()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json,text/*']);
|
|
|
|
|
$this->assertTrue($request->accepts(['text/html', 'application/json']));
|
|
|
|
|
$this->assertTrue($request->accepts('text/html'));
|
|
|
|
|
$this->assertTrue($request->accepts('text/foo'));
|
|
|
|
|
$this->assertTrue($request->accepts('application/json'));
|
2015-06-23 17:29:48 +01:00
|
|
|
$this->assertTrue($request->accepts('application/baz+json'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFormatReturnsAcceptsCharset()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json; charset=utf-8']);
|
|
|
|
|
$this->assertTrue($request->accepts(['text/html', 'application/json']));
|
|
|
|
|
$this->assertFalse($request->accepts('text/html'));
|
|
|
|
|
$this->assertFalse($request->accepts('text/foo'));
|
|
|
|
|
$this->assertTrue($request->accepts('application/json'));
|
2015-06-01 15:56:31 +01:00
|
|
|
$this->assertTrue($request->accepts('application/baz+json'));
|
|
|
|
|
}
|
|
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
public function testWantsJsonRespectsHeaderChanges()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*']);
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertFalse($request->wantsJson());
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertTrue($request->acceptsAnyContentType());
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'application/json');
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($request->wantsJson(), 'wantsJson() should return true after Accept header is changed to application/json');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAcceptsJsonRespectsHeaderChanges()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*']);
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($request->acceptsAnyContentType());
|
|
|
|
|
|
|
|
|
|
$request->headers->set('Accept', 'application/json');
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($request->acceptsJson(), 'acceptsJson() should return true after Accept header is changed to application/json');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testPrefersRespectsHeaderChanges()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '*/*']);
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertTrue($request->acceptsAnyContentType());
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'application/json');
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertSame('json', $request->prefers(['html', 'json']), 'prefers() should return json after Accept header is changed to application/json');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testWantsJsonWorksWhenHeaderSetBeforeFirstCall()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], []);
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'application/json');
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertTrue($request->wantsJson(), 'wantsJson() should return true when Accept header is set to application/json');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testCacheClearedWhenTransitioningFromUnsetToSetHeader()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], []);
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->getAcceptableContentTypes();
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'application/json');
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertTrue($request->wantsJson(), 'wantsJson() should return true after Accept header is set from null to application/json');
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertTrue($request->acceptsJson(), 'acceptsJson() should return true after Accept header is set from null to application/json');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAcceptsJsonWorksWhenHeaderChangedMultipleTimes()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'text/html']);
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$this->assertFalse($request->acceptsJson());
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'application/json');
|
|
|
|
|
$this->assertTrue($request->acceptsJson());
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'text/html');
|
|
|
|
|
$this->assertFalse($request->acceptsJson());
|
2025-11-24 21:58:20 +00:00
|
|
|
|
2025-11-25 05:57:52 +08:00
|
|
|
$request->headers->set('Accept', 'application/json');
|
|
|
|
|
$this->assertTrue($request->acceptsJson());
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-06 14:29:29 +01:00
|
|
|
public function testBadAcceptHeader()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'Mozilla/5.0 (Windows; U; Windows NT 5.1; pt-PT; rv:1.9.1.2) Gecko/20090729 Firefox/3.5.2 (.NET CLR 3.5.30729)']);
|
|
|
|
|
$this->assertFalse($request->accepts(['text/html', 'application/json']));
|
|
|
|
|
$this->assertFalse($request->accepts('text/html'));
|
|
|
|
|
$this->assertFalse($request->accepts('text/foo'));
|
|
|
|
|
$this->assertFalse($request->accepts('application/json'));
|
|
|
|
|
$this->assertFalse($request->accepts('application/baz+json'));
|
|
|
|
|
$this->assertFalse($request->acceptsHtml());
|
|
|
|
|
$this->assertFalse($request->acceptsJson());
|
2016-04-08 06:16:58 +02:00
|
|
|
|
|
|
|
|
// Should not be handled as regex.
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '.+/.+']);
|
|
|
|
|
$this->assertFalse($request->accepts('application/json'));
|
|
|
|
|
$this->assertFalse($request->accepts('application/baz+json'));
|
|
|
|
|
|
|
|
|
|
// Should not produce compilation error on invalid regex.
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => '(/(']);
|
|
|
|
|
$this->assertFalse($request->accepts('text/html'));
|
2016-04-06 14:29:29 +01:00
|
|
|
}
|
|
|
|
|
|
2021-10-29 18:55:02 +05:30
|
|
|
public function testCaseInsensitiveAcceptHeader()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'APPLICATION/JSON']);
|
|
|
|
|
$this->assertTrue($request->accepts(['text/html', 'application/json']));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'AppLiCaTion/JsOn']);
|
|
|
|
|
$this->assertTrue($request->accepts(['text/html', 'application/json']));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'APPLICATION/*']);
|
|
|
|
|
$this->assertTrue($request->accepts(['text/html', 'application/json']));
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'APPLICATION/JSON']);
|
|
|
|
|
$this->assertTrue($request->expectsJson());
|
2016-04-06 14:29:29 +01:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testSessionMethod()
|
|
|
|
|
{
|
2019-02-07 17:04:40 +01:00
|
|
|
$this->expectException(RuntimeException::class);
|
|
|
|
|
$this->expectExceptionMessage('Session store not set on request.');
|
|
|
|
|
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2015-06-01 15:56:31 +01:00
|
|
|
$request->session();
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-15 14:59:57 +00:00
|
|
|
public function testHasSessionMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/');
|
|
|
|
|
|
|
|
|
|
$this->assertFalse($request->hasSession());
|
|
|
|
|
|
|
|
|
|
$session = m::mock(Store::class);
|
|
|
|
|
$request->setLaravelSession($session);
|
|
|
|
|
|
|
|
|
|
$this->assertTrue($request->hasSession());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testGetSessionMethodWithLaravelSession()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/');
|
|
|
|
|
|
|
|
|
|
$laravelSession = m::mock(Store::class);
|
|
|
|
|
$request->setLaravelSession($laravelSession);
|
|
|
|
|
|
|
|
|
|
$session = $request->getSession();
|
|
|
|
|
$this->assertInstanceOf(SessionInterface::class, $session);
|
|
|
|
|
|
|
|
|
|
$laravelSession->shouldReceive('start')->once()->andReturn(true);
|
|
|
|
|
$session->start();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testGetSessionMethodWithoutLaravelSession()
|
|
|
|
|
{
|
|
|
|
|
$this->expectException(SessionNotFoundException::class);
|
|
|
|
|
$this->expectExceptionMessage('There is currently no session available.');
|
|
|
|
|
|
|
|
|
|
$request = Request::create('/');
|
|
|
|
|
|
|
|
|
|
$request->getSession();
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:56:31 +01:00
|
|
|
public function testUserResolverMakesUserAvailableAsMagicProperty()
|
|
|
|
|
{
|
2015-06-01 16:35:44 +01:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], ['HTTP_ACCEPT' => 'application/json']);
|
2016-05-28 22:16:16 +01:00
|
|
|
$request->setUserResolver(function () {
|
|
|
|
|
return 'user';
|
|
|
|
|
});
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('user', $request->user());
|
2015-06-01 15:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
2016-08-01 10:52:33 -03:00
|
|
|
public function testFingerprintMethod()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', [], [], [], []);
|
|
|
|
|
$request->setRouteResolver(function () use ($request) {
|
|
|
|
|
$route = new Route('GET', '/foo/bar/{id}', []);
|
|
|
|
|
$route->bind($request);
|
|
|
|
|
|
|
|
|
|
return $route;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
$this->assertEquals(40, mb_strlen($request->fingerprint()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testFingerprintWithoutRoute()
|
|
|
|
|
{
|
2019-02-07 17:04:40 +01:00
|
|
|
$this->expectException(RuntimeException::class);
|
|
|
|
|
$this->expectExceptionMessage('Unable to generate fingerprint. Route unavailable.');
|
|
|
|
|
|
2016-08-01 10:52:33 -03:00
|
|
|
$request = Request::create('/', 'GET', [], [], [], []);
|
|
|
|
|
$request->fingerprint();
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-09 07:46:19 -06:00
|
|
|
/**
|
|
|
|
|
* Ensure JSON GET requests populate $request->request with the JSON content.
|
|
|
|
|
*
|
|
|
|
|
* @link https://github.com/laravel/framework/pull/7052 Correctly fill the $request->request parameter bag on creation.
|
|
|
|
|
*/
|
|
|
|
|
public function testJsonRequestFillsRequestBodyParams()
|
2015-06-01 15:56:31 +01:00
|
|
|
{
|
|
|
|
|
$body = [
|
|
|
|
|
'foo' => 'bar',
|
|
|
|
|
'baz' => ['qux'],
|
|
|
|
|
];
|
|
|
|
|
|
2015-06-01 16:35:44 +01:00
|
|
|
$server = [
|
2015-06-01 15:56:31 +01:00
|
|
|
'CONTENT_TYPE' => 'application/json',
|
2015-06-01 16:35:44 +01:00
|
|
|
];
|
2015-06-01 15:56:31 +01:00
|
|
|
|
2015-06-01 16:35:44 +01:00
|
|
|
$base = SymfonyRequest::create('/', 'GET', [], [], [], $server, json_encode($body));
|
2015-06-01 15:56:31 +01:00
|
|
|
|
|
|
|
|
$request = Request::createFromBase($base);
|
|
|
|
|
|
|
|
|
|
$this->assertEquals($request->request->all(), $body);
|
|
|
|
|
}
|
2015-09-14 14:05:26 +02:00
|
|
|
|
2021-08-09 07:46:19 -06:00
|
|
|
/**
|
|
|
|
|
* Ensure non-JSON GET requests don't pollute $request->request with the GET parameters.
|
|
|
|
|
*
|
|
|
|
|
* @link https://github.com/laravel/framework/pull/37921 Manually populate POST request body with JSON data only when required.
|
|
|
|
|
*/
|
|
|
|
|
public function testNonJsonRequestDoesntFillRequestBodyParams()
|
|
|
|
|
{
|
|
|
|
|
$params = ['foo' => 'bar'];
|
|
|
|
|
|
|
|
|
|
$getRequest = Request::create('/', 'GET', $params, [], [], []);
|
|
|
|
|
$this->assertEquals($getRequest->request->all(), []);
|
|
|
|
|
$this->assertEquals($getRequest->query->all(), $params);
|
|
|
|
|
|
|
|
|
|
$postRequest = Request::create('/', 'POST', $params, [], [], []);
|
|
|
|
|
$this->assertEquals($postRequest->request->all(), $params);
|
|
|
|
|
$this->assertEquals($postRequest->query->all(), []);
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-30 21:58:35 -03:00
|
|
|
/**
|
2015-10-01 09:13:28 -03:00
|
|
|
* Tests for Http\Request magic methods `__get()` and `__isset()`.
|
|
|
|
|
*
|
|
|
|
|
* @link https://github.com/laravel/framework/issues/10403 Form request object attribute returns empty when have some string.
|
2015-09-30 21:58:35 -03:00
|
|
|
*/
|
2015-10-01 12:46:24 -03:00
|
|
|
public function testMagicMethods()
|
|
|
|
|
{
|
|
|
|
|
// Simulates QueryStrings.
|
|
|
|
|
$request = Request::create('/', 'GET', ['foo' => 'bar', 'empty' => '']);
|
|
|
|
|
|
|
|
|
|
// Parameter 'foo' is 'bar', then it ISSET and is NOT EMPTY.
|
2020-10-05 21:58:25 +03:00
|
|
|
$this->assertSame('bar', $request->foo);
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertTrue(isset($request->foo));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertNotEmpty($request->foo);
|
2015-10-01 12:46:24 -03:00
|
|
|
|
|
|
|
|
// Parameter 'empty' is '', then it ISSET and is EMPTY.
|
2020-10-05 21:58:25 +03:00
|
|
|
$this->assertSame('', $request->empty);
|
2017-05-09 13:11:01 -05:00
|
|
|
$this->assertTrue(isset($request->empty));
|
2018-01-15 15:12:56 +01:00
|
|
|
$this->assertEmpty($request->empty);
|
2015-10-01 12:46:24 -03:00
|
|
|
|
|
|
|
|
// Parameter 'undefined' is undefined/null, then it NOT ISSET and is EMPTY.
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertNull($request->undefined);
|
|
|
|
|
$this->assertFalse(isset($request->undefined));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertEmpty($request->undefined);
|
2015-10-01 12:46:24 -03:00
|
|
|
|
|
|
|
|
// Simulates Route parameters.
|
2016-12-25 04:26:32 +02:00
|
|
|
$request = Request::create('/example/bar', 'GET', ['xyz' => 'overwritten']);
|
2015-10-01 12:46:24 -03:00
|
|
|
$request->setRouteResolver(function () use ($request) {
|
|
|
|
|
$route = new Route('GET', '/example/{foo}/{xyz?}/{undefined?}', []);
|
|
|
|
|
$route->bind($request);
|
|
|
|
|
|
|
|
|
|
return $route;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
// Router parameter 'foo' is 'bar', then it ISSET and is NOT EMPTY.
|
2019-08-27 14:48:17 +02:00
|
|
|
$this->assertSame('bar', $request->foo);
|
|
|
|
|
$this->assertSame('bar', $request['foo']);
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertTrue(isset($request->foo));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertNotEmpty($request->foo);
|
2015-10-01 12:46:24 -03:00
|
|
|
|
|
|
|
|
// Router parameter 'undefined' is undefined/null, then it NOT ISSET and is EMPTY.
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertNull($request->undefined);
|
|
|
|
|
$this->assertFalse(isset($request->undefined));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertEmpty($request->undefined);
|
2015-10-01 12:46:24 -03:00
|
|
|
|
2016-12-25 04:26:32 +02:00
|
|
|
// Special case: router parameter 'xyz' is 'overwritten' by QueryString, then it ISSET and is NOT EMPTY.
|
2015-10-01 12:46:24 -03:00
|
|
|
// Basically, QueryStrings have priority over router parameters.
|
2020-10-05 21:58:25 +03:00
|
|
|
$this->assertSame('overwritten', $request->xyz);
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertTrue(isset($request->foo));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertNotEmpty($request->foo);
|
2015-10-01 12:46:24 -03:00
|
|
|
|
|
|
|
|
// Simulates empty QueryString and Routes.
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2015-10-01 12:46:24 -03:00
|
|
|
$request->setRouteResolver(function () use ($request) {
|
|
|
|
|
$route = new Route('GET', '/', []);
|
|
|
|
|
$route->bind($request);
|
2015-09-30 21:58:35 -03:00
|
|
|
|
2015-10-01 12:46:24 -03:00
|
|
|
return $route;
|
|
|
|
|
});
|
2015-09-30 21:58:35 -03:00
|
|
|
|
2015-10-01 12:46:24 -03:00
|
|
|
// Parameter 'undefined' is undefined/null, then it NOT ISSET and is EMPTY.
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertNull($request->undefined);
|
|
|
|
|
$this->assertFalse(isset($request->undefined));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertEmpty($request->undefined);
|
2015-09-30 21:58:35 -03:00
|
|
|
|
2015-10-01 12:46:24 -03:00
|
|
|
// Special case: simulates empty QueryString and Routes, without the Route Resolver.
|
|
|
|
|
// It'll happen when you try to get a parameter outside a route.
|
2021-12-03 22:33:34 +07:00
|
|
|
$request = Request::create('/');
|
2015-09-30 21:58:35 -03:00
|
|
|
|
2015-10-01 12:46:24 -03:00
|
|
|
// Parameter 'undefined' is undefined/null, then it NOT ISSET and is EMPTY.
|
2020-10-05 21:33:08 +03:00
|
|
|
$this->assertNull($request->undefined);
|
|
|
|
|
$this->assertFalse(isset($request->undefined));
|
2021-03-19 01:06:23 +01:00
|
|
|
$this->assertEmpty($request->undefined);
|
2015-09-30 21:58:35 -03:00
|
|
|
}
|
|
|
|
|
|
2015-09-14 14:05:26 +02:00
|
|
|
public function testHttpRequestFlashCallsSessionFlashInputWithInputData()
|
|
|
|
|
{
|
2018-10-05 14:48:10 +02:00
|
|
|
$session = m::mock(Store::class);
|
2015-09-14 14:05:26 +02:00
|
|
|
$session->shouldReceive('flashInput')->once()->with(['name' => 'Taylor', 'email' => 'foo']);
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
2016-12-23 13:33:04 -06:00
|
|
|
$request->setLaravelSession($session);
|
2015-09-14 14:05:26 +02:00
|
|
|
$request->flash();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testHttpRequestFlashOnlyCallsFlashWithProperParameters()
|
|
|
|
|
{
|
2018-10-05 14:48:10 +02:00
|
|
|
$session = m::mock(Store::class);
|
2016-12-19 16:28:12 -06:00
|
|
|
$session->shouldReceive('flashInput')->once()->with(['name' => 'Taylor']);
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
2016-12-23 13:33:04 -06:00
|
|
|
$request->setLaravelSession($session);
|
2016-12-19 16:28:12 -06:00
|
|
|
$request->flashOnly(['name']);
|
2015-09-14 14:05:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testHttpRequestFlashExceptCallsFlashWithProperParameters()
|
|
|
|
|
{
|
2018-10-05 14:48:10 +02:00
|
|
|
$session = m::mock(Store::class);
|
2016-12-19 16:28:12 -06:00
|
|
|
$session->shouldReceive('flashInput')->once()->with(['name' => 'Taylor']);
|
|
|
|
|
$request = Request::create('/', 'GET', ['name' => 'Taylor', 'email' => 'foo']);
|
2016-12-23 13:33:04 -06:00
|
|
|
$request->setLaravelSession($session);
|
2016-12-19 16:28:12 -06:00
|
|
|
$request->flashExcept(['email']);
|
2015-09-14 14:05:26 +02:00
|
|
|
}
|
2023-07-26 13:12:33 +10:00
|
|
|
|
|
|
|
|
public function testGeneratingJsonRequestFromParentRequestUsesCorrectType()
|
|
|
|
|
{
|
|
|
|
|
if (! method_exists(SymfonyRequest::class, 'getPayload')) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$base = SymfonyRequest::create('/', 'POST', server: ['CONTENT_TYPE' => 'application/json'], content: '{"hello":"world"}');
|
|
|
|
|
|
|
|
|
|
$request = Request::createFromBase($base);
|
|
|
|
|
|
|
|
|
|
$this->assertInstanceOf(InputBag::class, $request->getPayload());
|
|
|
|
|
$this->assertSame('world', $request->getPayload()->get('hello'));
|
|
|
|
|
}
|
2023-08-01 09:54:26 +10:00
|
|
|
|
|
|
|
|
public function testJsonRequestsCanMergeDataIntoJsonRequest()
|
|
|
|
|
{
|
|
|
|
|
if (! method_exists(SymfonyRequest::class, 'getPayload')) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$base = SymfonyRequest::create('/', 'POST', server: ['CONTENT_TYPE' => 'application/json'], content: '{"first":"Taylor","last":"Otwell"}');
|
|
|
|
|
$request = Request::createFromBase($base);
|
|
|
|
|
|
|
|
|
|
$request->merge([
|
|
|
|
|
'name' => $request->get('first').' '.$request->get('last'),
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
$this->assertSame('Taylor Otwell', $request->get('name'));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testItCanHaveObjectsInJsonPayload()
|
|
|
|
|
{
|
|
|
|
|
if (! method_exists(SymfonyRequest::class, 'getPayload')) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$base = SymfonyRequest::create('/', 'POST', server: ['CONTENT_TYPE' => 'application/json'], content: '{"framework":{"name":"Laravel"}}');
|
|
|
|
|
$request = Request::createFromBase($base);
|
|
|
|
|
|
|
|
|
|
$value = $request->get('framework');
|
|
|
|
|
|
|
|
|
|
$this->assertSame(['name' => 'Laravel'], $request->get('framework'));
|
|
|
|
|
}
|
2024-07-22 09:33:35 -05:00
|
|
|
|
|
|
|
|
public function testItDoesNotGenerateJsonErrorsForEmptyContent()
|
|
|
|
|
{
|
|
|
|
|
// clear any existing errors
|
|
|
|
|
json_encode(null);
|
|
|
|
|
|
|
|
|
|
Request::create('', 'GET')->json();
|
|
|
|
|
|
|
|
|
|
$this->assertTrue(json_last_error() === JSON_ERROR_NONE);
|
|
|
|
|
}
|
2026-02-04 10:13:49 -05:00
|
|
|
|
|
|
|
|
public function testItClampsValues()
|
|
|
|
|
{
|
|
|
|
|
$request = Request::create('/', 'GET', ['per_page' => 100, 'float' => 9.24]);
|
|
|
|
|
$this->assertSame(100, $request->clamp('per_page', 100, 101));
|
|
|
|
|
$this->assertSame(10, $request->clamp('per_page', -10, 10));
|
|
|
|
|
$this->assertSame(25, $request->clamp('per_page_2', 25, 100, 1));
|
|
|
|
|
$this->assertSame(100, $request->clamp('per_page', 1, 250, 99));
|
|
|
|
|
$this->assertSame(22.4, $request->clamp('per_page', 1.11, 22.4, 2));
|
|
|
|
|
$this->assertSame(9.24, $request->clamp('float', 1, 10));
|
|
|
|
|
}
|
2013-02-21 18:25:48 -05:00
|
|
|
}
|
