Sinon.js adalah tools yang sangat bermanfaat apabila kita ingin melakukan unit test untuk Java Scripts. Sinon menyediakan fitur untuk melakukan Spies, Stubs, dan Mock. Apa saja itu? Mari kita bahas lebih lanjut.

Pengantar

Membuat testing code dengan menggunakan banyak sekali functional lain seperti Ajax, networking, database, dan dependency lainnya tentu saja akan sangat sulit. Misalnya saja apabila aplikasi kita melakukan perintah Ajax atau networking lainnya, kita harus memastikan server yang akan memberikan response pada request kita. Selain itu penggunaan database harus dipastikan bahwa database kita sudah siap untuk memberikan data. Hal ini berarti test yang dibuat akan semakin sulit karena kita harus mempersiapkan environment agar test berjalan lancar.

Sinon.js hadir menyelesaikan masalah yang ada dengan kemampuannya yaitu spies, stubs dan mocks.

Contoh fungsi

Agar mempermudah penjelasan, mari kita mulai dengan ilustrasi fungsi sebagai berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13

function setupNewUser(info, callback) {
  var user = {
    name: info.name,
    nameLowercase: info.name.toLowerCase()
  };

  try {
    Database.save(user, callback);
  }
  catch(err) {
    callback(err);
  }
}

Fungsi diatas akan menerima dua parameter yaitu sebuah objek info berisi data yang akan dimasukkan kedalam database dan sebuah callback function. Dalam kasus ini, fungsi save yang dilakukan dalam Database adalah untuk memasukkan data yang ada kedalam database.

Spies, Stubs, dan Mocks

Spies, Stubs, dan Mocks sama saja dengan pemeran pengganti (stunts) dalam film. Apa yang mereka lakukan adalah sebagai pengganti dari fungsi yang membutuhkan dependency yang ada pada kode kita.

Spies

Spies digunakan untuk memdapatkan informasi mengenai function call. Lebih lanjut, spy dapat memberitahukan berapa banyak sebuah fungsi dipanggil, apa saja argumen yang dipanggil, apa return value dan error yang di throw, dll.

Spy adalah pilihan yang baik untuk test yang ingin melakukan verifikasi terhadap suatu pemanggilan fungsi. Dikombinasikan dengan assertions, kita bisa mengecek berapa banyak perbedaan yang tidak sesuai dengan harapan test kita.

Biasa spies digunakna untuk:

• Mengetahui berapa banyak sebuah fungsi dipanggil
• Mengetahui argumen apa saja yang dipanggil bersamaan dengan fungsi

Ada beberapa fungsi yang bisa digunakan untuk mengecek berapa kali suatu fungsi dipanggil diantaranya:

• sinon.assert.callCount akan menghitung berapa kali fungsi dipanggil
• sinon.assert.calledOnce akan memastikan fungsi dipanggil tepat satu kali
• sinon.assert.notCalled akan memastikan fungsi tidak dipanggil

Misalnya berikut adalah test code yang kita miliki:

1
2
3
4
5
6
7
8

it('should call save once', function() {
  var save = sinon.spy(Database, 'save');

  setupNewUser({ name: 'test' }, function() { });

  save.restore();
  sinon.assert.calledOnce(save);
});

Selain itu, untuk mengetahui argumen apa yang dipanggil bersamaan dengan fungsi kita bisa menggunakan sinon.assert.calledWith. Berikut adalah contohnya:

1
2
3
4
5
6
7
8
9
10
11
12
13

it('should pass object with correct values to save', function() {
  var save = sinon.spy(Database, 'save');
  var info = { name: 'test' };
  var expectedUser = {
    name: info.name,
    nameLowercase: info.name.toLowerCase()
  };

  setupNewUser(info, function() { });

  save.restore();
  sinon.assert.calledWith(save, expectedUser);
});

Masih banyak hal lain yang dapat di-assert oleh spy, pada penjelasan ini saya tidak menjelaskan keseluruhan hal yang dapat dilakukan.

Spy tidak akan mengubah behavior dari fungsi, namun apabila kita ingin mengubahnya maka kita bisa menggunakan stub.

Stubs

Stubs sebenarnya menyerupai spies, hanya saja stubs akan menimpa fungsi. Stub bisa saja mengubah behavior dari fungsi seperti mengembalukan nilai tertentu atau mengembalikan error. Stub biasa digunakan untuk:

• Apabila ingin menimpa fungsi yang membutuhkan dependency lain
• Apabila ingin melakukan error trigger

Apabila ingin menimpa fungsi yang membutuhkan dependency lain, seperti Database.save pada contoh, kita bisa menggunakan stub, sehingga dalam kasus ini, kita tidak perlu memastikan Database sudah siap digunakan dengan pengaturan yang ada, tetapi akan dibuatkan fungsi pengganti oleh Sinon. Berikut adalah contohnya:

1
2
3
4
5
6
7
8
9
10
11
12
13

it('should pass object with correct values to save', function() {
  var save = sinon.stub(Database, 'save');
  var info = { name: 'test' };
  var expectedUser = {
    name: info.name,
    nameLowercase: info.name.toLowerCase()
  };

  setupNewUser(info, function() { });

  save.restore();
  sinon.assert.calledWith(save, expectedUser);
});

Dengan menimpa fungsi Database.save kita tidak perlu lagi bersusah payah memikirkan mengenai kesiapan database dalam menangani test.

Selain itu, apabila ingin melakukan testing terhadap error, kita juga bisa menggunakan stub. Berikut adalah contohnya:

1
2
3
4
5
6
7
8
9
10
11

it('should pass the error into the callback if save fails', function() {
  var expectedError = new Error('oops');
  var save = sinon.stub(Database, 'save');
  save.throws(expectedError);
  var callback = sinon.spy();

  setupNewUser({ name: 'foo' }, callback);

  save.restore();
  sinon.assert.calledWith(callback, expectedError);
});

Mocks

Setelah mengetahui penjelasan mengenai spies dan stubs, sekarang kita akan berkenalan dengan mocks. Mocks pada dasarnya adalah yang paling sakti diantara spies dan stubs, karena mocks dapat melakukan apa yang dapat dilakukan oleh spies dan stubs. Tapi tentu saja terdapat trade off yang siap dibayar apabila menggunakan mocks, yaitu apabila salah dalam penulisan akan mudah sekali terjadi error pada test yang ada karena kita mendefinisikan ekspektasi di awal. Maksudnya dalam mocks kita bisa saja mendefinisikan multiple assertion yang mana harus dicek secara pasti agar tidak terjadi kesalahan. Langsung saja berikut adalah contoh penggunaan mocks:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

it('should pass object with correct values to save only once', function() {
  var info = { name: 'test' };
  var expectedUser = {
    name: info.name,
    nameLowercase: info.name.toLowerCase()
  };
  var database = sinon.mock(Database);
  database.expects('save').once().withArgs(expectedUser);

  setupNewUser(info, function() { });

  database.verify();
  database.restore();
});

Dalam kasus ini kita memastikan agar fungsi dipanggil sekali dengan fungsi once() dan argument yang digunakan harus sesuai dengan fungsi withArgs(). Jadi dengan mocks, kita dapat menggunakan multiple assertion yang sesuai dengan fungsi yang kita mau test.
Tips

Apabila kita menggunakan fungsi yang sama-sama akan distub dan digunakan dalam beberapa test berbeda, kita dapat melakukan shared stubs dengan fungsi beforeEach(). Sebagai contoh:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

describe('Something', function() {
  var save;
  beforeEach(function() {
    save = sinon.stub(Database, 'save');
  });

  afterEach(function() {
    save.restore();
  });

  it('should do something', function() {
    //you can use the stub in tests by accessing the variable
    save.yields('something');
  });
});

Yang harus dipastikan adalah setelah pemanggilan afterEach() harus melakukan clean up fungsi stub dengan perintah restore().

Test Driven Development atau TDD (Beck 2003; Astels 2003) adalah sebauh pendekatan pengembangan yang mengkombinasikan pembuatan test-first development dan refactoring.

Test-first development adalah disaat kita membuat test terlebih dahulu sebelum membuat kode yang bisa memenuhi test tersebut. Lantas apa yang menjadi tujuan utama dari TDD? Yang menjadi tujuan utama dari TDD adalah spesifikasi dan bukan validasi (Martin, Newkirk, and Kess 2003). Dalam kata lain, kita harus memikirkan dengan baik mengenai requirement dan design yang ada sebelum masuk kedalam tahap functional. TDD sebenarnya tidak hanya berbicara masalah test tetapi juga berbicara masalah bagaimana menulis code dengan baik, mengikuti kaidah clean code (Tulisan ini sudah dibuat oleh Brigita Maria Wiputri).

Apa itu TDD?

Seperti yang sudah dijelaskan di atas, TDD memiliki rumus yang sederhana, yaitu merupakan kombinasi dari test-first development dan refactoring.

1

TDD = TFD + Refactoring

TFD sendiri adalah kegiatan dimana kita menambahkan sebuah test sederhana, sehingga code yang ada akan gagal jika menjalankan test. Setelah itu kita membuat functional code yang sesuai untuk melewati test yang telah kita buat tadi. Setelah itu, kembali lakukan testing dan pastikan functional code yang ada berhasil melewati test yang ada. Jika seluruh test yang ada berhasil dilewati, maka kembali buat test yang sesuai untuk memenuhi requirement yang ada.

Secara umum, berikut adalah langkah yang dilakukan dalam TFD:

1. Tambahkan test sesuai requirement dan design
2. Tambahkan functional code yang sesuai untuk melewati test yang ada
3. Kembali lakukan langkah 1 sampai proses development selesai

TDD akan merubah pandangan kita mengenai proses development. Ketika biasanya kita akan langsung memikirkan bagaimana implementasi yang sesuai untuk requirement, tetapi sekarang kita akan memikirkan design terbaik untuk diimplementasikan pada functional code yang ada, mengacu pada test yang sudah dibuat. Selain itu ditambah dengan refactoring code yang sudah dibuat, guna meningkatkan kualitas code yang dibuat menyesuaikan dengan functional code lainnya yang sudah dibuat sebelumnya. Kombinasi dari TFD dan Refactoring akan meningkatkan kualitas code yang dibuat sehingga akan memudahkan pengembangan baik berupa penambahan code ataupun berupa integrasi dengan code lainnya.

Jika menggunakan TDD, programmer tidak akan menulis functional code terlebih dahulu, melainkan akan menulis test, sedikit demi sedikit baru diselesaikan dengan functional code yang sesuai. Melalui hal ini, kita juga bisa menerapkan prinsip lainnya dalam pengembangan yaitu berupa Pair Programming, dimana teman kita dapat mengingatkan untuk selalu on track dalam melaksanakan TDD, berupa TFD lalu Refactoring.

Kelebihan TDD

Penerapan TDD memiliki beberapa kelebihan dan kekurangan dan akan dibahas setelah ini. Proses testing akan membantu programmer untuk berfikir mengenai code design. Didorong dengan keharusan untuk membuat test terlebih dahulu, programmer akan berusaha untuk berfikir mengenai code design yang sesuai sehingga dapat digunakan dan di-improve secara terus menerus selama proses development.

TDD akan memastikan bahwa penambahan ataupun perubahan terhadap code tidak berpengaruh terhadap functionality. Kenapa hal ini bisa terjadi? Hal ini bisa terjadi karena proses dari TDD sendiri berlangsung berupa pembuatan code test, lalu selesaikan test yang ada, lalu ulangi kembali. Untuk dapat menambahkan test yang baru, perlu dipastikan bahwa functional code yang ada tetap berhasil melewati test yang ada.

TDD akan memastikan bahwa aplikasi yang dibuat sudah di-test dengan baik dan bebas dari bug. Dengan metode ini juga meningkatkan awareness tentang testing, sembari menulis code. Hal ini akan membangun kebiasaan yang baik bagi programmer dalam melakukan pengembangan yang ada. Memastikan functionality yang ada dapat berjalan dengan baik, sehingga mempercepat proses pengembangan.

Apa sih yang membuat Git berbeda dengan Version Control yang lainnya?

Perbedaan antara Git dengan VCS lainnya terlihat pada data apa yang disimpan sebagai pencatatan perubahan file. Pada VCS yang lainnya, data akan disimpan berupa list dari perubahan file-based. Maksudnya adalah sistem ini akan menyimpan informasi berupa sekumpulan file lalu perubahan apa saja yang kita lakukan terhadap file tersebut.

Sementara itu, apa yang dilakukan oleh Git dalam pencatatan perubahan pada file? Berbeda dengan sistem VCS lainnya, Git akan menyimpan data yang ada sebagai snapshots miniatur keseluruhan sistem file. Maksudnya, ketika melakukan commit atau menyimpan state dari project kedalam Git, maka keseluruhan file yang ada akan disimpan gambarannya kedalam sebuah snapshots. Tentu saja terdapat penghematan dari sisi penyimpanan yang dilakukan Git, yaitu untuk file yang sama tidak akan disimpan ulang, melainkan hanya akan disimpan reference link menuju file sebelumnya.

Hal inilah yang menjadi pembeda antara Git dengan VCS lainnya, dimana Git akan menyerupai mini file system yang dapat dilengkapi dengan tools keren lainnya, dibandingkan dengan VCS sederhana lainnya.

Git Workflow

Hal yang sangat penting untuk dipahami dari Git adalah workflow dari Git itu sendiri. Terdapat tiga keadaan yang harus diingat pada Git yaitu: commited, modified, dan staged. Commited adalah ketika data yang ada sudah secara aman disimpan pada database local git. Modified adalah kondisi dimana kita melakukan perubahan terhadap data yang ada tetapi belum melakukan commit. Staged adalah kondisi dimana kita sudah menandai data yang diubah pada versi saat ini, untuk menjadi commit snapshot selanjutnya.

Setelah memahami ketiga keadaan diatas, maka kita akan mendapatkan tiga bagian utama dari Git project, yaitu Git Directory, working tree, dan staging area.

Git directory merupakan tempat dimana Git menyimpan metadata dan object database untuk project kita. Ini adalah bagian terpenting dari Git dan ini adalah hal yang kita pindahkan ketika kita melakukan clone repository.

Working tree adalah sebuah checkout dari suatu versi project yang ada. File yang ada akan di-pull dari Git directory dan ditempatkan pada folder dimana kita akan bekerja untuk melakukan modifikasi file.

Staging area adalah sebuah file, biasanya berada pada Git directory. File ini akan menyimpan informasi mengenai data mana saja yang akan masuk kedalam commit berikutnya. File ini biasanya disebut “index”, tapi biasa juga disebut staging area.

Apabila dirangkum, secara umum berikut adalah workflow dari Git:

1. Melakukan modifikasi terhadap file yang ada pada working tree.
2. Melakukan staging terhadap file yang dimodifikasi, menambahkan snapshots pada staging area.
3. Melakukan commit, dimana akan menyimpan data snapshot yang ada pada staging area untuk disimpan secara permanent pada Git directory.

Apabila terdapat suatu versi file pada Git directory, maka file itu dinyatakan commited. Apabila file yang tadinya dimodifikasi dan ditambahkan ke staging area, maka file tersebut dinyatakan staged. Apabila file tersebut belum di staged, maka dia dinyatakan modified.

I know the theory, then?

Setelah mengetahui teori penggunaan dari Git, saya akan menjelaskan beberapa hal dasar yang harus dipahami dari Git. Bisa dikatakan ini adalah cheatsheet Git sederhana.

Setup

• Untuk mengetahui lokasi Git diinstal which git
• Mengetahui versi Git terinstall git --version
• Help git help

General

• Melakukan inisialisasi git init
• Melakukan staging terhadap seluruh file git add .
• Melakukan staging terhadap file tertentu git add index.html
• Melakukan commit terhadap perubahan yang ada git commit -m "Message"
• Menghapus file dari Git git rm index.html
• Melakukan undo terhadap commit yang sudah dilakukan git checkout -- index.html
• Melakukan restore file dari commit tertentU git checkout 6eb715d -- index.html

Reset

• Kembali pada commit tertentu git revert 073791e7dd71b90daa853b2c5acc2c925f02dbc6
• Undo commit terakhir yang dilakukan git reset --soft ~HEAD

Branch

• Melihat branch apa saja yang ada git branch
• Membuat sebuah branch baru git branch branchname
• Pindah ke branch tertentu git checkout branchname
• Membuat dan pindah ke branch baru git checkout -b branchname
• Melakukan penamaan ulang pada suatu branch git branch -m branchname new_branchname atau git branch --move branchname* new_branchname
• Menghapus branch yang ada git branch -D branch_to_delete

Merge

• Melakukan merge (apabila terjadi fast forward) git merge branchname
• Merge ke master (jika fast forward) git merge --ff-only branchname
• Merge ke master (mode paksa) git merge --no-ff branchname
• Menghentikan merge (jika konflik) git merge --abort
• Menghentikan merge (jika konflik) git reset --merge // untuk v1.7.4
• Melakukan merge hanya pada commit tertentu git cherry-pick 073791e7

Stash

• Memasukkan file ke dalam stash git stash save "Message"
• Melihat stash git stash list
• Melihat status stash git stash show stash@{0}
• Melihat perubahan stash git stash show -p stash@{0}
• Menghapus item custom stash git stash drop stash@{0}
• Menghapus stash keseluruhan git stash clear

Compare

• Melakukan komparasi atas file yang dimodifikasi git diff
• Melakukan komparasi pada modified file dan memberikan highlight pada perubahan yang ada git diff --color-words index.html
• Komparasi modified file pada tahap staging git diff --staged
• Melakukan komparasi branch git diff master..branchname
• Melakukan komparasi commit git diff 6eb715d git diff 6eb715d..HEAD git diff 6eb715d..537a09f
• Komparasi file pada suatu commit git diff 6eb715d index.html git diff 6eb715d..537a09f index.html

Gitignore

Adalah sekumpulan file yang akan di ignore oleh Git. Template yang biasa digunakan dalam Gitignore ada di https://github.com/github/gitignore

Kesimpulan

Penggunaan Git akan sangat membantu pekerjaan terutama programmer dan designer ataupun pekerjaan lainnya yang membutuhkan versioning dalam pekerjaannya sehingga mempermudah pekerjaan apabila ingin melakukan perubahan atau memperhatikan perubahan yang ada dari file-file yang digunakan.

Referensi: https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control

Pada judul dari blog ini sengaja digunakan kata tanya kenapa. Lalu kenapa? Kenapa Version Control? Dalam post kali ini saya akan mencoba menjelaskan kenapa dan ada apa dengan Version Control.

Version Control itu apa?

Version control sejatinya adalah sistem yang dapat menyimpan perubahan yang dilakukan terhadap suatu file ataupun sekumpulan file, sehingga kita dapat melakukan mengatur versi dari file tersebut. Maksudnya seperti apa? Secara sederhana kita dapat menganggap Version Control adalah sistem yang akan mencatat setiap perubahan yang kita lakukan terhadap file yang ada, lalu dengan adanya catatan ini, kita dapat menggunakannya untuk merubah versi file yang ada (seperti kembali ke versi sebelumnya).

Version Control System akan sangat bermanfaat apabila kita bekerja pada lingkungan yang sangat fragile dimana akan sering melakukan perubahan terhadap versi dari file yang ada menyesuaikan dengan kondisi, seperti source code. Pentingnya pemanfaatan VCS akan terlihat apabila mengerjakan sebuah project secara bersama-sama dalam team.
Local vs Centralized vs Distributed VCS

Penggunaan local VCS biasa digunakan oleh banyak orang untuk melakukan pencatatan terhadap perubahan file yang dilakukan. Hal ini berangkat dari masalah yang ada, yaitu tanpa adanya pencatatan, maka untuk melakukan versioning seseorang harus menyimpan beberapa versi file yang ada pada folder yang berbeda dan memindahkannya secara manual. Tapi semenjak adanya Local VCS, kita tidak perlu melakukan itu :D

Namun permasalahan baru muncul, yaitu apabila kita bekerja dalam team sehingga dibutuhkan kolaborasi dengan team member yang lainnya dalam menyelesaikan suatu file, maka penggunaan Local VCS sudah tidak dapat diterapkan. Karena alasan tersebut berkembanglah metode Centralized VCS.

Dengan menggunakan metode ini, maka pencatatan perubahan file akan disimpan pada server sehingga pengguna yang ingin mengakses pencatatan hanya cukup melakukan akses kepada server sehingga memudahkan pengguna apabila ingin berkolaborasi dengan team member lainnya.

Namun masih terdapat masalah yang muncul yaitu apabila server yang digunakan untuk menyimpan pencatatan mengalami masalah, maka seluruh pencatatan yang sudah disimpan tidak akan ada gunanya. Seluruh file yang ada berpotensi hilang. Lalu berkembanglah sistem yang digunakan dewasa ini, Distributed VCS.

Apa yang menjadi perbedaan pada Distributed VCS adalah kita tidak hanya mengupload pencatatan pada server, tetapi yang kita lakukan sebenarnya adalah mirroring pencatatan local yang ada ke server, sehingga setiap pengguna sebenarnya masih memiliki penatatan yang tersimpan, sehingga apabila terjadi masalah dengan server maka team member lainnya masih dapat melakukan back-up.

Banyak sekali VCS yang bisa digunakan, diantaranya adalah Git, Mercurial, Bazaar, dan Darcs. Dalam PPL kali ini, yang digunakan adalah Git dengan server menggunakan GitLab.

Migration script adalah script yang digunakan untuk memudahkan kita dalam melakukan migrasi baik berupa environment atau hanya sekedar database. Dalam studi kasus PPL kali ini, kelompok kami hanya akan melakukan migrasi database. Walaupun terkesan sederhana tetapi migration script sangat bermanfaat dan bisa memudahkan pekerjaan.

Migration Script itu apa?

Secara sederhana, migration script dapat membantu kita untuk melakukan migrasi, bisa berupa perubahan versi aplikasi ataupun pindah server. Ilustrasi sederhana yang dapat menggambarkan migration script adalah pindah rumah. Pada saat pindah dari rumah, maka kita akan berkemas untuk memindahkan barang-barang yang ada di dalam rumah kita untuk dipindahkan ke rumah yang baru. Bayangkan proses memindahkan barang-barang yang ada, hingga pemasangan di rumah yang baru dilakukan oleh sebuah migration script sehingga mempermudah kita dalam pindah rumah.

Pada kenyataannya, migration script dalam database biasa digunakan untuk melakukan drop table, membuat table baru, menambahkan column baru pada table, atau melakukan split table. Migration script dapat dibuat secara manual oleh database programmer atau dibuat secara otomatis.

Sequelize

Sequelize adalah adalah ORM dengan tipe promise untuk Node.js yang dapat mendukung dialeg MySQL. Sequelize sangat mudah untuk digunakan dalam pengembangan aplikasi berbasis Node.js.

Model

Sequelize digunakan dalam pembuatan model. Berikut adalah contoh model menggunakan Sequelize.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

module.exports = function(sequelize, DataTypes) {
   return sequelize.define("employees", {
      email: DataTypes.STRING,
      password: DataTypes.TEXT,
      name: DataTypes.TEXT,
      join_date: DataTypes.DATE,
      place_of_birth: DataTypes.TEXT,
      date_of_birth: DataTypes.DATEONLY,
      is_admin: DataTypes.BOOLEAN,
      salary: DataTypes.INTEGER,
      retire_date: DataTypes.DATE
   }, {
      tableName: 'employees',
      indexes: [{
         unique: true,
         fields: ['email']
      }]
   });
};

Dalam kasus ini, kita membuat sebuah module yang akan mengembalikan object Sequelize employees beserta datatype yang sesuai.

Umzug

Umzug adalah sebuah agnostic migration tool framework untuk Node.js. Secara spesifik tool ini tidak dikhususkan untuk database, tapi menyediakan API yang baik dan mendukung Sequelize.

Instalasi

Untuk melakukan instalasi Umzug, dapat dilakukan sebagai berikut:

1

npm install --save umzug

Penggunaan

Secara umum, untuk menggunakan Umzug yang harus dilakukan adalah sebagai berikut:

1
2
3
4
5

var umzug = require('umzug');
var umzug = new umzug({});
umzug.someMethod().then(function (result) {
  // lakukan sesuatu dengan hasilnya
});

Dalam kasus migrasi, Umzug digunakan untuk memanggil migration up sebagai berikut:

1
2
3
4

umzug.up().then(function (migrations) {
  // "migrations" will be an Array with the names of the
  // executed migrations.
});

Implementasi

Setelah membahas cara instalasi dan penggunaan Umzug, maka kita akan membahas tahap implementasi. Berikut adalah potongan kode yang digunakan untuk menjalankan migrasi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// ... define other variable here
var umzug] = require('umzug');
var umzug] = new umzug({
   storage: 'sequelize',
   storageOptions: {
      sequelize: model.sequelize,
      tableName: '_migration'
   },
   logging: false,
   upName: 'up',
   downName: 'down',
   migrations: {
      params: [model.sequelize.getQueryInterface(), Sequelize],
      path: 'migrations',
      pattern: /^.*\.js$/,
   }
});

umzug.up().then(function(migrations, err) {
   console.log(migrations);
   app.listen(3000, function() {
      console.log('listening on port 3000');
   });
});

Dalam kasus ini, model adalah seluruh file yang menjadi model dan disimpan dalam folder models. Seluruh file migration akan disimpan dalam folder migrations. Perintah umzug.up() akan menjalankan migrasi yang ada, setelah selesai melaksanakan migrasi akan menjalankan server (app) pada port 3000.

Berikut adalah salah satu contoh module migrasi untuk melakukan drop table.

1
2
3
4
5
6

module.exports = {
   up: function (QueryInterface, Sequelize) {
      return QueryInterface.dropAllTables();
   },
   down: function (QueryInterface, Sequelize) {}
};

Berikut adalah salah satu contoh module migrasi untuk membuat table employees.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

module.exports = {
   up: function (QueryInterface, Sequelize) {
      return QueryInterface.createTable("employees", {
         id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true
         },
         email: {
            type: Sequelize.STRING,
            unique: true,
            allowNull: false
         },
         password: {
            type: Sequelize.STRING,
            allowNull: false
         },
         name: {
            type: Sequelize.STRING,
            allowNull: false
         },
         join_date: {
            type: Sequelize.DATE,
            allowNull: false
         },
         place_of_birth: Sequelize.STRING,
         date_of_birth: {
            type: Sequelize.DATEONLY,
            allowNull: false
         },
         is_admin: {
            type: Sequelize.BOOLEAN,
            allowNull: false
         },
         salary: {
            type: Sequelize.INTEGER,
            allowNull: false
         },
         retire_date: Sequelize.DATE
      }, {}); 
   },
   down: function (QueryInterface) {
      return QueryInterface.dropTable(tableName);
   }
};

Kesimpulan

Dalam pembuatan migration script sebagai bagian dari provisioning script dalam tugas PPL ini, saya sangat menyadari betapa penting dan bermanfaatnya penggunaaan migration script dalam memudahkan pekerjaan kita apabila melakukan migrasi aplikasi.