Go語言工作流與故障注入測試

Go 語言是一種現代的編程語言，它提供了簡潔、高效和可靠的方式來構建軟件

1. Go 語言工作流：

在 Go 語言中，工作流通常是通過 goroutines 和 channels 來實現的。goroutine 是一個輕量級的線程，它可以并發地執行函數。channel 是一種同步機制，用于在不同的 goroutine 之間傳遞數據。

下面是一個簡單的 Go 語言工作流示例：

package main

import (
	"fmt"
	"sync"
)

func worker(id int, wg *sync.WaitGroup, jobs <-chan int, results chan<- int) {
	defer wg.Done()

	for job := range jobs {
		fmt.Printf("Worker %d started job %d\n", id, job)
		results <- job * 2
		fmt.Printf("Worker %d finished job %d\n", id, job)
	}
}

func main() {
	const numJobs = 5
	jobs := make(chan int, numJobs)
	results := make(chan int, numJobs)

	var wg sync.WaitGroup
	wg.Add(3)

	for i := 0; i < 3; i++ {
		go worker(i, &wg, jobs, results)
	}

	for i := 0; i < numJobs; i++ {
		jobs <- i
	}
	close(jobs)

	wg.Wait()
	close(results)

	for result := range results {
		fmt.Println("Result:", result)
	}
}

這個示例中，我們創建了一個工作流，其中有三個工作線程（worker）并發地處理任務。每個工作線程從 jobs channel 中獲取任務，處理任務后將結果發送到 results channel。主函數等待所有工作線程完成任務，然后關閉 results channel 并輸出結果。

2. Go 語言故障注入測試：

故障注入測試是一種測試方法，用于模擬系統中的故障情況，以驗證系統的容錯能力和恢復能力。在 Go 語言中，我們可以使用內置的 testing 包來進行故障注入測試。

下面是一個簡單的 Go 語言故障注入測試示例：

package main

import (
	"errors"
	"testing"
)

func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("division by zero")
	}
	return a / b, nil
}

func TestDivide(t *testing.T) {
	testCases := []struct {
		a, b     float64
		expected float64
		err      error
	}{
		{10, 2, 5, nil},
		{10, 0, 0, errors.New("division by zero")},
	}

	for _, tc := range testCases {
		result, err := divide(tc.a, tc.b)
		if err != nil && err.Error() != tc.err.Error() {
			t.Errorf("divide(%v, %v) error: expected %v, got %v", tc.a, tc.b, tc.err, err)
		} else if result != tc.expected {
			t.Errorf("divide(%v, %v) result: expected %v, got %v", tc.a, tc.b, tc.expected, result)
		}
	}
}

在這個示例中，我們定義了一個 divide 函數，用于計算兩個浮點數的除法。為了進行故障注入測試，我們編寫了一個名為 TestDivide 的測試函數，該函數使用 testing 包進行測試。我們定義了一組測試用例，其中包含正常情況和除數為零的異常情況。對于每個測試用例，我們調用 divide 函數并檢查結果是否符合預期。如果結果不符合預期，我們使用 t.Errorf 記錄錯誤。

要運行測試，只需在命令行中輸入 go test 命令即可。