Pengalaman praktikal dalam pembangunan dipacu ujian di Golang

Pengalaman praktikal dalam pembangunan dipacu ujian di Golang

Ikhtisar:
Pembangunan Dipacu Ujian (TDD) ialah kaedah pembangunan perisian biasa. Ia menekankan penulisan kod ujian yang mengesahkan kefungsian sebelum menulis kod sebenar. Dengan menulis kod ujian, pembangun boleh lebih memahami keperluan, mentakrifkan antara muka dengan tepat dan meningkatkan kualiti dan kebolehselenggaraan kod. Artikel ini akan mengambil bahasa Golang sebagai contoh untuk memperkenalkan cara menggunakan pembangunan TDD dalam projek sebenar.

1. Tetapan persekitaran dan pengurusan pergantungan
   Pertama sekali, sebelum memulakan TDD, anda perlu menyediakan persekitaran pembangunan Golang. Pastikan Golang dipasang dan pembolehubah persekitaran GOROOT dan GOPATH ditetapkan.

Di Golang, terdapat banyak alatan pengurusan pergantungan untuk dipilih. Yang biasa termasuk go mod, dep, dll. Mengambil mod go sebagai contoh, gunakan arahan berikut untuk memulakan projek:

go mod init <项目名>

2. Buat fail ujian
   Untuk melaksanakan TDD, setiap fungsi harus mempunyai kod ujian yang sepadan. Dalam Golang, fail ujian diakhiri dengan _test.go dan Ujian ditambahkan sebelum nama fungsi. _test.go为后缀，并且在函数名前加上Test。

以一个简单的计算器为例，我们可以创建一个calculator_test.go的文件，并编写测试代码：

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    c := add(2, 3)
    if c != 5 {
        t.Error("Expected 5, got ", c)
    }
}

func TestSubtract(t *testing.T) {
    c := subtract(5, 2)
    if c != 3 {
        t.Error("Expected 3, got ", c)
    }
}

3. 编写功能代码
   测试代码编写完成后，我们需要编写功能代码来满足测试的需求。在本例中，我们可以在calculator.go文件中编写功能代码：

package main

func add(a, b int) int {
    return a + b
}

func subtract(a, b int) int {
    return a - b
}

4. 运行测试
   测试代码和功能代码编写完成后，我们可以运行测试代码来验证功能的正确性。在项目根目录下，运行以下命令：

go test

如果输出结果中没有出现错误，那么说明测试通过。

5. 迭代开发
   TDD的核心思想是迭代开发。在已经通过的测试代码基础上，我们可以添加更多的测试来覆盖更多的场景。然后，根据这些测试来修改和完善功能代码。

例如，我们可以添加一个测试来测试乘法运算：

func TestMultiply(t *testing.T) {
    c := multiply(4, 3)
    if c != 12 {
        t.Error("Expected 12, got ", c)
    }
}

然后，在功能代码中添加乘法函数：

func multiply(a, b int) int {
    return a * b
}

再次运行go test

Mengambil kalkulator mudah sebagai contoh, kita boleh mencipta fail calculator_test.go dan menulis kod ujian:

6. func TestDivideByZero(t *testing.T) {
       defer func() {
           if r := recover(); r != nil {
               if r != "divide by zero" {
                   t.Error("Expected 'divide by zero' error")
               }
           } else {
               t.Error("Expected 'divide by zero' error")
           }
       }()
       divide(5, 0)
   }

   
   Tulis kod berfungsi
Ujian Selepas kod ditulis, kita perlu menulis kod berfungsi untuk memenuhi keperluan ujian. Dalam kes ini, kita boleh menulis kod fungsi dalam fail calculator.go:

func divide(a, b int) int {
    if b == 0 {
        panic("divide by zero")
    }
    return a / b
}

Jalankan ujian

Selepas kod ujian dan kod fungsi ditulis, kita boleh Jalankan kod ujian untuk mengesahkan kefungsian. Dalam direktori akar projek, jalankan arahan berikut:

rrreee

Jika tiada ralat dalam output, ujian akan lulus.

Pembangunan berulangIdea teras TDD ialah pembangunan berulang. Berdasarkan kod ujian yang telah diluluskan, kami boleh menambah lebih banyak ujian untuk merangkumi lebih banyak senario. Kemudian, ubah suai dan perbaiki kod berfungsi berdasarkan ujian ini.

Sebagai contoh, kita boleh menambah ujian untuk menguji operasi pendaraban:

rrreee🎜Kemudian, tambahkan fungsi pendaraban dalam kod fungsi: 🎜rrreee🎜Jalankan perintah go test sekali lagi, jika ujian lulus, ini bermakna pembangunan berulang kami adalah tepat. 🎜🎜🎜Pengendalian situasi abnormal🎜Dalam perkembangan sebenar, kita perlu mempertimbangkan pelbagai situasi abnormal dan menulis kod ujian yang sepadan. 🎜🎜🎜Sebagai contoh, dalam kalkulator, kita perlu mempertimbangkan kes di mana pembahagi adalah 0. Kita boleh menambah ujian seperti ini: 🎜rrreee🎜 Kemudian, tambahkan fungsi bahagi dalam kod fungsi: 🎜rrreee🎜Jalankan ujian dan kita akan mendapat keputusan ujian lulus. 🎜🎜Ringkasan: 🎜Melalui pembangunan TDD, kami boleh meningkatkan kualiti dan kebolehselenggaraan kod. Di Golang, dengan menulis kod ujian, kami boleh lebih memahami keperluan, mentakrifkan antara muka dengan tepat dan memastikan ketepatan kod. 🎜🎜Walaupun TDD akan meningkatkan masa pembangunan dan beban kerja, ia boleh mengurangkan masa penyahpepijatan dan penyelenggaraan kemudian, meningkatkan kecekapan pembangunan dan kualiti kod. Oleh itu, TDD adalah sangat penting dalam projek sebenar, terutamanya projek yang melibatkan logik kompleks dan perubahan keperluan yang kerap. 🎜🎜Melalui pengenalan artikel ini, saya harap pembaca dapat lebih memahami dan mengaplikasikan pengalaman praktikal pembangunan berasaskan ujian di Golang. Mari kita cipta kod berkualiti tinggi bersama-sama! 🎜

Atas ialah kandungan terperinci Pengalaman praktikal dalam pembangunan dipacu ujian di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!