gorilla/mux提供了用于测试的SetURLVars函数，您可以使用该函数注入mock vars。

func TestGetRequest(t *testing.T) {
    r, _ := http.NewRequest("GET", "/test/abcd", nil)
    w := httptest.NewRecorder()

    //Hack to try to fake gorilla/mux vars
    vars := map[string]string{
        "mystring": "abcd",
    }

    // CHANGE THIS LINE!!!
    r = mux.SetURLVars(r, vars)
    
    GetRequest(w, r)

    assert.Equal(t, http.StatusOK, w.Code)
    assert.Equal(t, []byte("abcd"), w.Body.Bytes())
}

问题是，即使您使用0作为值来设置上下文值，它也不是mux.Vars()读取的值。mux.Vars()使用的是varsKey（正如您已经看到的），它的类型是contextKey，而不是int。
确定，contextKey定义为：

type contextKey int

这意味着它的底层对象是int，但是在Go语言中比较值时，type起作用，所以int(0) != contextKey(0)。
我看不出你如何能欺骗gorillamux或context返回你的值。
话虽如此，我想到了几种测试方法（注意下面的代码未经测试，我直接在这里输入，所以可能会有一些愚蠢的错误）：
1.正如有人建议的那样，运行一个服务器并向其发送HTTP请求。
1.在你的测试中使用gorilla mux Router而不是运行服务器。在这个场景中，你会有一个路由器，你传递给ListenAndServe，但是你也可以在测试中使用同一个路由器示例，并在它上面调用ServeHTTP。Router将负责设置上下文值，它们将在你的处理程序中可用。

func Router() *mux.Router {
    r := mux.Router()
    r.HandleFunc("/employees/{1}", GetRequest)
    (...)
    return r 
}

在main函数中，您可以执行如下操作：

http.Handle("/", Router())

在测试中，您可以：

func TestGetRequest(t *testing.T) {
    r := http.NewRequest("GET", "employees/1", nil)
    w := httptest.NewRecorder()

    Router().ServeHTTP(w, r)
    // assertions
}

1. Package 处理程序，使其接受URL参数作为第三个参数， Package 程序应调用mux.Vars()并将URL参数传递给处理程序
   使用此解决方案，您的处理程序将具有签名：

type VarsHandler func (w http.ResponseWriter, r *http.Request, vars map[string]string)

并且您必须调整对它的调用以符合http.Handler接口：

func (vh VarsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    vh(w, r, vars)
}

若要注册行程常式，请用途：

func GetRequest(w http.ResponseWriter, r *http.Request, vars map[string]string) {
    // process request using vars
}

mainRouter := mux.NewRouter().StrictSlash(true)
mainRouter.HandleFunc("/test/{mystring}", VarsHandler(GetRequest)).Name("/test/{mystring}").Methods("GET")

你用哪一个是个人喜好的问题。就我个人而言，我可能会选择2或3，略倾向于3。

在golang，我有稍微不同的测试方法。
我稍微重写了您的lib代码：

package main

import (
        "fmt"
        "net/http"

        "github.com/gorilla/mux"
)

func main() {
        startServer()
}

func startServer() {
        mainRouter := mux.NewRouter().StrictSlash(true)
        mainRouter.HandleFunc("/test/{mystring}", GetRequest).Name("/test/{mystring}").Methods("GET")
        http.Handle("/", mainRouter)

        err := http.ListenAndServe(":8080", mainRouter)
        if err != nil {
                fmt.Println("Something is wrong : " + err.Error())
        }
}

func GetRequest(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        myString := vars["mystring"]

        w.WriteHeader(http.StatusOK)
        w.Header().Set("Content-Type", "text/plain")
        w.Write([]byte(myString))
}

下面是对它的测试：

package main

import (
        "io/ioutil"
        "net/http"
        "testing"
        "time"

        "github.com/stretchr/testify/assert"
)

func TestGetRequest(t *testing.T) {
        go startServer()
        client := &http.Client{
                Timeout: 1 * time.Second,
        }

        r, _ := http.NewRequest("GET", "http://localhost:8080/test/abcd", nil)

        resp, err := client.Do(r)
        if err != nil {
                panic(err)
        }
        assert.Equal(t, http.StatusOK, resp.StatusCode)
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
                panic(err)
        }
        assert.Equal(t, []byte("abcd"), body)
}

我认为这是一个更好的方法-你真的是在测试你写的东西，因为它非常容易在go中启动/停止监听器！

我使用下面的helper函数从单元测试中调用处理程序：

func InvokeHandler(handler http.Handler, routePath string,
    w http.ResponseWriter, r *http.Request) {

    // Add a new sub-path for each invocation since
    // we cannot (easily) remove old handler
    invokeCount++
    router := mux.NewRouter()
    http.Handle(fmt.Sprintf("/%d", invokeCount), router)

    router.Path(routePath).Handler(handler)

    // Modify the request to add "/%d" to the request-URL
    r.URL.RawPath = fmt.Sprintf("/%d%s", invokeCount, r.URL.RawPath)
    router.ServeHTTP(w, r)
}

因为没有简单的方法来取消注册HTTP句柄，并且对同一个路由的http.Handle的多次调用将会失败。因此，该函数添加了一个新的路由（例如/1或/2）来确保路径是唯一的。在同一个进程中的多个单元测试中使用该函数时，这种魔法是必要的。
要测试GetRequest-函数：

func TestGetRequest(t *testing.T) {
    t.Parallel()

    r, _ := http.NewRequest("GET", "/test/abcd", nil)
    w := httptest.NewRecorder()

    InvokeHandler(http.HandlerFunc(GetRequest), "/test/{mystring}", w, r)

    assert.Equal(t, http.StatusOK, w.Code)
    assert.Equal(t, []byte("abcd"), w.Body.Bytes())
}

问题是你不能设置变量。

var r *http.Request
var key, value string

// runtime panic, map not initialized
mux.Vars(r)[key] = value

解决方案是在每次测试中创建一个新路由器。

// api/route.go

package api

import (
    "net/http"
    "github.com/gorilla/mux"
)

type Route struct {
    http.Handler
    Method string
    Path string
}

func (route *Route) Test(w http.ResponseWriter, r *http.Request) {
    m := mux.NewRouter()
    m.Handle(route.Path, route).Methods(route.Method)
    m.ServeHTTP(w, r)
}

在你的处理程序文件里。

// api/employees/show.go

package employees

import (
    "github.com/gorilla/mux"
)

func Show(db *sql.DB) *api.Route {
    h := func(w http.ResponseWriter, r http.Request) {
        username := mux.Vars(r)["username"]
        // .. etc ..
    }
    return &api.Route{
        Method: "GET",
        Path: "/employees/{username}",

        // Maybe apply middleware too, who knows.
        Handler: http.HandlerFunc(h),
    }
}

在你的测试中。

// api/employees/show_test.go

package employees

import (
    "testing"
)

func TestShow(t *testing.T) {
    w := httptest.NewRecorder()
    r, err := http.NewRequest("GET", "/employees/ajcodez", nil)
    Show(db).Test(w, r)
}

您可以在需要http.Handler的任何地方使用*api.Route。