Adding factory and other helper assertions (#34)

srtfisher · web-flow · commit 2c36290884b9 · 2025-10-07T09:45:07.000-04:00
* WIP on upgrade to pest 4.0

* Prepare for upgrade

* Enable for branch

* Fix static

* Fix static

* Drop node

* Adjust workflow

* Drop 8.2

* Drop tests

* Adding more helper assertions

* Appeasing phpstan

* Appease pint

* CHANGELOG

* Removing old

* Removing .phpunit.cache/test-results

* Rector fix
diff --git a/.gitignore b/.gitignore
@@ -11,3 +11,4 @@ coverage.xml
 *.swo
 .vscode
 .DS_Store
+.phpunit.cache
diff --git a/.php-cs-fixer.dist.php b/.php-cs-fixer.dist.php
diff --git a/.phpunit.cache/test-results b/.phpunit.cache/test-results
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## Unreleased
 
 - Upgrade to Pest 4.0. Requires PHP 8.3+ and `mantle-framework/testkit` 1.9+.
+- Added multiple new helpers including `factory()`, `actingAs()`, and `fakeRequest()`.
 
 ## v0.5.0
 
diff --git a/composer.json b/composer.json
@@ -32,7 +32,8 @@
         }
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^4.0"
+        "pestphp/pest-dev-tools": "^4.0",
+        "szepeviktor/phpstan-wordpress": "^2.0"
     },
     "extra": {
         "branch-alias": {
@@ -59,10 +60,12 @@
     "scripts": {
         "rector": "rector",
         "lint": "pint",
+        "phpstan": "phpstan --memory-limit=512M",
         "test:rector": "rector --dry-run",
         "test:lint": "pint --test",
-        "test:types": "phpstan analyse --ansi",
+        "test:types": "@phpstan",
         "test:unit": "pest --colors=always",
+        "test:watch": "npx nodemon --watch tests --exec \"composer test:unit\" -e php",
         "test": [
             "@test:rector",
             "@test:lint",
diff --git a/phpstan.neon b/phpstan.neon
@@ -1,3 +1,6 @@
+includes:
+  - vendor/szepeviktor/phpstan-wordpress/extension.neon
+
 parameters:
     level: max
     paths:
diff --git a/src/Autoload.php b/src/Autoload.php
@@ -2,4 +2,15 @@
 
 declare(strict_types=1);
 
-require_once __DIR__.'/Http.php';
+(static function (): void {
+    $files = [
+        'Factory.php',
+        'Http.php',
+        'RemoteRequest.php',
+        'User.php',
+    ];
+
+    foreach ($files as $file) {
+        require_once __DIR__."/{$file}";
+    }
+})();
diff --git a/src/Factory.php b/src/Factory.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\PestPluginWordPress;
+
+use Mantle\Database\Factory\Factory_Container;
+use Mantle\Testing\TestCase;
+
+/**
+ * Get the factory container instance.
+ */
+function factory(): Factory_Container
+{
+    return TestCase::factory();
+}
diff --git a/src/Http.php b/src/Http.php
@@ -29,6 +29,14 @@ function from(string $url): Pending_Testable_Request
     return test()->with_header('referer', $url);
 }
 
+/**
+ * Start a fluent request to the application.
+ */
+function request(): Pending_Testable_Request
+{
+    return test()->with_headers([]);
+}
+
 /**
  * Visit the given URI with a GET request.
  *
@@ -39,3 +47,84 @@ function get(mixed $uri, array $headers = []): Test_Response
 {
     return test()->get($uri, $headers);
 }
+
+/**
+ * Visit the given URI with a POST request.
+ *
+ * @param  mixed  $uri  request URI
+ * @param  array<string, mixed>  $data  request data
+ * @param  array<string, string>  $headers  request Headers to load
+ */
+function post(mixed $uri, array $data = [], array $headers = []): Test_Response
+{
+    return test()->post($uri, $data, $headers);
+}
+
+/**
+ * Visit the given URI with a PUT request.
+ *
+ * @param  mixed  $uri  request URI
+ * @param  array<string, mixed>  $data  request data
+ * @param  array<string, string>  $headers  request Headers to load
+ */
+function put(mixed $uri, array $data = [], array $headers = []): Test_Response
+{
+    return test()->put($uri, $data, $headers);
+}
+
+/**
+ * Visit the given URI with a PATCH request.
+ *
+ * @param  mixed  $uri  request URI
+ * @param  array<string, mixed>  $data  request data
+ * @param  array<string, string>  $headers  request Headers to load
+ */
+function patch(mixed $uri, array $data = [], array $headers = []): Test_Response
+{
+    return test()->patch($uri, $data, $headers);
+}
+
+/**
+ * Visit the given URI with a DELETE request.
+ *
+ * @param  mixed  $uri  request URI
+ * @param  array<string, mixed>  $data  request data
+ * @param  array<string, string>  $headers  request Headers to load
+ */
+function delete(mixed $uri, array $data = [], array $headers = []): Test_Response
+{
+    return test()->delete($uri, $data, $headers);
+}
+
+/**
+ * Visit the given URI with an OPTIONS request.
+ *
+ * @param  mixed  $uri  request URI
+ * @param  array<string, mixed>  $data  request data
+ * @param  array<string, string>  $headers  request Headers to load
+ */
+function options(mixed $uri, array $data = [], array $headers = []): Test_Response
+{
+    return test()->options($uri, $data, $headers);
+}
+
+/**
+ * Visit the given URI with a HEAD request.
+ *
+ * @param  mixed  $uri  request URI
+ * @param  array<string, string>  $headers  request Headers to load
+ */
+function head(mixed $uri, array $headers = []): Test_Response
+{
+    return test()->head($uri, $headers);
+}
+
+/**
+ * Create a WordPress post and visit its permalink with a GET request.
+ *
+ * @param  array<string, mixed>  $arguments  request data
+ */
+function fetchPost(array $arguments = []): Test_Response
+{
+    return test()->get(factory()->post->create_and_get($arguments));
+}
diff --git a/src/RemoteRequest.php b/src/RemoteRequest.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\PestPluginWordPress;
+
+use Closure;
+use Mantle\Contracts\Support\Arrayable;
+use Mantle\Http_Client\Http_Method;
+use Mantle\Http_Client\Request;
+use Mantle\Testing\Mock_Http_Response;
+use Mantle\Testing\Mock_Http_Sequence;
+
+/**
+ * Fake a remote HTTP request.
+ *
+ * @template TCallableReturn of Mock_Http_Sequence|Mock_Http_Response|Arrayable|null
+ *
+ * @param  (callable(string|Request, ?array<mixed>): TCallableReturn)|Mock_Http_Response|string|array<string, Mock_Http_Response|callable>  $url_or_callback  URL to fake, array of URL and response pairs, or a closure
+ *                                                                                                                                                            that will return a faked response.
+ * @param  Mock_Http_Response|array<mixed>|callable  $response  Optional response object, defaults to a 200 response with no body.
+ * @param  Http_Method|string|null  $method  Optional request method to apply to, defaults to all. Does not apply to array of URL and response pairs OR callbacks.
+ */
+function fakeRequest(
+    Mock_Http_Response|callable|string|array|null $url_or_callback = null,
+    Mock_Http_Response|array|callable|null $response = null,
+    Http_Method|string|null $method = null
+): ?Mock_Http_Response {
+    return test()->fake_request($url_or_callback, $response, $method);
+}
+
+/**
+ * Prevent any stray HTTP requests.
+ *
+ * @param  Mock_Http_Response|Closure|bool  $response  Optional response or boolean to enable/disable. Defaults to true, which will return a 500 response for any stray requests.
+ */
+function preventStrayRequests(Mock_Http_Response|Closure|bool $response = true): void
+{
+    test()->prevent_stray_requests($response);
+}
+
+/**
+ * Allow stray HTTP requests.
+ */
+function allowStrayRequests(): void
+{
+    test()->allow_stray_requests();
+}
diff --git a/src/User.php b/src/User.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\PestPluginWordPress;
+
+use Mantle\Database\Model\User;
+use WP_User;
+
+/**
+ * Set the currently authenticated user for the application.
+ *
+ * @param  User|WP_User|string|int|null  $user  The user to authenticate as. Can be a User model, WP_User object, user ID, or user login. If null, will log out the current user.
+ * @return User|WP_User The authenticated user instance.
+ */
+function actingAs(User|WP_User|string|int|null $user): User|WP_User
+{
+    return test()->acting_as($user);
+}
+
+/**
+ * Assert that the current user is authenticated.
+ *
+ * @param  User|WP_User|string|int|null|mixed  $user  User to check, optional.
+ */
+function assertAuthenticated(mixed $user = null): void
+{
+    test()->assertAuthenticated($user);
+}
+
+/**
+ * Assert that the current user is not authenticated.
+ */
+function assertNotAuthenticated(): void
+{
+    test()->assertNotAuthenticated();
+}
diff --git a/tests/Factory.php b/tests/Factory.php
@@ -0,0 +1,9 @@
+<?php
+
+use function Pest\PestPluginWordPress\factory;
+
+it('should create a post and get it', function () {
+    $post = factory()->post->create_and_get();
+
+    expect($post)->toBeInstanceOf(WP_Post::class);
+});
diff --git a/tests/Homepage.php b/tests/Homepage.php
diff --git a/tests/Http.php b/tests/Http.php
@@ -0,0 +1,28 @@
+<?php
+
+use function Pest\PestPluginWordPress\fetchPost;
+use function Pest\PestPluginWordPress\from;
+use function Pest\PestPluginWordPress\get;
+use function Pest\PestPluginWordPress\request;
+
+it('should load the homepage', function () {
+    get('/')
+        ->assertStatus(200)
+        ->assertSee('home');
+});
+
+it('should load with a referrer', function () {
+    from('https://laravel.com/')
+        ->get('/')
+        ->assertStatus(200);
+});
+
+it('should be able to make a request fluently', function () {
+    request()
+        ->get('/')
+        ->assertStatus(200);
+});
+
+it('should be able to fetch a post', function () {
+    fetchPost()->assertOk()->assertQueryTrue('is_single', 'is_singular');
+});
diff --git a/tests/RemoteRequest.php b/tests/RemoteRequest.php
@@ -0,0 +1,25 @@
+<?php
+
+use Mantle\Http_Client\Pending_Request;
+use Mantle\Testing\Exceptions\Stray_Request_Exception;
+
+use function Pest\PestPluginWordPress\fakeRequest;
+use function Pest\PestPluginWordPress\preventStrayRequests;
+
+it('should fake a remote request', function () {
+    preventStrayRequests();
+
+    fakeRequest('https://example.com')->with_json(['foo' => 'bar']);
+
+    $request = Pending_Request::create()->get('https://example.com');
+
+    $this->assertEquals('bar', $request->json('foo'));
+});
+
+it('should throw an error for a stray request', function () {
+    preventStrayRequests();
+
+    $this->expectException(Stray_Request_Exception::class);
+
+    Pending_Request::create()->get('https://stray-request.com');
+});
diff --git a/tests/User.php b/tests/User.php
@@ -0,0 +1,13 @@
+<?php
+
+use function Pest\PestPluginWordPress\actingAs;
+use function Pest\PestPluginWordPress\assertAuthenticated;
+use function Pest\PestPluginWordPress\assertNotAuthenticated;
+
+it('should authenticate as a user', function () {
+    assertNotAuthenticated();
+
+    actingAs('administrator');
+
+    assertAuthenticated();
+});
