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/installerDen 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-nameDen här koden startar ett nytt Laravel-projekt och installerar sedan alla beroenden:
Ett annat enklare sätt att installera Laravel är att använda Composer direkt.
composer create-project laravel/laravel app-nameDu 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 serveDen 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:
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:
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 CommentDen 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:
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_tableObservera: 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 migrateDet här kommandot kör alla migreringar i database/migrations eftersom det är den första migreringen sedan appen skapades:
Följande bild visar alla migrerings-filer som du körde. Var och en representerar en tabell i databasen:
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.phpDenna 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:
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.phpDen 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:
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=CommentSeederDen här koden kör seeder-filen och genererar 50 rader med falska data i databasen.
Databasen bör därefter ha 50 rader med falska data som du kan använda för att testa applikationens funktioner:
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:
Kör testet
När du har lagt till egenskapen RefreshDatabase i testfilen kör du testet med Artisan:
php artisan testDen här koden kör alla tester i appen och uppdaterar databasen efter testerna, vilket visas i bilden nedan:
Kontrollera nu databasen för att se den tomma tabellen med kommentarer:
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 ä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.
Lämna ett svar