
Menggunakan Github Action untuk Test dan Deploy Ke Cloud Server Digitalocean atau Lainnya. berikut akan saya share ketika menggunakan atau memanfaatkan github action untuk test, pint dan `Deploy` Laravel ke Server secara otomatis.

### Buat Workflow Github file

Langkah pertama buat file workflow github dengan nama `deploy.yaml` di folder `.github/workflows` jika belum ada foldernya silahkan buat sehingga nanti akan seperti ini `.github/workflows/deploy.yaml` dan isinya seperti ini :

```yaml
name: Laravel Github Action
on:
  pull_request:
    branches:
      - master
jobs:
  lint:
    name: Run Pint Laravel On Production
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 2
      - name: Laravel Pint Action
        uses: aglipanci/laravel-pint-action@0.1.0
        with:
          preset: laravel
```

Penjelasan Proses diatas adalah Github akan melakukan **Pint** untuk merapihkan kode atau `linter` kode kita. disini saya menggunakan github action [Laravel Pint Action](https://github.com/aglipanci/laravel-pint-action) package.

### Tambahkan Proses Pest Action

Untuk Selanjutnya kita buat proses Github action untuk mengetest kode dengan `menambahkan baris` seperti berikut :

```yaml
tests:
  name: Run Test with Pest on Production
  needs: lint
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v3
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.2'
        extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite, bcmath, soap, intl, gd, exif, iconv
        coverage: none
    - name: Run Composer
      run: composer install -n --prefer-dist
    - name: Prepare Laravel Application
      run: |
        cp .env.ci .env
        php artisan key:generate
    - name: Run Pest
      run: php artisan test
```

Proses diatas adalah untuk mengetest menggunakan [Pest](https://pestphp.com/) package untuk memudahkan kita dalam melakukan Test Unit atau test lainnya. Jika anda belum tau cara menggunakan pest silahkan kunjungi tutorial saya [Laravel Pest Untuk Test Api]
(https://imansugirman.com/laravel-pest-untuk-test-api) dan jangan lupa buat file `.env.ci` untuk environtment yang akan kita gunakan dan sesuaikan.

### Deploy Github Action

```yaml
deploy:
  name: Run Test with Pest on Production
  needs: lint
  runs-on: ubuntu-latest
  steps:
    - name: Checkout code
      uses: actions/checkout@v2
    - name: Cache dependencies
      uses: actions/cache@v1
      with:
        path: ~/.composer/cache/files
        key: dependencies-composer-${{ hashFiles('composer.json') }}
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: 7.3
        extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite,pdo_sqlite
        coverage: none
    - name: Install Composer dependencies
      run: composer install --prefer-dist --no-interaction --no-suggest
    - name: Install NPM dependencies
      run: npm install
    - name: Compile assets
      run: npm run production
    - name: Execute tests
      run: vendor/bin/phpunit --verbose
    - name: Deploy
      if: github.ref == 'refs/heads/master'
      run: curl ${{ secrets.ENVOYER_HOOK }}?sha=${{ github.sha }}
```

Proses diatas akan melakukan Proses untuk deploy ke server menggunakan Envoyer untuk mengetahui cara Deploy menggunakan Laravel Envoy bisa ikuti tutorial [Deploy Laravel Menggunakan Envoy](https://imansugirman.com/laravel-envoy-cara-deploy-laravel-otomatis-dengan-git-repositories)

Jika digabungkan kodenya maka akan menjadi begini :

```yaml
name: Laravel Github Action
on:
  pull_request:
    branches:
      - master
jobs:
  lint:
    name: Run Pint Laravel On Production
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 2
      - name: Laravel Pint Action
        uses: aglipanci/laravel-pint-action@0.1.0
        with:
          preset: laravel
tests:
  name: Run Test with Pest on Production
  needs: lint
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v3
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.2'
        extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite, bcmath, soap, intl, gd, exif, iconv
        coverage: none
    - name: Run Composer
      run: composer install -n --prefer-dist
    - name: Prepare Laravel Application
      run: |
        cp .env.ci .env
        php artisan key:generate
    - name: Run Pest
      run: php artisan test
deploy:
  name: Run Test with Pest on Production
  needs: lint
  runs-on: ubuntu-latest
  steps:
    - name: Checkout code
      uses: actions/checkout@v2
    - name: Cache dependencies
      uses: actions/cache@v1
      with:
        path: ~/.composer/cache/files
        key: dependencies-composer-${{ hashFiles('composer.json') }}
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: 7.3
        extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite,pdo_sqlite
        coverage: none
    - name: Install Composer dependencies
      run: composer install --prefer-dist --no-interaction --no-suggest
    - name: Install NPM dependencies
      run: npm install
    - name: Compile assets
      run: npm run production
    - name: Execute tests
      run: vendor/bin/phpunit --verbose
    - name: Deploy
      if: github.ref == 'refs/heads/master'
      run: curl ${{ secrets.ENVOYER_HOOK }}?sha=${{ github.sha }}
```

Dengan menggunakan Github Action maka anda akan dimudahkan dalam memanage dan maintenance kode di server, karna akan terstruktur dan lebih rapih lagi.

Demikian tutorial **Menggunakan Github Action untuk Test dan Deploy Ke Cloud Server Digitalocean atau Lainnya**


Menggunakan Github Action untuk Test dan Deploy Ke Cloud Server Digitalocean atau Lainnya. berikut akan saya share ketika menggunakan atau memanfaatkan github action untuk test

Laravel Test dan Deploy Menggunakan Github Action

Pest adalah framework untuk pengujian dengan fokus pada kesederhanaan terutama untuk framework Laravel. Agar Api yang kita bangun lebih percaya diri untuk di deploy karena sudah di test dengan pengujian menggunakan Pest Framework.

### Instalasi Pest di Laravel

Install Pest dengan Dependencies

```bash
composer require pestphp/pest --dev --with-all-dependencies
```

Initialisasi Pest menggunakan `--init`

```bash
./vendor/bin/pest --init
```

Tambahkan Package pest untuk Laravel

```bash
composer require pestphp/pest-plugin-laravel --dev
```

Jika anda membutuhkan `Faker` bisa juga diinstall dengan pest dengan cara menambahkan, namun ini adalah hanya alternative saja tidak begitu dibutuhkan nanti karna laravel menggunakan factory

```bash
composer require pestphp/pest-plugin-faker --dev
```

### Membuat Model dan Migration Terlebih Dahulu

Membuat model dan migration di laravel

```bash
php artisan make:model Product -m
```

dan akan terbuat 2 file yaitu Model dan Migration sekarang kita edit file Migration :

```php
Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->decimal('weight', 45)->nullable();
    $table->string('slug')->unique();
    $table->string('sku')->unique();
    $table->string('image')->nullable();
    $table->decimal('price', 45)->nullable();
    $table->decimal('discount', 45)->nullable();
    $table->timestamps();
});
```

Lalu sekarang kita edit model dari `Product` tersebut

```php
// App\Models\Product.php

class Product extends Model
{
    use HasFactory;

    protected $table = 'products';

    protected $fillable = [
        'name', 'weight', 'slug', 'sku', 'image', 'price', 'discount'
    ];

}
// Kode Selanjutnya
```

### Membuat Factory berdasarkan Model

Sebelum membuat test baiknya kita menggunakan factory untuk berinteraksi dengan database, dan masukan perintah :

```bash
php artisan make:factory ProductFactory --model=Product
```

dan Edit file `ProductFactory` berikut :

```php
public function definition(): array
{
    return [
        'name' => fake()->name(),
        'weight' => rand(1000, 10000),
        'slug' => Str::slug(fake()->name()),
        'sku' => Str::slug(fake()->unique()->name(2)),
        'price' => fake()->randomNumber(5, true),
        'discount' => rand(1, 20),
    ];
}
```

Dan sekarang bisa kita gunakan untuk membuat demo product dummy. Sekarang kita edit `phpunit.xml`

```xml
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
>
    <php>
        <env name="APP_ENV" value="testing"/>
        <env name="BCRYPT_ROUNDS" value="4"/>
        <env name="CACHE_DRIVER" value="array"/>
        
        <env name="DB_CONNECTION" value="sqlite"/>
        <env name="DB_DATABASE" value=":memory:"/>
        
        <env name="MAIL_MAILER" value="array"/>
        <env name="QUEUE_CONNECTION" value="sync"/>
        <env name="SESSION_DRIVER" value="array"/>
        <env name="TELESCOPE_ENABLED" value="false"/>
    </php>
</phpunit>
```

Tambahkan file `database.sqlite` di folder `database` dan saatnya kita buat `Controller` untuk interaksi API.

### Membuat ProductController

Untuk membuat interaksi API kita harus membuat Controller terlebih dahulu untuk berintegrasi dengan test yang akan kita buat :

```bash
php artisan make:controller ProductController
```

Lalu edit `ProductController`

```php
public function index(Request $request): JsonResponse
{
    try {
        // Controller Untuk Query Index

    } catch (Exception $ex) {
        // Jika Error
    }
}

public function store(Request $request): JsonResponse
{
    try {
        // Controller Untuk Membuat Data

    } catch (Exception $ex) {
        // Jika Error
    }
}

public function show($id): JsonResponse
{
    try {
        // Controller Untuk Menampilkan Data

    } catch (Exception $ex) {
        // Jika Error
    }
}


public function update(Request $request, $id): JsonResponse
{
    try {
        // Controller Untuk mengupdate Data Data

    } catch (Exception $ex) {
        // Jika Error
    }
}

public function delete(Request $request, $id): JsonResponse
{
    try {
        // Controller Untuk mengupdate Data Data

    } catch (Exception $ex) {
        // Jika Error
    }
}

```

Lalu atur Routenya untuk Api diatas :

```php
Route::get('products', [ProductController::class, 'index']);
Route::get('products/{id}', [ProductController::class, 'show']);
Route::post('products', [ProductController::class, 'store']);
Route::put('products/{id}', [ProductController::class, 'update']);
Route::delete('products/{id}', [ProductController::class, 'destroy']);
```

Lalu sekarang kita buat Testnya untuk Membuat Test :

### Saatnya Buat Pest Untuk Test

Saatnya kita buat Pest file dengan memasukan Perintah :

```php
php artisan make:test ProductTest --pest --unit
```

Lalu edit ProductTest.php seperti ini :

Ini adalah untuk mengetest Bahwa Route `/api/products` bisa digunakan untuk membuat produk

Expektasi kita response mengembalikan status 200 dan Expektasi di database `products` ada data seperti variable product

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class);

it('Can Create Product Data', function () {
    $product = Product::factory()->raw();
    $response = $this->postJson('/api/products', $product);
    $response->assertStatus(200);
    $this->assertDatabaseHas('products', $product);
});

```

Dibawah membuat test ketika kita menginput lebih dari 1 atau lebih tepatnya 10 data

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class); // Untuk Berinteraksi dengan Database

it('Can Create More Product with Count', function () {
    $product = Product::factory()->count(10)->create();
    $results = $this->getJson('/api/products');
    expect($results['data'])->toHaveCount(10);
});

```

Ketika Di Query maka akan mengeluarkan data seperti expektasi data yang kita buat dan status `200`:

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class); // Untuk Berinteraksi dengan Database

it('Can Fetch Product Data', function () {
    $product = Product::factory()->create();
    $response = $this->getJson("/api/products/{$post->id}");
    $data = [
        'data' => ['id' => $post->id, 'name' => $post->name, 'slug' => $post->slug],
    ];
    $response->assertStatus(200)->assertJson($data);
});

```

Expektasi Kita ketika salah id untuk menemukan produk berdasarkan ID :

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class); // Untuk Berinteraksi dengan Database

it('Cannot Fetch Product Because Wrong ID', function () {
    $product = Product::factory()->create();
    $wrongId = $product->id.'j3443';
    $response = $this->getJson("/api/products/{$wrongId}");
    $response->assertStatus(500);
});

```

Expektasi Kita ketika hanya memasukan nama produk saja tidak ada data lain :

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class); // Untuk Berinteraksi dengan Database

it('Validation Without Product', function () {
    $response = $this->postJson('/api/products', ['name' => 'Updated Woke']);
    $response->assertStatus(422);
});

```

Produk Bisa di update dengan data data demo :

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class); // Untuk Berinteraksi dengan Database

it('Can Update Product', function () {
    $product = Product::factory()->create();
    $updatedpost = ['name' => 'Wakanda', 'slug' => '2834932asd', 'sku' => '2834932asd'];
    $response = $this->putJson("/api/products/{$product->id}", $updatedpost);
    expect($response)->assertStatus(200);
    $this->assertDatabaseHas('products', $updatedpost);
});
```

Expextasi kita bisa menghapus produk

```php

use App\Models\Product;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(Tests\TestCase::class, RefreshDatabase::class); // Untuk Berinteraksi dengan Database

it('Can Delete Product', function () {
    $product = Product::factory()->create();
    $deleted = $this->deleteJson('/api/products/'.$product->id);
    expect($deleted)->assertStatus(200);
});
```

Lalu masukan perintah :

```bash
./vendor/bin/pest
```

atau bisa juga dengan memasukan perintah :

```bash
php artisan test
```

maka akan keluar seperti ini :

```bash
 PASS  Tests\Unit\ProductUnitTest
  ✓ it Can Create Product Data
  ✓ it Can Create More Product with Count
  ✓ it Can Fetch Product Data
  ✓ it Cannot Fetch Product Because Wrong ID
  ✓ it Validation Without Product
  ✓ it Can Update Product
  ✓ it Can Delete Product
```

Dan test berhasil selanjutnya akan saya share tutorial Github Pipeline untuk test Laravel Api kita.

Terimakasih Happy Coding....

Pest adalah kerangka pengujian dengan fokus pada kesederhanaan, cermat dirancang untuk membawa kembali kegembiraan pengujian di PHP

Laravel Pest Untuk Test Api


Tutorial Custom Laravel Error Handler menggunakan Json Response Biar Terlihat rapi, karena Laravel Tidak Menyediakan Untuk Pengaturan Default, maka kita harus mengubahnya dan mengkonversi response ke Json. Berikut beberapa Handler yang biasanya saya custom :

### Mengubah Exception MethodNotAllowedHttpException

Sekarang edit file `App/Exceptions/Handler.php` dan tambahkan di method :

```php
public function register()
{
        // Area ini yang akan kita buat Custom handler
}
```

Lalu tambahkan kode :

```php
use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;

...
$this->renderable(function (MethodNotAllowedHttpException $e) {
    return response()->json(['error' => 'Method Not Allowed', 'success' => false, 'message' => $e->getMessage()], SymfonyResponse::HTTP_METHOD_NOT_ALLOWED);
});
```

Code diatas akan mengubah Format error ketika anda mau membuat Response Api berupa `json` dengan error `MethodNotAllowedHttpException`

### Mengubah Exception NotFoundHttpException

Sekarang edit file `App/Exceptions/Handler.php` dan tambahkan di method :

```php
public function register()
{
        // Area ini yang akan kita buat Custom handler
}
```

Lalu tambahkan kode :

```php
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;

...
$this->renderable(function (NotFoundHttpException $e) {
    return response()->json(['error' => 'Http NotFound', 'success' => false, 'message' => $e->getMessage()], SymfonyResponse::HTTP_NOT_FOUND);
});

```

Code diatas akan mengubah Format error ketika anda mau membuat Response Api berupa `json` dengan Error `NotFoundHttpException`

### Mengubah Exception UnauthorizedException

Sekarang edit file `App/Exceptions/Handler.php` dan tambahkan di method :

```php
public function register()
{
        // Area ini yang akan kita buat Custom handler
}
```

Lalu tambahkan kode :

```php
use BadMethodCallException;

...
$this->renderable(function (BadMethodCallException $e) {
    return response()->json(['error' => 'Http NotFound', 'success' => false, 'message' => $e->getMessage()], 403);
});

```

Code diatas akan mengubah Format error ketika anda mau membuat Response Api berupa `json` dengan Error `BadMethodCallException`

### Mengubah Exception UnauthorizedException

Sekarang edit file `App/Exceptions/Handler.php` dan tambahkan di method :

```php
public function register()
{
        // Area ini yang akan kita buat Custom handler
}
```

Lalu tambahkan kode :

```php
// Jika anda menggunakan Spatie Permissions
use Spatie\Permission\Exceptions\UnauthorizedException;

...
$this->renderable(function (UnauthorizedException $e) {
    return response()->json(['error' => 'You do not have the required authorization.', 'success' => false, 'message' => $e->getMessage()], 403);
});

```

Code diatas akan mengubah Format error ketika anda mau membuat Response Api berupa `json` dengan Error `UnauthorizedException`

### Gabungan Untuk Menggunakan Semua Handler

Untuk Menggabungkan Semua Error Handler, bisa menambahkan seperti berikut :

```php
use BadMethodCallException;
use Spatie\Permission\Exceptions\UnauthorizedException;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;
use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

...
public function register()
{
    $this->renderable(function (MethodNotAllowedHttpException $e) {
        return response()->json(['error' => 'Method Not Allowed', 'success' => false, 'message' => $e->getMessage()], SymfonyResponse::HTTP_METHOD_NOT_ALLOWED);
    });

    $this->renderable(function (NotFoundHttpException $e) {
        return response()->json(['error' => 'Http NotFound', 'success' => false, 'message' => $e->getMessage()], SymfonyResponse::HTTP_NOT_FOUND);
    });

    $this->renderable(function (UnauthorizedException $e) {
        return response()->json(['error' => 'You do not have the required authorization.', 'success' => false, 'message' => $e->getMessage()], 403);
    });

    $this->renderable(function (BadMethodCallException $e) {
        return response()->json(['error' => 'Bad Method Call Exception', 'success' => false, 'message' => $e->getMessage()], 403);
    });

}
```

Demikian Tutorial tentang Laravel Custom Error Handler Json Response, semoga bermanfaat. Happy Coding...


Tutorial Custom Laravel Error Handler menggunakan Json Response Biar Terlihat rapi, karena Laravel Tidak Menyediakan Untuk Pengaturan Default, maka kita harus mengubahnya dan mengkonversi response ke Json sendiri

Laravel Custom Error Handler Json Response


Sequelize ORM menggunakan Filter dan Pagination lebih mudah dan lebih efisien untuk menghandle dan integrasi dengan Table di Front end, biasanya hal ini sangat menyulitkan karena `Sequelize` ini tidak menyajikan langsung dengan pagination dan filter di library bawaannya.

Pertama buat class terlebih dahulu untuk mengextract `limit` dan `offset` seperti ini :

```js
// pagination.js
const getPagination = (page, size) => {
  const limit = size ? +size : 10;
  const offset = page ? page * limit : 0;

  return { limit, offset };
};
```

Penjelasan diatas adalah :

```js
const limit = size ? +size : 10;
```

diatas menjelaskan request dari front end misal `size` itu direquest adalah `10` maka limit yang akan dikirim dari server adalah `10`

```js
const offset = page ? page * limit : 0;
```

Offset diatas adalah yang akan di skip, yg mana fungsi skip ini akan dilewati berapa `data` yang tidak akan kita query.

Lalu untuk extraksi data dan menggabungkannya dengan `pagination` bisa menggunakan seperti ini :

```js
const getPagingData = (models, page, limit) => {
  const { count: total, rows: data } = models;
  const currentPage = page ? +page : 0;
  const currentPageFront = page ? +page + Number(1) : Number(1);
  const totalPages = Math.ceil(total / limit - Number(1));
  const totalPagesFront = Math.ceil(total / limit);

  return {
    data,
    pagination: {
      total,
      totalPages,
      totalPagesFront,
      currentPage,
      currentPageFront,
    },
  };
};
```

Dan penjelasannya diatas adalah seperti ini :

```js
const { count: total, rows: data } = models;
```

`total` adalah extraksi dari count data yang dikumpulkan. dan rows adalah data dari query yg dihasilkan.

```js
const currentPage = page ? +page : 0;
```

untuk menentukan `currentPage` dibackend yang sedang di page tersebut kita buat parse seperti diatas. Untuk mengetahui posisi page sekarang.

```js
const currentPageFront = page ? +page + Number(1) : Number(1);
```

untuk menentukan `currentPageFront` difrontend yang sedang di page tersebut kita buat parse seperti diatas. Untuk mengetahui posisi page sekarang.

```js
const totalPages = Math.ceil(total / limit - Number(1));
```

untuk menentukan `totalPages` dibackend yang sedang di page tersebut kita buat parse seperti diatas. Untuk mengetahui posisi page sekarang.

```js
const totalPagesFront = Math.ceil(total / limit);
```

untuk menentukan `totalPagesFront` difrontend yang sedang di page tersebut kita buat parse seperti diatas. Untuk mengetahui posisi page sekarang.

### Parsing dari Controller untuk Mengekstrak Pagination

Untuk mempassing data dari controller ke Pagination class yang tadi kita buat:

```js
const { getPagination, getPagingData } = require('../utils/pagination');

...
const page = req.query.page || 0;
const size = req.query.size || 10;
const search = req.query.search || '';
const { limit, offset } = getPagination(page, size);
```

Fungsi Filter dari `Sequelize` seperti berikut :

```js
const { Op } = require('sequelize');

...
const condition = search
  ? {
      [Op.or]: {
        name: { [Op.iLike]: `%${search}%` },
      },
    }
  : null;
```

Selanjutnya kita buat pass data dari controller

```js
const { Model } = require('../models');

const models = await Model.findAndCountAll({
  attributes: ['id', 'name', 'created_at'],
  where: condition,
  order: sort,
  limit,
  offset,
});

const response = getPagingData(models, page, limit);

res.status(200).json(response);
```

Demikian tutorial Sequelize Pagination dan Filter di Nodejs, Happy Coding....


Sequelize ORM menggunakan Filter dan Pagination lebih mudah dan lebih efisien untuk menghandle dan integrasi dengan Table di Front end