Go语言中利用httptest进行HTTP服务和客户端测试的实践指南

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "time"
)

// twitterResult 结构体用于解析API响应
type twitterResult struct {
    Results []struct {
        Text     string `json:"text"`
        Ids      string `json:"id_str"`
        Name     string `json:"from_user_name"`
        Username string `json:"from_user"`
        UserId   string `json:"from_user_id_str"`
    } `json:"results"` // 注意这里需要有json tag来匹配响应中的"results"键
}

// retrieveTweets 负责从指定的URL获取推文
func retrieveTweets(apiURL string) (*twitterResult, error) {
    resp, err := http.Get(apiURL)
    if err != nil {
        return nil, fmt.Errorf("failed to make HTTP request: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API returned non-OK status: %s", resp.Status)
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response body: %w", err)
    }

    r := new(twitterResult)
    err = json.Unmarshal(body, r) // 注意这里，r已经是*twitterResult类型，无需再取地址
    if err != nil {
        return nil, fmt.Errorf("failed to unmarshal JSON: %w", err)
    }
    return r, nil
}

// main函数仅作示例，实际测试中不会直接调用
func main() {
    // 实际应用中可能从配置读取
    twitterAPIURL := "http://search.twitter.com/search.json?q=%23UCL"

    // 为了演示，这里假设我们只获取一次
    tweets, err := retrieveTweets(twitterAPIURL)
    if err != nil {
        log.Fatalf("Error retrieving tweets: %v", err)
    }

    for _, v := range tweets.Results {
        fmt.Printf("%v:%v\n", v.Username, v.Text)
    }
    time.Sleep(5 * time.Second) // 模拟暂停
}

package main

import (
    "io"
    "net/http"
    "net/http/httptest"
    "testing"
)

// 定义一个模拟的Twitter API响应
const mockTwitterResponse = `{
    "results": [
        {"text":"hello from mock","id_str":"12345","from_user_name":"mock_user","from_user_id_str":"67890","from_user":"mockuser"},
        {"text":"another mock tweet","id_str":"54321","from_user_name":"test_user","from_user_id_str":"09876","from_user":"testuser"}
    ]
}`

// TestRetrieveTweets 使用 httptest.NewServer 测试 retrieveTweets 函数
func TestRetrieveTweets(t *testing.T) {
    // 1. 创建一个模拟的HTTP处理器
    // 这个处理器将模拟Twitter API的响应
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 验证请求路径和查询参数是否符合预期
        if r.URL.Path != "/search.json" || r.URL.Query().Get("q") == "" {
            http.Error(w, "Bad Request", http.StatusBadRequest)
            return
        }
        w.Header().Set("Content-Type", "application/json")
        io.WriteString(w, mockTwitterResponse)
    })

    // 2. 使用 httptest.NewServer 启动一个测试服务器
    server := httptest.NewServer(handler)
    defer server.Close() // 确保测试结束后关闭服务器

    // 3. 将被测试函数的API URL指向模拟服务器的URL
    // 这样 retrieveTweets 就会向我们的模拟服务器发送请求
    tweets, err := retrieveTweets(server.URL + "/search.json?q=%23Test")
    if err != nil {
        t.Fatalf("retrieveTweets returned an error: %v", err)
    }

    // 4. 验证返回的数据是否符合预期
    if tweets == nil {
        t.Fatal("Expected tweets, got nil")
    }
    if len(tweets.Results) != 2 {
        t.Errorf("Expected 2 tweets, got %d", len(tweets.Results))
    }
    if tweets.Results[0].Username != "mockuser" {
        t.Errorf("Expected first tweet username 'mockuser', got '%s'", tweets.Results[0].Username)
    }
    if tweets.Results[1].Text != "another mock tweet" {
        t.Errorf("Expected second tweet text 'another mock tweet', got '%s'", tweets.Results[1].Text)
    }
}

package main

import (
    "fmt"
    "net/http"
)

// myHandler 是一个简单的HTTP处理器
func myHandler(w http.ResponseWriter, r *http.Request) {
    switch r.URL.Path {
    case "/hello":
        fmt.Fprint(w, "Hello, World!")
    case "/status":
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, "Service is running.")
    default:
        http.NotFound(w, r)
    }
}

package main

import (
    "io/ioutil"
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"
)

// TestMyHandler 使用 httptest.NewRecorder 测试 myHandler 函数
func TestMyHandler(t *testing.T) {
    // 测试 /hello 路径
    t.Run("Test /hello path", func(t *testing.T) {
        req := httptest.NewRequest("GET", "/hello", nil) // 创建一个GET请求
        rr := httptest.NewRecorder()                     // 创建一个响应记录器

        myHandler(rr, req) // 直接调用被测试的处理器

        // 验证状态码
        if status := rr.Code; status != http.StatusOK {
            t.Errorf("handler returned wrong status code: got %v want %v",
                status, http.StatusOK)
        }

        // 验证响应体
        expected := "Hello, World!"
        if rr.Body.String() != expected {
            t.Errorf("handler returned unexpected body: got %v want %v",
                rr.Body.String(), expected)
        }
    })

    // 测试 /status 路径
    t.Run("Test /status path", func(t *testing.T) {
        req := httptest.NewRequest("GET", "/status", nil)
        rr := httptest.NewRecorder()

        myHandler(rr, req)

        if status := rr.Code; status != http.StatusOK {
            t.Errorf("handler returned wrong status code: got %v want %v",
                status, http.StatusOK)
        }
        if rr.Body.String() != "Service is running." {
            t.Errorf("handler returned unexpected body: got %v want %v",
                rr.Body.String(), "Service is running.")
        }
    })

    // 测试未知路径
    t.Run("Test unknown path", func(t *testing.T) {
        req := httptest.NewRequest("GET", "/unknown", nil)
        rr := httptest.NewRecorder()

        myHandler(rr, req)

        if status := rr.Code; status != http.StatusNotFound {
            t.Errorf("handler returned wrong status code: got %v want %v",
                status, http.StatusNotFound)
        }
        // 对于 NotFound 响应，通常会有一个默认的HTML体，我们检查是否包含特定字符串
        bodyBytes, _ := ioutil.ReadAll(rr.Body)
        if !strings.Contains(string(bodyBytes), "404 page not found") {
            t.Errorf("handler returned unexpected body for 404: got %v", string(bodyBytes))
        }
    })
}