HTTP Tests

• 简介
  • 自定义请求头
• Sitzung /认证
• 测试 JSON APIs
• Testing文件上传
• 可用的断言方法
  • 响应断言
  • 认证断言

Einführung

Laravel bietet eine sehr flüssige API sowohl für die Generierung von HTTP-Anfragen als auch für die Überprüfung der Ausgabe. Sie können sich beispielsweise den folgenden Testfall ansehen: Die Methode

<?php
    namespace Tests\Feature;
    use Tests\TestCase;
    use Illuminate\Foundation\Testing\RefreshDatabase;
    use Illuminate\Foundation\Testing\WithoutMiddleware;
    class ExampleTest extends TestCase{    
    /**
     * 一个基础的测试用例。
     *
     * @return void
     */   
     public function testBasicTest() 
        {     
           $response = $this->get('/');        
           $response->assertStatus(200);  
         }
      }

get erstellt eine GET-Anfrage an Ihre Anwendung und die Methode assertStatus stellt sicher, dass die zurückgegebene Antwort den angegebenen HTTP-Status hat Code. Zusätzlich zu dieser einfachen Behauptung enthält Laravel auch verschiedene Behauptungen, die Antwortheader, Inhalt, JSON, Struktur usw. überprüfen.

Benutzerdefinierte Anforderungsheader

Sie können die withHeaders-Methode verwenden, um die Anforderung anzupassen, bevor Sie sie an senden Anwendungsheader. Sie können beliebige benutzerdefinierte Header hinzufügen.

<?php
    class ExampleTest extends TestCase{
     /**
     * 一个基础的功能测试用例。
     *
     * @return void
     */  
       public function testBasicExample() 
          {     
             $response = $this->withHeaders([        
                 'X-Header' => 'Value',        
               ])->json('POST', '/user', ['name' => 'Sally']);        
              $response      
                    ->assertStatus(201)            
                    ->assertJson([        
                            'created' => true,           
                            ]); 
                         }
                      }

{tip} Die CSRF-Middleware wird beim Ausführen von Tests automatisch deaktiviert.

Sitzung/Authentifizierung

Laravel bietet mehrere Helfer für die Verwendung von Session während der HTTP-Testfunktion. Zuerst müssen Sie ein Array an die Methode withSession übergeben, um die Sitzungsdaten festzulegen. Dadurch können Sie die Sitzung ganz einfach mit Daten laden, bevor Sie die Testanfrage der Anwendung senden:

<?php
    class ExampleTest extends TestCase{  
      public function testApplication()  
        {     
           $response = $this->withSession(['foo' => 'bar'])              
                      ->get('/'); 
         }
    }

Natürlich wird die Sitzung im Allgemeinen zur Aufrechterhaltung des Benutzerstatus verwendet, beispielsweise zur Authentifizierung von Benutzern. actingAs Hilfsfunktionen bieten eine einfache Möglichkeit, den Benutzer anzugeben, der sich als aktueller Benutzer authentifizieren soll. Beispielsweise können wir das Factory-Modell verwenden, um Benutzer zu generieren und zu authentifizieren:

<?php
    use App\User;
    class ExampleTest extends TestCase{ 
       public function testApplication()  
         {     
            $user = factory(User::class)->create();        
            $response = $this->actingAs($user)                 
                    ->withSession(['foo' => 'bar'])                        
                    ->get('/');  
          }
     }

Sie können auch angeben, über welchen Watcher der Benutzer authentifiziert wird, indem Sie den Watcher-Namen als zweiten Parameter von actingAs übergeben:

$this->actingAs($user, 'api')

JSON testen APIs

Laravel bietet außerdem mehrere Hilfsfunktionen zum Testen von JSON-APIs und deren Antworten. Beispielsweise können json, get, post, put, patch und delete zum Senden verschiedener HTTP-Aktionen verwendet werden. Sie können diesen Methoden auch problemlos Daten und Anforderungsheader übergeben. Beginnen wir mit der Verwendung, indem wir eine POST-Anfrage an /user schreiben und bestätigen, dass die erwarteten Daten zurückgegeben werden:

<?php
    class ExampleTest extends TestCase{   
     /**
     * 一个简单的功能测试用例。
     *
     * @return void
     */   
     public function testBasicExample() 
        {    
            $response = $this->json('POST', '/user', ['name' => 'Sally']);     
            $response        
                ->assertStatus(201)            
                ->assertJson([         
                       'created' => true,           
                       ]);  
         }
     }

{tip} Die assertJson-Methode wandelt die Antwort in ein Array um und verwendet das PHPUnit::assertArraySubset, um zu überprüfen, ob das angegebene Array in der von der Anwendung zurückgegebenen JSON-Antwort vorhanden ist. Wenn also andere Attribute in der JSON-Antwort vorhanden sind, wird der Test trotzdem bestanden, sofern das Array vorhanden ist:

Überprüfen Sie eine genaue Übereinstimmung

, wenn Sie ein bestimmtes Array exakt überprüfen möchten Um von einer Anwendung zurückgegebene JSON-Ergebnisse abzugleichen, sollten Sie die Methode assertExactJson verwenden:

<?php
    class ExampleTest extends TestCase{   
     /**
     * 一个基本的功能测试用例。
     *
     * @return void
     */  
      public function testBasicExample()  
        {     
           $response = $this->json('POST', '/user', ['name' => 'Sally']);        
           $response         
              ->assertStatus(201)            
              ->assertExactJson([           
                   'created' => true,           
                  ]);  
         }
     }

Testdatei-Upload

IlluminateHttpUploadedFile bietet eine fake Methode zum Generieren virtueller Dateien oder Bilder zu Testzwecken. Es kann mit der Storage-Methode der fake-Fassade kombiniert werden, um das Testen des Datei-Uploads erheblich zu vereinfachen. Beispielsweise können Sie die beiden Funktionen kombinieren, um das Avatar-Upload-Formular ganz bequem zu testen:

<?php
    namespace Tests\Feature;
    use Tests\TestCase;
    use Illuminate\Http\UploadedFile;
    use Illuminate\Support\Facades\Storage;
    use Illuminate\Foundation\Testing\RefreshDatabase;
    use Illuminate\Foundation\Testing\WithoutMiddleware;
    class ExampleTest extends TestCase{
        public function testAvatarUpload()  
          {    
              Storage::fake('avatars');        
              $file = UploadedFile::fake()->image('avatar.jpg');        
              $response = $this->json('POST', '/avatar', [        
                  'avatar' => $file,      
             ]);       
           // 断言文件已经存储 . . .       
           Storage::disk('avatars')->assertExists($file->hashName());      
          // 断言文件不存在 . . .        
          Storage::disk('avatars')->assertMissing('missing.jpg');   
       }
 }

Virtuelle Dateivorbereitung

In Verwendung fake Wenn Sie eine Datei mit dieser Methode erstellen, können Sie die Breite, Höhe und Größe des Bildes angeben, um die Testregeln besser zu überprüfen:

UploadedFile::fake()->image('avatar.jpg', $width, $height)->size(100);

Zusätzlich zum Erstellen von Bildern können Sie auch create verwenden Methoden zum Erstellen anderer Dateitypen:

UploadedFile::fake()->create('document.pdf', $sizeInKilobytes);

Verfügbare Behauptungen

Response Assertion

Laravel bietet eine Vielzahl gängiger Assertionsmethoden für PHPUnit-Tests. Verfügbar unter json, get, post, put und delete Greifen Sie in der Testmethode auf diese Behauptungen zu:

assertCookie

Bestätigt, dass die Antwort das Gegebene enthält Cookie:

$response->assertCookie($cookieName, $value = null);

assertCookieExpired

Stellen Sie sicher, dass die Antwort das angegebene Cookie enthält und es ist abgelaufen:

$response->assertCookieExpired($cookieName);

assertCookieNotExpired

Stellen Sie sicher, dass das angegebene Cookie in der Antwort enthalten war und es ist nicht abgelaufen:

$response->assertCookieNotExpired($cookieName);

assertCookieMissing

Bestätigt, dass die Antwort das Gegebene nicht enthält Cookie:

$response->assertCookieMissing($cookieName);

assertDontSee

Stellen Sie sicher, dass die angegebene Zeichenfolge nicht in der Antwort enthalten ist:

$response->assertDontSee($value);

as sertDontSeeText

Bestätigt, dass die angegebene Zeichenfolge nicht im Antworttext enthalten ist:

$response->assertDontSeeText($value);

assertExactJson

$response->assertExactJson(array $data);

$response->assertForbidden();

$response->assertHeader($headerName, $value = null);

$response->assertHeaderMissing($headerName);

$response->assertJson(array $data);

$response->assertJsonCount($count, $key = null);

$response->assertJsonFragment(array $data);

$response->assertJsonMissing(array $data);

$response->assertJsonMissingExact(array $data);

$response->assertJsonMissingValidationErrors($keys);

$response->assertJsonStructure(array $structure);

$response->assertJsonValidationErrors($keys);

$response->assertLocation($uri);

$response->assertNotFound();

$response->assertOk();

$response->assertPlainCookie($cookieName, $value = null);

$response->assertRedirect($uri);

$response->assertSee($value);

$response->assertSeeInOrder(array $values);

$response->assertSeeText($value);

$response->assertSeeTextInOrder(array $values);

$response->assertSessionHas($key, $value = null);

$response->assertSessionHasAll(array $data);

$response->assertSessionHasErrors(array $keys, $format = null, $errorBag = 'default');

$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);

$response->assertSessionHasNoErrors();

$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');

$response->assertSessionMissing($key);

$response->assertStatus($code);

$response->assertSuccessful();

$response->assertViewHas($key, $value = null);

$response->assertViewHasAll(array $data);

$response->assertViewIs($value);

$response->assertViewMissing($key);