Menguji Go: Mocking Request.FormFile

Dalam proses menguji titik akhir web Go, seseorang mungkin menghadapi cabaran untuk mengejek http. Medan Request.FormFile. Medan ini mewakili fail yang dimuat naik dalam permintaan dan penting untuk menguji kefungsian titik akhir.

Untuk menangani perkara ini, seseorang mungkin mempertimbangkan untuk mengejek keseluruhan struktur http.Request.FormFile. Walau bagaimanapun, ini adalah langkah yang tidak perlu. Pakej mime/berbilang bahagian menawarkan pendekatan yang lebih cekap.

Pakej mime/berbilang bahagian menyediakan jenis Writer yang boleh menjana tika FormFile. Seperti yang dinyatakan dalam dokumentasi:

CreateFormFile is a convenience wrapper around CreatePart. It creates
a new form-data header with the provided field name and file name.

Fungsi CreateFormFile mengembalikan io.Writer yang boleh digunakan untuk membina medan FormFile. Io.Writer ini kemudiannya boleh dihantar sebagai hujah kepada httptest.NewRequest, yang menerima pembaca sebagai hujah.

Untuk melaksanakan teknik ini, seseorang boleh sama ada menulis FormFile ke penimbal io.ReaderWriter atau menggunakan io.Paip. Contoh berikut menunjukkan pendekatan yang terakhir:

<code class="go">import (
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "net/http/httptest"

    "github.com/codegangsta/multipart"
)

func TestUploadFile(t *testing.T) {
    // Create a pipe to avoid buffering
    pr, pw := io.Pipe()
    // Create a multipart writer to transform data into multipart form data
    writer := multipart.NewWriter(pw)

    go func() {
        defer writer.Close()
        // Create the form data field 'fileupload' with a file name
        part, err := writer.CreateFormFile("fileupload", "someimg.png")
        if err != nil {
            t.Errorf("failed to create FormFile: %v", err)
        }

        // Generate an image dynamically and encode it to the multipart writer
        img := createImage()
        err = png.Encode(part, img)
        if err != nil {
            t.Errorf("failed to encode image: %v", err)
        }
    }()

    // Create an HTTP request using the multipart writer and set the Content-Type header
    request := httptest.NewRequest("POST", "/", pr)
    request.Header.Add("Content-Type", writer.FormDataContentType())

    // Create a response recorder to capture the response
    response := httptest.NewRecorder()

    // Define the handler function to test
    handler := func(w http.ResponseWriter, r *http.Request) {
        // Parse the multipart form data
        if err := r.ParseMultipartForm(32 << 20); err != nil {
            http.Error(w, "failed to parse multipart form data", http.StatusBadRequest)
            return
        }

        // Read the uploaded file
        file, header, err := r.FormFile("fileupload")
        if err != nil {
            if err == http.ErrMissingFile {
                http.Error(w, "missing file", http.StatusBadRequest)
                return
            }
            http.Error(w, fmt.Sprintf("failed to read file: %v", err), http.StatusInternalServerError)
            return
        }
        defer file.Close()

        // Save the file to disk
        outFile, err := os.Create("./uploads/" + header.Filename)
        if err != nil {
            http.Error(w, fmt.Sprintf("failed to save file: %v", err), http.StatusInternalServerError)
            return
        }
        defer outFile.Close()

        if _, err := io.Copy(outFile, file); err != nil {
            http.Error(w, fmt.Sprintf("failed to copy file: %v", err), http.StatusInternalServerError)
            return
        }

        w.Write([]byte("ok"))
    }

    // Serve the request with the handler function
    handler.ServeHTTP(response, request)

    // Verify the response status code and file creation
    if response.Code != http.StatusOK {
        t.Errorf("incorrect HTTP status: %d", response.Code)
    }

    if _, err := os.Stat("./uploads/someimg.png"); os.IsNotExist(err) {
        t.Errorf("failed to create file: ./uploads/someimg.png")
    } else if body, err := ioutil.ReadAll(response.Body); err != nil {
        t.Errorf("failed to read response body: %v", err)
    } else if string(body) != "ok" {
        t.Errorf("incorrect response body: %s", body)
    }
}</code>

Contoh ini menyediakan aliran lengkap untuk menguji titik akhir yang mengendalikan muat naik fail, daripada menjana FormFile olok-olok kepada menegaskan kod status respons dan penciptaan fail. Dengan menggunakan pakej mime/berbilang bahagian dan paip, anda boleh mensimulasikan permintaan yang mengandungi fail yang dimuat naik dengan cekap dan menguji titik akhir anda dengan cekap.

Atas ialah kandungan terperinci Bagaimanakah saya boleh mengejek `http.Request.FormFile` dalam Go untuk menguji titik akhir web?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!