Sådan genereres og bruges falske records med Laravel Model Factories

Testning er afgørende for webudvikling. Laravel Model factories definerer databaseposter på en forudsigelig og let replikerbar måde, så dine app-tests er konsistente og kontrollerede. Model factories definerer et sæt standardattributter for hver af dine Eloquent-modeller.

Hvis du f.eks. laver en blogging-app, der giver forfattere og moderatorer mulighed for at godkende kommentarer, før de går live, skal du teste, om funktionen fungerer korrekt, før du udruller den til dine brugere. Alt dette kræver testdata.

For at teste den blogging-app, der er beskrevet ovenfor, har du brug for kommentardata til at efterligne og teste din applikations funktionalitet. Laravel giver dig mulighed for at gøre det uden at få kommentarer fra faktiske brugere ved at bruge Laravel-factories og Faker til at generere falske data.

Denne artikel forklarer, hvordan du får kommentardata uden kommentarer fra rigtige brugere.

Forudsætninger

For at gennemføre denne vejledning skal du være bekendt med følgende:

• XAMPP
• Composer

XAMPP er en gratis og let at installere Apache-distribution, der indeholder PHP, Perl og MariaDB – en MySQL-database. Denne vejledning bruger den nyeste version, 8.1.10, som installerer PHP 8.1.10. Læs denne artikel, hvis du installerer XAMPP til MacOS, eller denne vejledning til Linux. Denne vejledning bruger XAMPP på Windows.

Composer er et værktøj, der giver dig mulighed for at definere, installere og hente de pakker, som din webapp afhænger af i udvikling og produktion. Denne vejledning bruger version v2.4.4 af Composer, som kræver PHP version 7.2+. Du bruger Composer til at installere Laravel-installationsprogrammet til denne vejledning.

Du kan også downloade den komplette kode til projektet for at følge med.

Sådan opsættes projektet

I dette afsnit opretter du et Laravel-projekt og forbinder det til en database. Lad os tage et kig på alt det, det indebærer, og hvordan du gennemfører det.

Installer Laravel installationsprogrammet

For hurtigt at oprette et Laravel-projekt skal du installere Laravel-installationsprogrammet:

composer global require laravel/installer

Denne kode installerer Laravel-installationsprogrammet globalt på din maskine.

Opret et Laravel-projekt

Derefter skal du oprette et Laravel-projekt ved at køre følgende:

laravel new app-name

Denne kode starter et nyt Laravel-projekt og installerer alle afhængigheder:

En anden nemmere måde at installere Laravel på er at bruge Composer direkte.

composer create-project laravel/laravel app-name

Du behøver ikke at installere Laravel-installationsprogrammet, når du bruger ovenstående metode.

Start appen

Du kan nu ændre mappen til app-name og starte projektet ved hjælp af Laravels eget CLI-værktøj (command-line interface), Artisan:

php artisan serve

Denne kode starter projektet og forbinder det til localhost:8000 eller en anden tilgængelig port, hvis port 8000 er i brug. På localhost:8000 bør du se noget som dette:

Opret en database

For at forbinde din app til en database skal du oprette en ny database ved hjælp af XAMPP’s grafiske brugergrænseflade PHPMyAdmin. Gå til localhost/phpmyadmin, og klik på Ny på sidebaren:

Billedet ovenfor viser Create Database formularen med app_name som databasenavn.

Klik på Create (Opret) for at oprette en database.

Rediger .env-filen

Hvis du vil forbinde din app til en database, skal du redigere DB-delen af .env-filen:

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

Denne kode udfylder databaseoplysningerne med databasens navn, brugernavn, port, adgangskode og vært. Du er nu klar til at begynde at oprette fabrikker og modeller.

Bemærk: Udskift værdierne med dine databaseoplysninger. Hvis du også støder på fejlen “Access denied for user,”, skal du sætte værdierne for DB_USERNAME og DB_PASSWORD i dobbelte anførselstegn.

Sådan genererer du falske data

Når du har oprettet appen og tilsluttet den til databasen, kan du nu oprette de nødvendige filer til at generere falske data i databasen.

Opret kommentarmodellen

Opret modelfilen til at interagere med databasetabellerne. Du kan oprette en model ved at bruge Artisan:

php artisan make:model Comment

Denne kode opretter en Comment.php-fil i mappen app/Models med noget boilerplate-kode. Tilføj følgende kode under linjen use HasFactory;:

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

Denne kode indeholder en liste over de felter, du ønsker at tillade massetildelinger, fordi Laravel som standard beskytter din database mod massetildelinger. Comment-modelfilen skal nu se således ud:

Oprettelse af migrationsfilen

Når du har oprettet modelfilen og erklæret arrayet $fillable, skal du oprette migrationsfilen ved hjælp af nedenstående kommando:

php artisan make:migration create_comments_table

Bemærk: Navngivningskonventionen for oprettelse af migreringer i Laravel er normalt snake_case, også kendt som underscore_case. Det første ord er handlingen, det andet ord er et flertal af modellen, og det sidste ord er den funktion, der bliver oprettet inde i projektet. Det betyder, at du skriver create_books_table, når du opretter en migration for en Book-model.

Denne kode opretter en fil med navnet yyyy_mm_dd_hhmmss_create_comments_table inde i mappen database/migrations.

Derefter redigeres funktionen up inde i yyyyy_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();
    });
    }

Denne kode opretter et skema, der opretter en tabel med kolonnerne: id, name, email, body, approved, likes, og timestamps.

Kør overflytningerne

Oprettelse og redigering af migrationsfilen vil ikke gøre noget, før du kører dem ved hjælp af kommandolinjen. Hvis du kigger på databaseadministratoren, er den stadig tom.

Kør migreringerne ved hjælp af Artisan:

php artisan migrate

Denne kommando kører alle migreringer inde i database/migrations, fordi det er den første migrering siden oprettelsen af appen:

Følgende billede viser alle de migrationsfiler, du har kørt. Hver repræsenterer en tabel i databasen:

Opret filen CommentFactory

Opret en fabriksfil, der indeholder din definitionsfunktion. I denne demonstration opretter du en fabrik ved hjælp af Artisan:

php artisan make:factory CommentFactory.php

Denne kode opretter en CommentFactory.php-fil i mappen database/factories.

Definitionsfunktionen

Funktionen inde i CommentFactory definerer, hvordan Faker genererer falske data. Rediger den, så den ser således ud:

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)
     ];
    }

Denne kode fortæller Faker, at den skal generere følgende:

• Et navn
• En e-mail-adresse
• Et afsnit, der indeholder 45 sætninger
• En godkendt værdi, der kun kan være true eller false
• Et tilfældigt tal mellem 0 og 9999

Tilslut kommentarmodellen til CommentFactory

Forbind modellen Comment med CommentFactory ved at deklarere en beskyttet $model -variabel over definitionen:

protected $model = Comment::class;

Tilføj også use App\Models\Comment; til filafhængighederne. CommentFactory-filen bør nu se således ud:

Sådan seedes databasen

Seeding i programmering betyder at generere tilfældige falske data til en database til testformål.

Nu, hvor du har oprettet modellen, kørt migreringer og oprettet definitionen i CommentFactory, skal du køre seederen ved hjælp af DatabaseSeeder-filen.

Opret filen CommentSeeder

Opret en seeder-fil, der bruger factory til at generere dataene:

php artisan make:seeder CommentSeeder.php

Denne kode opretter en CommentSeeder.php-fil inde i mappen database/seeders.

Rediger Run-funktionen

Forbind kommentarmodellen med CommentSeeder. Tilføj følgende kode inde i run-funktionen:

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

Denne kode fortæller CommentSeeder, at den skal bruge Comment-modellen og CommentFactory’s definitionsfunktion til at generere 50 kommentarer i databasen. Tilføj også use App\Models\Comment; til filafhængighederne. CommentSeeder-filen skal nu se således ud:

Bemærk: Du kan konfigurere Faker til at oprette lokale data. Du kan f.eks. indstille den til at generere italienske navne i stedet for tilfældige navne ved at indstille faker_locale i filen app/config.php til it_IT. Du kan læse mere om Faker Locales i denne vejledning.

Kør Seeder’en

Dernæst skal du køre seeder-filen med Artisan:

php artisan db:seed --class=CommentSeeder

Denne kode kører seeder-filen og genererer 50 rækker med falske data i databasen.

Databasen bør nu have 50 rækker falske data, som du kan bruge til at teste din applikations funktioner:

Sådan nulstiller du databasen

Når du bruger de genererede data til test, skal du nulstille databasen, hver gang du kører en test. Lad os antage, at du vil teste funktionen til at skifte mellem godkendte kommentarer. Opdater databasen efter hver test for at sikre, at de tidligere genererede data ikke forstyrrer fremtidige tests.

Brug RefreshDatabase

Opdater databasen ved hjælp af egenskaben RefreshDatabase i testfilen.

Naviger til ExampleTest.php i mappen tests/Feature til kommentaren use Illuminate\Foundation\Testing\RefreshDatabase; og tilføj følgende kodelinje over funktionen test_the_application_returns_a_successful_response:

use RefreshDatabase;

Filen ExampleTest.php bør nu se således ud:

Kør testen

Når du har tilføjet egenskaben RefreshDatabase til testfilen, skal du køre testen med Artisan:

php artisan test

Denne kode kører alle testene i appen og opdaterer databasen efter testene, som vist i billedet nedenfor:

Tjek nu databasen for at se den tomme kommentartabel:

Oversigt

I denne artikel blev det beskrevet, hvordan man opretter et Laravel-projekt, forbinder det til en database og opretter og konfigurerer modeller, migrations-, fabriks- og seeder-filer til at generere tilfældige data til databasen. Den behandlede også, hvordan man nulstiller databasen efter at have kørt test.

Du har nu set, hvordan Laravel Factories og Faker gør det nemt at generere en hvilken som helst mængde testdata på få minutter til at teste en applikation eller endda som en placeholder – med minimal konfiguration.

Når din Laravel-app er klar til at blive implementeret, kan du gøre det på Kinstas Applikation Hosting-tjenester hurtigt og effektivt.

Steve Bonisteel Kinsta

"Steve Bonisteel er en teknisk redaktør hos Kinsta, der begyndte sin forfatterkarriere som journalist på en avis, der jagtede ambulancer og brandbiler. Han har dækket internetrelateret teknologi siden slutningen af 1990'erne."