How to set mock gin.Context for BindJSON

Question

I'm setting up testing in Go.

I use go-sqlmock to test mysql connection and Go Gin as framework. Now I try to test mysql insert logic.

The problem is I need to set mock gin.Context which is used for BindJSON later.
But I can't set this gin.Context so far.

server side: golang
db: mysql
web framework: gin

dao.go

unc PostImageToDBDao(c *gin.Context, db *sql.DB) {
        // Because of this logic, I need to set gin.Context with json
    var imageData util.ImageData
    c.BindJSON(&imageData)

    for _, imageName := range imageData.IMAGENAMES {
        ins, err := db.Prepare("INSERT INTO images(article_uuid, image_name) VALUES(?,?)")
        if err != nil {
            log.Fatal(err)
        }
        ins.Exec(imageData.ARTICLEUUID, imageName.NAME)
    }
}

dao_test.go

func TestPostImageToDBDao(t *testing.T) {
    db, mock, err := sqlmock.New()

    if err != nil {
        t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    }

    defer db.Close()

    prep := mock.ExpectPrepare("^INSERT INTO images*")

    prep.ExpectExec().
        WithArgs("bea1b24d-0627-4ea0-aa2b-8af4c6c2a41c", "b8119536-fad5-4ffa-ab71-2f96cca19697").
        WillReturnResult(sqlmock.NewResult(1, 1))

        // try to set context with json post
    req, _ := http.NewRequest("POST", "/post/image/db", bytes.NewBuffer([]byte(`[{
        "articleUUID": "bea1b24d-0627-4ea0-aa2b-8af4c6c2a41c",
        "imageNames": "b8119536-fad5-4ffa-ab71-2f96cca19697",
      }]`)))
    req.Header.Set("Content-Type", "application/json")
    var context *gin.Context
    context = &gin.Context{Request: req}

    PostImageToDBDao(context, db)

    if err := mock.ExpectationsWereMet(); err != nil {
        t.Errorf("there were unfulfilled expections: %s", err)
    }
}

I expect mock gin.Context to set properly and run go test -v without error, however it fails with the following error:

=== RUN   TestPostImageToDBDao
[GIN-debug] [WARNING] Headers were already written. Wanted to override status code 0 with 400
--- FAIL: TestPostImageToDBDao (0.00s)
panic: runtime error: invalid memory address or nil pointer dereference [recovered]
        panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x60 pc=0x15bde75]

goroutine 50 [running]:
testing.tRunner.func1(0xc000234100)
        /usr/local/go/src/testing/testing.go:830 +0x392
panic(0x16918e0, 0x1ce5850)
        /usr/local/go/src/runtime/panic.go:522 +0x1b5
github.com/gin-gonic/gin.(*Context).AbortWithStatus(0xc00026aee8, 0x190)
        /Users/jpskgc/go/pkg/mod/github.com/gin-gonic/[email protected]/context.go:146 +0x45
github.com/gin-gonic/gin.(*Context).AbortWithError(0xc0000d9ee8, 0x190, 0x1863e00, 0xc0002700a0, 0x1863e00)
        /Users/jpskgc/go/pkg/mod/github.com/gin-gonic/[email protected]/context.go:162 +0x39
github.com/gin-gonic/gin.(*Context).MustBindWith(0xc00026aee8, 0x16328e0, 0xc00022c180, 0x186e060, 0x1d16588, 0x1e316d0, 0x0)
        /Users/jpskgc/go/pkg/mod/github.com/gin-gonic/[email protected]/context.go:561 +0x92
github.com/gin-gonic/gin.(*Context).BindJSON(...)
        /Users/jpskgc/go/pkg/mod/github.com/gin-gonic/[email protected]/context.go:528
article/api/dao.PostImageToDBDao(0xc00026aee8, 0xc000276000)
        /Users/jpskgc/article/api/dao/dao.go:54 +0x87
article/api/dao.TestPostImageToDBDao(0xc000234100)
        /Users/jpskgc/article/api/dao/dao_test.go:204 +0x4b6
testing.tRunner(0xc000234100, 0x17897e0)
        /usr/local/go/src/testing/testing.go:865 +0xc0
created by testing.(*T).Run
        /usr/local/go/src/testing/testing.go:916 +0x35a
exit status 2
FAIL    article/api/dao 0.032s

Answer 1

First, you must instantiate a test *gin.Context and make sure its *http.Request is non-nil:

    w := httptest.NewRecorder()
    c, _ := gin.CreateTestContext(w) 

    c.Request = &http.Request{
        Header: make(http.Header),
    }

Then you can mock a POST json body in the following way:

func MockJsonPost(c *gin.Context /* the test context */, content interface{}) {
    c.Request.Method = "POST" // or PUT
    c.Request.Header.Set("Content-Type", "application/json")

    jsonbytes, err := json.Marshal(content)
    if err != nil {
        panic(err)
    }
    
    // the request body must be an io.ReadCloser
    // the bytes buffer though doesn't implement io.Closer,
    // so you wrap it in a no-op closer
    c.Request.Body = io.NopCloser(bytes.NewBuffer(jsonbytes))
}

where the function argument content interface{} is anything that can be marshalled into JSON with json.Marshal(), so in most cases a struct with the proper json tags, or a map[string]interface{}.

Example usage:

func TestMyHandler(t *testing.T) {
    w := httptest.NewRecorder()
    ctx, _ := gin.CreateTestContext(w) 

    ctx.Request = &http.Request{
        Header: make(http.Header),
    }


    MockJsonPost(ctx, map[string]interface{}{"foo": "bar"})
    
    MyHandler(ctx)
    assert.EqualValues(t, http.StatusOK, w.Code)
} 

Related:

• How to unit test a Go Gin handler function?