Testning är viktigt för webbutveckling. Laravel Model factories definierar databas-poster på ett förutsägbart och lätt replikerbart sätt. Som ett resultat blir dina app-tester konsekventa och kontrollerade. Model Factory definierar en uppsättning standard-attribut för var och en av dina Eloquent-modeller.

Du kanske exempelvis gör en blogg-app som låter författare och moderatorer godkänna kommentarer innan de går live? Då måste du testa om funktionen fungerar som den ska innan du distribuerar den till dina användare. Allt detta kräver testdata.

För att testa den blogg-app som beskrivs ovan behöver du kommentars-data för att imitera och testa funktionaliteten i din applikation. Med Laravel kan du göra detta utan att få kommentarer från faktiska användare. Du kan helt enkelt nyttja Laravel Factory och Faker för att generera falska data.

Den här artikeln förklarar hur du får kommentars-data utan kommentarer från riktiga användare.

Förutsättningar

För att kunna slutföra den här handledningen måste du känna till följande:

  • XAMPP
  • Composer

XAMPP är en kostnadsfri och lättinstallerad Apache-distribuering som innehåller PHP, Perl och MariaDB – en MySQL-databas. I den här handledningen används den senaste versionen, 8.1.10, som installerar PHP 8.1.10. Läs den här artikeln om du installerar XAMPP för MacOS eller den här guiden för Linux. I den här handledningen används XAMPP på Windows.

Composer är ett verktyg som gör att du kan definiera, installera och hämta de paket som din webb–applikation är beroende av i utveckling och produktion. Den här handledningen använder version v2.4.4 av Composer, som kräver PHP version 7.2+. Du använder Composer för att installera Laravel-installationsprogrammet för den här handledningen.

Du kan dessutom ladda ner hela koden för projektet för att följa med.

Så här konfigurerar du projektet

I det här avsnittet skapar du ett Laravel-projekt och ansluter detta till en databas. Låt oss ta en titt på allt som det innebär och hur du åstadkommer det.

Installera Laravel Installer

För att snabbt skapa ett Laravel-projekt installerar du Laravel Installer:

composer global require laravel/installer

Den här koden installerar Laravel-installationsprogrammet globalt på din maskin.

Skapa ett Laravel-projekt

Skapa sedan ett Laravel-projekt genom att köra följande:

laravel new app-name

Den här koden startar ett nytt Laravel-projekt och installerar sedan alla beroenden:

Skapa Laravel-projektet
Skapa Laravel-projektet

Ett annat enklare sätt att installera Laravel är att använda Composer direkt.

composer create-project laravel/laravel app-name

Du behöver inte installera Laravel-installationsprogrammet när du använder metoden ovan.

Starta appen

Du kan nu ändra katalogen till app-name och starta projektet med hjälp av Laravel’s eget verktyg för kommandoradsgränssnitt (CLI), Artisan:

php artisan serve

Den här koden startar projektet och ansluter det därefter till localhost:8000 eller någon annan tillgänglig port om port 8000 används. På localhost:8000 bör du se något som liknar det här:

Laravel
Laravel

Skapa en databas

För att ansluta din app till en databas måste du skapa en ny databas med hjälp av XAMPP’s grafiska användargränssnitt PHPMyAdmin. Gå till localhost/phpmyadmin och klicka på Ny i sidofältet:

Skapa databas-formulär
Skapa databas-formulär

Bilden ovan visar formuläret Skapa databas med app_name som databasnamn.

Klicka på Skapa för att skapa en databas.

Redigera .env-filen

För att ansluta din app till en databas måste du sedan redigera DB-delen av .env-filen:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=app_name
DB_USERNAME=root
DB_PASSWORD=

Den här koden fyller i databasens autentiserings-uppgifter med ditt databasnamn, användarnamn, port, lösenord och din host. Du är nu redo att börja skapa factories och models.

Obs: Ersätt värdena med dina databas-referenser. Om du stöter på felet Åtkomst nekad för användaren, sätt värdena för DB_USERNAME och DB_PASSWORD inom dubbla citattecken.

Hur man genererar falska data

När du har skapat appen och anslutit den till databasen kan du nu skapa de nödvändiga filerna för att generera falska data i databasen.

Skapa kommentars-modellen

Skapa modell-filen för att interagera med databas-tabellerna. För att skapa en modell använder du Artisan:

php artisan make:model Comment

Den här koden skapar en Comment.php-fil i mappen app/Modeller med en del standard-kod. Lägg till följande kod under raden use HasFactory;:

 protected $fillable = [
      'name',
      'email',
      'body',
      'approved',
      'likes'
    ];

Den här koden listar de fält som du vill tillåta mass-tilldelningar för. Laravel skyddar nämligen din databas från mass-tilldelningar som standard. Modellfilen Comment ska nu se ut så här:

Kommentars-modellfilen ser nu ut på följande sätt
Kommentars-modellfilen ser nu ut på följande sätt

Skapa migrerings-filen

När du har skapat modell-filen och deklarerat matrisen $fillable måste du skapa migrerings-filen med hjälp av kommandot nedan:

php artisan make:migration create_comments_table

Observera: Namnkonventionen för att skapa migreringar i Laravel är vanligtvis följande snake_case, även känd som underscore_case. Det första ordet är åtgärden, det andra ordet är en plural av modellen och det sista ordet är funktionen som skapas i projektet. Detta innebär exempelvis att du skriver create_books_table när du skapar en migrering för en Book-modell.

Den här koden skapar en fil som heter yyyy_mm_dd_hhmmss_create_comments_table i mappen database/migrations.

Därefter redigerar du funktionen up inuti yyyy_mm_dd_hhmmss_create_comments_table:

public function up()
    {
  Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email');
    $table->longText('body');
    $table->boolean('approved');
    $table->integer('likes')->default(0);
    $table->timestamps();
    });
    }

Denna kod genererar ett schema som skapar en tabell med kolumnerna: id, name, email, body, approved, likes och timestamps.

Kör migreringen

Att skapa och redigera migrerings-filen gör ingenting förrän du kör dem med hjälp av kommandoraden. Om du tittar på databashanteraren så är den fortfarande tom.

Kör migreringen med Artisan:

php artisan migrate

Det här kommandot kör alla migreringar i database/migrations eftersom det är den första migreringen sedan appen skapades:

Framgångsrika migreringar
Framgångsrika migreringar

Följande bild visar alla migrerings-filer som du körde. Var och en representerar en tabell i databasen:

Databas efter migreringar
Databas efter migreringar

Skapa filen CommentFactory

Skapa en factory-fil som innehåller din definitions-funktion. I den här demonstrationen skapar du en factory med hjälp av Artisan:

php artisan make:factory CommentFactory.php

Denna kod skapar en CommentFactory.php-fil i mappen database/factories.

Definitions-funktionen

Funktionen inuti CommentFactory definierar hur Faker genererar falska data. Redigera den så att den ser ut så här:

public function definition()
  {
   return [
     'name' => $this->faker->name(),
     'email' => $this->faker->email(),
     'body' => $this->faker->sentence(45),
     'approved' => $this->faker->boolean(),
     'likes' => $this->faker->randomNumber(5)
     ];
    }

Koden säger åt Faker att generera följande:

  • Ett namn
  • En e-postadress
  • Ett stycke som innehåller 45 meningar
  • Ett godkänt värde som bara kan vara sant eller falskt
  • Ett slumpmässigt tal mellan 0 och 9999

Anslut kommentars-modellen till CommentFactory

Koppla modellen Comment till CommentFactory genom att deklarera en skyddad $model-variabel ovanför definitionen:

protected $model = Comment::class;

Lägg dessutom till use App\Models\Comment; i filberoendena. CommentFactory-filen bör sedan se ut så här:

Filen för CommentFactory
Filen för CommentFactory

Så här gör du för att skapa en databas

Seeding i programmering innebär generering av slumpmässiga falska data för en databas i test-syfte.

Nu när du har skapat modellen, kört migreringar och skapat definitionen i CommentFactory kör du seedern med hjälp av filen DatabaseSeeder.

Skapa filen CommentSeeder

Skapa en seeder-fil som använder factory för att generera data:

php artisan make:seeder CommentSeeder.php

Den här koden skapar sedan en CommentSeeder.php-fil i mappen database/seeders.

Redigera körfunktionen

Anslut kommentars-modellen till CommentSeeder. Lägg till följande kod i kör-funktionen:

Comment::factory()->count(50)->create();

Koden talar om för CommentSeeder att den ska använda Comment-modellen och CommentFactorys definitions-funktion för att generera 50 kommentarer i databasen. Lägg dessutom till use App\Models\Comment; till filberoendena. CommentSeeder-filen bör sedan se ut så här:

CommentSeeder-filen ser nu ut på följande sätt
CommentSeeder-filen ser nu ut på följande sätt

Obs: Du kan konfigurera Faker så att den skapar lokala data. Du kan exempelvis ställa in den så att den genererar italienska namn i stället för slumpmässiga namn genom att ställa in faker_locale i filen app/config.php till it_IT. Du kan läsa mer om Faker Locales i den här guiden.

Kör Seeder

Kör sedan seeder-filen med Artisan:

php artisan db:seed --class=CommentSeeder

Den här koden kör seeder-filen och genererar 50 rader med falska data i databasen.

Lyckad databas-seeding
Lyckad databas-seeding

Databasen bör därefter ha 50 rader med falska data som du kan använda för att testa applikationens funktioner:

50 datarader i databasen
50 datarader i databasen

Så här återställer du databasen

När du använder genererade data för testning ska du återställa databasen varje gång som du kör ett test. Anta att du vill testa funktionen för att växla mellan godkända kommentarer. Uppdatera databasen efter varje test för att se till att tidigare genererade data inte stör framtida tester.

Använd RefreshDatabase

Uppdatera databasen med hjälp av egenskapen RefreshDatabase i testfilen.

Navigera till ExampleTest.php i mappen tests/Feature till kommentaren use Illuminate\Foundation\Testing\RefreshDatabase;. Lägg sedan till följande kod-rad ovanför funktionen test_the_application_returns_a_successful_response:

use RefreshDatabase;

Filen ExampleTest.php bör därefter se ut så här:

ExampleTest-filen ser nu ut på följande sätt
ExampleTest-filen ser nu ut på följande sätt

Kör testet

När du har lagt till egenskapen RefreshDatabase i testfilen kör du testet med Artisan:

php artisan test

Den här koden kör alla tester i appen och uppdaterar databasen efter testerna, vilket visas i bilden nedan:

Ett lyckat Artisan-test
Ett lyckat Artisan-test

Kontrollera nu databasen för att se den tomma tabellen med kommentarer:

Tomma kommentarer i databasen
Tomma kommentarer i databasen

Sammanfattning

Den här artikeln handlade om hur man skapar ett Laravel-projekt och ansluter det till en databas. Artikeln visar dessutom hur du skapar och konfigurerar modeller, migreringar-, factory- och seeder-filer för att generera slumpmässiga data till databasen. Den diskuterade även hur man återställer databasen efter att ha kört tester.

Du har nu sett hur Laravel Factories och Faker gör det enkelt att generera valfri mängd testdata på några minuter. Allt för att testa en applikation. Det kan till och med fungera som en platshållare – med minimal konfiguration.

När din Laravel-app är redo att distribueras kan du göra detta snabbt och effektivt på Kinsta’s tjänster för Applikationshosting.

Steve Bonisteel Kinsta

Steve Bonisteel är en teknisk redaktör på Kinsta som började sin författarkarriär som printjournalist och jagade ambulanser och brandbilar. Han har bevakat internetrelaterad teknik sedan slutet av 1990-talet.