Cara Membuat Dummy Data dengan Seeder dan Faker di Laravel

بسم الله الرحمن الرحيم

Cara Membuat Dummy Data dengan Seeder dan Faker di Laravel

Saat mengembangkan aplikasi Laravel, kita sering membutuhkan banyak data untuk menguji halaman tabel, pagination, pencarian, filter, API, dashboard, atau fitur lainnya.

Memasukkan puluhan bahkan ratusan data secara manual tentu tidak efisien.

Laravel menyediakan database seeder, sedangkan data dummy dapat dibuat menggunakan Faker.

Pada tutorial ini kita akan membuat data dummy employees dengan alur:

Membuat migration tabel employees.
Membuat model Employee.
Membuat database seeder.
Menggunakan Faker untuk menghasilkan data dummy.
Menjalankan seeder dengan Artisan.
Memeriksa data yang berhasil dibuat.

Artikel ini merupakan pembaruan dari tutorial yang pertama kali saya tulis ketika masih menggunakan struktur Laravel versi lama. Contoh di bawah diperbarui agar lebih mudah diterapkan pada Laravel modern.

Apa Itu Seeder di Laravel?

Seeder adalah fitur Laravel untuk memasukkan data ke database melalui kode.

Seeder sangat berguna ketika kita membutuhkan data awal atau data pengujian selama proses development.

Misalnya kita sedang membuat halaman daftar karyawan.

Daripada memasukkan 50 karyawan satu per satu melalui phpMyAdmin atau form aplikasi, kita dapat meminta Laravel membuat data tersebut secara otomatis.

Perintah Artisan yang umum digunakan adalah:

php artisan db:seed

Kita juga dapat menjalankan seeder tertentu:

php artisan db:seed --class=EmployeeSeeder

Apa Itu Faker?

Faker adalah library yang dapat menghasilkan data palsu atau dummy secara otomatis.

Contohnya:

Nama      : Ahmad Hidayat
Email     : ahmad@example.com
Pekerjaan : Software Developer

Dengan Faker, kita tidak perlu menulis data pengujian satu per satu.

Kita dapat menghasilkan puluhan atau ratusan data dengan kombinasi Seeder dan Faker.

1. Membuat Migration Employees

Pertama kita buat migration untuk tabel employees.

Jalankan:

php artisan make:migration create_employees_table

Laravel akan membuat file migration di:

database/migrations/

Buka file tersebut kemudian buat struktur tabel seperti berikut:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('employees', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->string('jobdesk')->nullable();
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('employees');
    }
};

Kemudian jalankan migration:

php artisan migrate

Sekarang tabel:

employees

akan tersedia di database.

Strukturnya kurang lebih:

id
name
email
jobdesk
created_at
updated_at

2. Membuat Model Employee

Selanjutnya buat model:

php artisan make:model Employee

Model akan dibuat pada:

app/Models/Employee.php

Contohnya:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Employee extends Model
{
    protected $fillable = [
        'name',
        'email',
        'jobdesk',
    ];
}

Model Employee akan kita gunakan untuk memasukkan data dari seeder ke tabel employees.

3. Membuat Seeder Laravel

Sekarang buat seeder:

php artisan make:seeder EmployeeSeeder

Pada Laravel modern, file tersebut akan dibuat di:

database/seeders/EmployeeSeeder.php

Struktur awalnya kurang lebih:

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class EmployeeSeeder extends Seeder
{
    public function run(): void
    {
        //
    }
}

4. Insert Data Menggunakan Seeder

Sebelum menggunakan Faker, kita dapat mencoba memasukkan satu data terlebih dahulu.

Ubah EmployeeSeeder.php menjadi:

<?php

namespace Database\Seeders;

use App\Models\Employee;
use Illuminate\Database\Seeder;

class EmployeeSeeder extends Seeder
{
    public function run(): void
    {
        Employee::create([
            'name' => 'Puji Ermanto',
            'email' => 'pujiermanto@example.com',
            'jobdesk' => 'Web Developer',
        ]);
    }
}

Kemudian jalankan:

php artisan db:seed --class=EmployeeSeeder

Jika berhasil, Laravel akan menjalankan proses database seeding.

Sekarang periksa tabel:

employees

Data yang kita masukkan melalui seeder seharusnya sudah tersedia.

5. Membuat Dummy Data Menggunakan Faker

Satu data tentu belum cukup untuk menguji aplikasi.

Sekarang kita gunakan Faker.

Ubah method run() menjadi:

public function run(): void
{
    $faker = fake('id_ID');

    for ($i = 0; $i < 20; $i++) {
        Employee::create([
            'name' => $faker->name(),
            'email' => $faker->unique()->safeEmail(),
            'jobdesk' => $faker->jobTitle(),
        ]);
    }
}

Jangan lupa import model:

use App\Models\Employee;

Sehingga file lengkapnya menjadi:

<?php

namespace Database\Seeders;

use App\Models\Employee;
use Illuminate\Database\Seeder;

class EmployeeSeeder extends Seeder
{
    public function run(): void
    {
        $faker = fake('id_ID');

        for ($i = 0; $i < 20; $i++) {
            Employee::create([
                'name' => $faker->name(),
                'email' => $faker->unique()->safeEmail(),
                'jobdesk' => $faker->jobTitle(),
            ]);
        }
    }
}

Kemudian jalankan:

php artisan db:seed --class=EmployeeSeeder

Laravel akan membuat 20 employee dengan data yang berbeda-beda.

Contohnya:

+----+----------------------+-----------------------------+----------------------+
| id | name                 | email                       | jobdesk              |
+----+----------------------+-----------------------------+----------------------+
| 1  | Ahmad Hidayat        | ahmad@example.com           | Software Developer   |
| 2  | Budi Santoso         | budi@example.com            | System Administrator |
| 3  | Rizky Pratama        | rizky@example.com           | Web Developer        |
+----+----------------------+-----------------------------+----------------------+

Data tersebut hanya contoh. Faker akan menghasilkan data yang berbeda ketika seeder dijalankan.

6. Menjalankan Seeder dari DatabaseSeeder

Selain menjalankan EmployeeSeeder secara langsung, kita dapat mendaftarkannya di:

database/seeders/DatabaseSeeder.php

Contohnya:

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            EmployeeSeeder::class,
        ]);
    }
}

Sekarang cukup jalankan:

php artisan db:seed

Laravel akan menjalankan seeder yang sudah didaftarkan.

7. Menggunakan migrate:fresh –seed

Saat development, ada satu perintah yang sangat praktis:

php artisan migrate:fresh --seed

Perintah tersebut akan:

hapus seluruh tabel
        ↓
jalankan migration
        ↓
buat tabel kembali
        ↓
jalankan database seeder

Ini sangat membantu ketika kita ingin mengembalikan database development ke kondisi awal.

Perhatian: migrate:fresh menghapus seluruh tabel pada database yang digunakan. Jangan menjalankannya sembarangan pada database production.

8. Seeder dengan Query Builder

Selain Eloquent, data juga dapat dimasukkan menggunakan Query Builder.

Contohnya:

use Illuminate\Support\Facades\DB;

public function run(): void
{
    $faker = fake('id_ID');

    for ($i = 0; $i < 20; $i++) {
        DB::table('employees')->insert([
            'name' => $faker->name(),
            'email' => $faker->unique()->safeEmail(),
            'jobdesk' => $faker->jobTitle(),
            'created_at' => now(),
            'updated_at' => now(),
        ]);
    }
}

Untuk kasus sederhana, baik Eloquent maupun Query Builder dapat digunakan.

9. Cara yang Lebih Rapi: Menggunakan Factory

Untuk aplikasi Laravel yang lebih besar, saya lebih menyarankan menggunakan Model Factory.

Buat factory:

php artisan make:factory EmployeeFactory --model=Employee

Kemudian isi factory:

<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

class EmployeeFactory extends Factory
{
    public function definition(): array
    {
        return [
            'name' => fake('id_ID')->name(),
            'email' => fake()->unique()->safeEmail(),
            'jobdesk' => fake()->jobTitle(),
        ];
    }
}

Model Employee menggunakan trait:

use Illuminate\Database\Eloquent\Factories\HasFactory;

class Employee extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'email',
        'jobdesk',
    ];
}

Kemudian pada seeder:

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

Dengan cara ini kita dapat membuat:

employee
employee
000 employee

tanpa menulis looping manual.

Seeder vs Factory di Laravel

Keduanya berhubungan dengan pembuatan data, tetapi mempunyai tanggung jawab yang sedikit berbeda.

Seeder mengatur data apa yang perlu dimasukkan ke database.

Contohnya:

$this->call([
    EmployeeSeeder::class,
]);

Sedangkan Factory mendefinisikan bagaimana sebuah model dummy dibuat.

Contohnya:

Employee::factory()
    ->count(100)
    ->create();

Karena itu, keduanya sering digunakan bersama.

Alurnya menjadi:

DatabaseSeeder
      ↓
EmployeeSeeder
      ↓
EmployeeFactory
      ↓
Faker
      ↓
employees table

Contoh DatabaseSeeder untuk Banyak Data

Misalnya aplikasi mempunyai employee dan user.

Kita dapat membuat:

public function run(): void
{
    User::factory()
        ->count(10)
        ->create();

    Employee::factory()
        ->count(50)
        ->create();
}

Kemudian:

php artisan migrate:fresh --seed

Database development langsung mempunyai data yang cukup untuk menguji aplikasi.

Error yang Sering Terjadi Saat Menggunakan Seeder

Class Seeder Tidak Ditemukan

Pastikan namespace-nya:

namespace Database\Seeders;

dan jalankan:

composer dump-autoload

kemudian:

php artisan db:seed

Duplicate Entry pada Email

Jika kolom email menggunakan unique index, Faker juga sebaiknya menggunakan:

$faker->unique()->safeEmail()

atau:

fake()->unique()->safeEmail()

Data Seeder Terus Bertambah

Jika:

php artisan db:seed

dijalankan berkali-kali, seeder dapat memasukkan data tambahan setiap kali dijalankan.

Untuk database development yang boleh dihapus, kita dapat menggunakan:

php artisan migrate:fresh --seed

Tetapi sekali lagi, jangan gunakan migrate:fresh pada database production yang berisi data penting.

Kesimpulan

Laravel Seeder dan Faker sangat membantu ketika kita membutuhkan data pengujian selama proses development.

Dengan kombinasi:

Migration
   ↓
Model
   ↓
Factory
   ↓
Faker
   ↓
Seeder
   ↓
Database

kita dapat membuat puluhan bahkan ratusan data dummy hanya dengan beberapa baris kode.

Perintah yang paling sering digunakan antara lain:

php artisan make:seeder EmployeeSeeder
php artisan db:seed
php artisan db:seed --class=EmployeeSeeder
php artisan migrate:fresh --seed

Untuk project sederhana kita dapat menggunakan Faker langsung di dalam seeder.

Sedangkan untuk project yang lebih besar, penggunaan Factory + Seeder biasanya menghasilkan struktur yang lebih mudah dipelihara.

Semoga tutorial ini membantu memahami cara membuat dummy data menggunakan Seeder dan Faker di Laravel.

Artikel Laravel Lainnya

Kalau sedang belajar Laravel, beberapa pembahasan lain di blog ini juga dapat digunakan sebagai lanjutan.

Pelajari migration dan pengelolaan database Laravel.
Pelajari Eloquent untuk mengelola data menggunakan model.
Pelajari pagination ketika jumlah dummy data sudah cukup banyak.
Pelajari pembuatan API Laravel untuk menampilkan data tersebut.

Saya juga sedang menulis seri implementasi Laravel dan MikroTik berdasarkan proses pengembangan aplikasi yang saya kerjakan, mulai dari koneksi RouterOS API hingga provisioning dan monitoring PPPoE.

Artikel ini pertama kali ditulis menggunakan struktur Laravel versi lama dan kemudian diperbarui agar contoh Seeder, Faker, Factory, namespace, dan struktur direktorinya lebih relevan untuk Laravel modern.

Cara Membuat Dummy Data dengan Seeder dan Faker di Laravel