Pengujian Kode Data-Intensif dengan Go, Bagian 3

() translation by (you can also view the original English article)

Ikhtisar

Ini adalah bagian tiga dari dari lima dalam seri tutorial tentang pengujian kode data-intensif dengan Go. Pada bagian kedua, saya membahas pengujian terhadap lapisan data nyata dalam-memori berdasarkan SQLite yang populer. Dalam tutorial ini, saya akan melakukan pengujian terhadap lapisan data kompleks lokal yang menyertakan DB relasional dan cache Redis.

Pengujian Terhadap Lapisan Data Lokal

Pengujian terhadap lapisan data dalam-memori adalah luar biasa. Pengujiannya cepat, dan Anda memiliki kontrol penuh. Tetapi terkadang Anda harus lebih dekat dengan konfigurasi sebenarnya dari lapisan data produksi Anda. Berikut beberapa kemungkinan alasannya:

Anda menggunakan detail spesifik dari DB relasional Anda yang ingin Anda uji.
Lapisan data Anda terdiri dari beberapa penyimpanan data yang saling berinteraksi.
Kode yang diuji terdiri dari beberapa proses yang mengakses lapisan data yang sama.
Anda ingin mempersiapkan atau mengamati data uji Anda menggunakan alat standar.
Anda tidak ingin menerapkan lapisan data dalam-memori khusus jika lapisan data Anda berubah-ubah.
Anda hanya ingin tahu bahwa Anda menguji terhadap lapisan data Anda yang sebenarnya.
Anda perlu menguji dengan banyak data yang tidak sesuai dalam memori.

Saya yakin ada alasan lain, tetapi Anda dapat melihat mengapa hanya menggunakan sebuah lapisan data dalam-memori untuk pengujian mungkin tidak cukup dalam banyak kasus.

OK. Jadi kami ingin menguji lapisan data yang sebenarnya. Tapi kita tetap ingin menjadi seringan dan selincah mungkin. Itu berarti lapisan data lokal. Berikut manfaatnya:

Tidak perlu menyediakan dan mengkonfigurasi apa pun di pusat data atau cloud.
Tidak perlu khawatir tentang pengujian kami yang merusak data produksi secara tidak sengaja.
Tidak perlu berkoordinasi dengan sesama pengembang di lingkungan pengujian bersama.
Tidak ada kelambatan selama panggilan jaringan.
Kontrol penuh atas konten lapisan data, dengan kemampuan untuk memulai dari awal setiap saat.

Dalam tutorial ini kita akan menaikkan taruhannya. Kami akan mengimplementasikan (sebagian) lapisan data hibrid yang terdiri dari DB relasional MariaDB dan server Redis. Kemudian kita akan menggunakan Docker untuk membuat lapisan data lokal yang dapat kita gunakan dalam pengujian kami.

Menggunakan Docker untuk Menghindari Sakit Kepala Saat Instalasi

Pertama, Anda membutuhkan Docker, tentu saja. Lihat dokumentasinya jika Anda tidak terbiasa dengan Docker. Langkah selanjutnya adalah mendapatkan image untuk penyimpanan data kami: MariaDB dan Redis. Tanpa terlalu banyak detail, MariaDB adalah DB relasional hebat yang kompatibel dengan MySQL, dan Redis adalah penyimpanan kunci-nilai dalam-memori yang hebat (dan masih banyak lagi).

> docker pull mariadb
...

> docker pull redis
...

> docker images
REPOSITORY      TAG      IMAGE ID      CREATED      SIZE
mariadb         latest   51d6a5e69fa7  2 weeks ago  402MB
redis           latest   b6dddb991dfa  2 weeks ago  107MB

Sekarang setelah Docker diinstal dan kami memiliki image untuk MariaDB dan Redis, kami dapat menulis file docker-compose.yml, yang akan kami gunakan untuk meluncurkan penyimpanan data kami. Mari kita memanggil DB kami "songify".

mariadb-songify:
  image: mariadb:latest
  command: >
      --general-log 
      --general-log-file=/var/log/mysql/query.log
  expose:
    - "3306"
  ports:
    - "3306:3306"
  environment:
    MYSQL_DATABASE: "songify"
    MYSQL_ALLOW_EMPTY_PASSWORD: "true"
  volumes_from:
    - mariadb-data
mariadb-data:
  image: mariadb:latest
  volumes:
    - /var/lib/mysql
  entrypoint: /bin/bash

redis:
  image: redis
  expose:
    - "6379"
  ports:
    - "6379:6379"

Anda dapat meluncurkan penyimpanan data Anda dengan perintah docker-compose up (mirip dengan vagrant up). Keluarannya akan terlihat seperti ini:

> docker-compose up
Starting hybridtest_redis_1 ...
Starting hybridtest_mariadb-data_1 ...
Starting hybridtest_redis_1
Starting hybridtest_mariadb-data_1 ... done
Starting hybridtest_mariadb-songify_1 ...
Starting hybridtest_mariadb-songify_1 ... done
Attaching to hybridtest_mariadb-data_1, 
             hybridtest_redis_1, 
             hybridtest_mariadb-songify_1
.
.
.
redis_1  | * DB loaded from disk: 0.002 seconds
redis_1  | * Ready to accept connections
.
.
.
mariadb-songify_1  | [Note] mysqld: ready for connections.
.
.
.

Pada titik ini, Anda memiliki server MariaDB lengkap mendengarkan pada port 3306 dan server Redis mendengarkan pada port 6379 (keduanya adalah port standar).

Lapisan Data Hibrid

Mari manfaatkan penyimpanan data yang kuat ini dan tingkatkan lapisan data kami ke lapisan data hibrid yang menyimpan lagu-lagu per pengguna dalam Redis. Ketika GetSongsByUser() dipanggil, lapisan data akan memeriksa dulu apakah Redis sudah menyimpan lagu untuk pengguna. Jika itu kemudian hanya mengembalikan lagu dari Redis, tetapi jika tidak (cache miss) maka akan mengambil lagu-lagu dari MariaDB dan mengisi cache Redis, sehingga siap untuk waktu berikutnya.

Berikut adalah definisi struct dan constructor. Struct ini menyimpan handle DB seperti sebelumnya dan juga klien redis. Constructor menghubungkan ke DB relasional serta Redis. Ini menciptakan skema dan flushes redis hanya jika parameter yang sesuai adalah true, yang diperlukan hanya untuk pengujian. Dalam produksi, Anda membuat skema sekali (mengabaikan migrasi skema).

type HybridDataLayer struct {
    db *sql.DB
  redis *redis.Client
}

func NewHybridDataLayer(dbHost string, 
                        dbPort int, 
                        redisHost string, 
                        createSchema bool, 
                        clearRedis bool) (*HybridDataLayer, 
                                          error) {
	dsn := fmt.Sprintf("root@tcp(%s:%d)/", dbHost, dbPort)
	if createSchema {
		err := createMariaDBSchema(dsn)
		if err != nil {
			return nil, err
		}
	}

	db, err := sql.Open("mysql", 
                         dsn+"desongcious?parseTime=true")
	if err != nil {
		return nil, err
	}

	redisClient := redis.NewClient(&redis.Options{
		Addr:     redisHost + ":6379",
		Password: "",
		DB:       0,
	})

	_, err = redisClient.Ping().Result()
	if err != nil {
		return nil, err
	}

	if clearRedis {
		redisClient.FlushDB()
	}

	return &HybridDataLayer{db, redisClient}, nil
}

Menggunakan MariaDB

MariaDB dan SQLite sedikit berbeda sejauh DDL berjalan. Perbedaannya kecil, tetapi penting. Go tidak memiliki piranti lintas-DB yang matang seperti SQLAlchemy yang fantastis dari Python, jadi Anda harus mengelolanya sendiri (tidak, Gorm tidak dihitung). Perbedaan utama adalah:

Driver SQL adalah "github.com/go-sql-driver/mysql".
Database tidak hidup dalam memori, sehingga dibuat ulang setiap kali (drop dan create).
Skema harus merupakan bagian dari pernyataan DDL independen, bukan satu string dari semua pernyataan.
Primary key auto increment ditandai oleh AUTO_INCREMENT.
VARCHAR bukannya TEXT.

Berikut ini kodenya:

func createMariaDBSchema(dsn string) error {
    db, err := sql.Open("mysql", dsn)
	if err != nil {
		return err
	}

	// Recreate DB
	commands := []string{
		"DROP DATABASE songify;",
		"CREATE DATABASE songify;",
	}
	for _, s := range (commands) {
		_, err = db.Exec(s)
		if err != nil {
			return err
		}
	}

	// Create schema
	db, err = sql.Open("mysql", dsn+"songify?parseTime=true")
	if err != nil {
		return err
	}

	schema := []string{
		`CREATE TABLE IF NOT EXISTS song (
		  id          INTEGER PRIMARY KEY AUTO_INCREMENT,
		  url         VARCHAR(2088) UNIQUE,
		  title       VARCHAR(100),
		  description VARCHAR(500)
		);`,
		`CREATE TABLE IF NOT EXISTS user (
		  id            INTEGER PRIMARY KEY AUTO_INCREMENT,
		  name          VARCHAR(100),
		  email         VARCHAR(100) UNIQUE,
		  registered_at TIMESTAMP,
		  last_login    TIMESTAMP
		);`,
		"CREATE INDEX user_email_idx  ON user (email);",
		`CREATE TABLE IF NOT EXISTS label (
		  id   INTEGER PRIMARY KEY AUTO_INCREMENT,
		  name VARCHAR(100) UNIQUE
		);`,
		"CREATE INDEX label_name_idx ON label (name);",
		`CREATE TABLE IF NOT EXISTS label_song (
		  label_id  INTEGER NOT NULL REFERENCES label (id),
		  song_id INTEGER NOT NULL REFERENCES song (id),
		  PRIMARY KEY (label_id, song_id)
		);`,
		`CREATE TABLE IF NOT EXISTS user_song (
		  user_id INTEGER NOT NULL REFERENCES user (id),
		  song_id INTEGER NOT NULL REFERENCES song (id),
		  PRIMARY KEY (user_id, song_id)
		);`,
	}

	for _, s := range (schema) {
		_, err = db.Exec(s)
		if err != nil {
			return err
		}
	}
	return nil
}

Menggunakan Redis

Redis sangat mudah digunakan dari Go. Perpustakaan klien "github.com/go-redis/redis" sangat intuitif dan setia mengikuti perintah Redis. Sebagai contoh, untuk menguji apakah sebuah kunci ada, Anda hanya menggunakan metode Exists() dari klien redis, yang menerima satu atau lebih kunci dan mengembalikan berapa banyak dari mereka ada.

Dalam hal ini, saya memeriksa satu kunci saja:

1	count, err := m.redis.Exists(email).Result()
2	if err != nil {
3	return err
4	}

Menguji Akses ke Banyak Penyimpanan Data

Pengujiannya sebenarnya identik. Antarmuka tidak berubah, dan perilaku tidak berubah. Satu-satunya perubahan adalah bahwa implementasi sekarang menyimpan cache di Redis. Metode GetSongsByEmail() sekarang hanya memanggil refreshUser_Redis().

func (m *HybridDataLayer) GetSongsByUser(u User) (songs []Song, 
                                                  err error) {
    err = m.refreshUser_Redis(u.Email, &songs)
	return
}

Metode refreshUser_Redis() mengembalikan lagu-lagu pengguna dari Redis jika ada dan sebaliknya mengambilnya dari MariaDB.

type Songs *[]Song

func (m *HybridDataLayer) refreshUser_Redis(email string, 
                                            out Songs) error {
    count, err := m.redis.Exists(email).Result()
	if err != nil {
		return err
	}

	if count == 0 {
		err = m.getSongsByUser_DB(email, out)
		if err != nil {
			return err
		}

		for _, song := range *out {
			s, err := serializeSong(song)
			if err != nil {
				return err
			}

			_, err = m.redis.SAdd(email, s).Result()
			if err != nil {
				return err
			}
		}
		return
	}

	members, err := m.redis.SMembers(email).Result()
	for _, member := range members {
		song, err := deserializeSong([]byte(member))
		if err != nil {
			return err
		}
		*out = append(*out, song)
	}

	return out, nil
}

Ada sedikit masalah di sini dari sudut pandang metodologi pengujian. Ketika kami menguji melalui antarmuka lapisan data abstrak, kami tidak memiliki visibilitas ke dalam implementasi lapisan data.

Sebagai contoh, ada kemungkinan bahwa ada cacat besar di mana lapisan data benar-benar melompati cache dan selalu mengambil data dari DB. Pengujian akan dilalui, tetapi kami tidak mendapatkan manfaat dari cache. Saya akan berbicara di bagian lima tentang menguji cache Anda, yang sangat penting.

Kesimpulan

Dalam tutorial ini, kami membahas pengujian terhadap lapisan data kompleks lokal yang terdiri dari banyak penyimpanan data (DB relasional dan cache Redis). Kami juga menggunakan Docker untuk menyebarkan banyak penyimpanan data dengan mudah untuk diuji.

Di bagian empat, kami akan fokus pada pengujian terhadap penyimpanan data jarak jauh, menggunakan snapshot data produksi untuk pengujian kami, dan juga menghasilkan data uji kami sendiri. Nantikanlah!