diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7968520..de47c75 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,82 @@
# Gin ChangeLog
+## Gin v1.10.0
+
+### Features
+
+* feat(auth): add proxy-server authentication (#3877) (@EndlessParadox1)
+* feat(bind): ShouldBindBodyWith shortcut and change doc (#3871) (@RedCrazyGhost)
+* feat(binding): Support custom BindUnmarshaler for binding. (#3933) (@dkkb)
+* feat(binding): support override default binding implement (#3514) (@ssfyn)
+* feat(engine): Added `OptionFunc` and `With` (#3572) (@flc1125)
+* feat(logger): ability to skip logs based on user-defined logic (#3593) (@palvaneh)
+
+### Bug fixes
+
+* Revert "fix(uri): query binding bug (#3236)" (#3899) (@appleboy)
+* fix(binding): binding error while not upload file (#3819) (#3820) (@clearcodecn)
+* fix(binding): dereference pointer to struct (#3199) (@echovl)
+* fix(context): make context Value method adhere to Go standards (#3897) (@FarmerChillax)
+* fix(engine): fix unit test (#3878) (@flc1125)
+* fix(header): Allow header according to RFC 7231 (HTTP 405) (#3759) (@Crocmagnon)
+* fix(route): Add fullPath in context copy (#3784) (@KarthikReddyPuli)
+* fix(router): catch-all conflicting wildcard (#3812) (@FirePing32)
+* fix(sec): upgrade golang.org/x/crypto to 0.17.0 (#3832) (@chncaption)
+* fix(tree): correctly expand the capacity of params (#3502) (@georgijd-form3)
+* fix(uri): query binding bug (#3236) (@illiafox)
+* fix: Add pointer support for url query params (#3659) (#3666) (@omkar-foss)
+* fix: protect Context.Keys map when call Copy method (#3873) (@kingcanfish)
+
+### Enhancements
+
+* chore(CI): update release args (#3595) (@qloog)
+* chore(IP): add TrustedPlatform constant for Fly.io. (#3839) (@ab)
+* chore(debug): add ability to override the debugPrint statement (#2337) (@josegonzalez)
+* chore(deps): update dependencies to latest versions (#3835) (@appleboy)
+* chore(header): Add support for RFC 9512: application/yaml (#3851) (@vincentbernat)
+* chore(http): use white color for HTTP 1XX (#3741) (@viralparmarme)
+* chore(optimize): the ShouldBindUri method of the Context struct (#3911) (@1911860538)
+* chore(perf): Optimize the Copy method of the Context struct (#3859) (@1911860538)
+* chore(refactor): modify interface check way (#3855) (@demoManito)
+* chore(request): check reader if it's nil before reading (#3419) (@noahyao1024)
+* chore(security): upgrade Protobuf for CVE-2024-24786 (#3893) (@Fotkurz)
+* chore: refactor CI and update dependencies (#3848) (@appleboy)
+* chore: refactor configuration files for better readability (#3951) (@appleboy)
+* chore: update GitHub Actions configuration (#3792) (@appleboy)
+* chore: update changelog categories and improve documentation (#3917) (@appleboy)
+* chore: update dependencies to latest versions (#3694) (@appleboy)
+* chore: update external dependencies to latest versions (#3950) (@appleboy)
+* chore: update various Go dependencies to latest versions (#3901) (@appleboy)
+
+### Build process updates
+
+* build(codecov): Added a codecov configuration (#3891) (@flc1125)
+* ci(Makefile): vet command add .PHONY (#3915) (@imalasong)
+* ci(lint): update tooling and workflows for consistency (#3834) (@appleboy)
+* ci(release): refactor changelog regex patterns and exclusions (#3914) (@appleboy)
+* ci(testing): add go1.22 version (#3842) (@appleboy)
+
+### Documentation updates
+
+* docs(context): Added deprecation comments to BindWith (#3880) (@flc1125)
+* docs(middleware): comments to function `BasicAuthForProxy` (#3881) (@EndlessParadox1)
+* docs: Add document to constant `AuthProxyUserKey` and `BasicAuthForProxy`. (#3887) (@EndlessParadox1)
+* docs: fix typo in comment (#3868) (@testwill)
+* docs: fix typo in function documentation (#3872) (@TotomiEcio)
+* docs: remove redundant comments (#3765) (@WeiTheShinobi)
+* feat: update version constant to v1.10.0 (#3952) (@appleboy)
+
+### Others
+
+* Upgrade golang.org/x/net -> v0.13.0 (#3684) (@cpcf)
+* test(git): gitignore add develop tools (#3370) (@demoManito)
+* test(http): use constant instead of numeric literal (#3863) (@testwill)
+* test(path): Optimize unit test execution results (#3883) (@flc1125)
+* test(render): increased unit tests coverage (#3691) (@araujo88)
+
## Gin v1.9.1
-### BUG FIXES
+### BUG FIXES
* fix Request.Context() checks [#3512](https://github.com/gin-gonic/gin/pull/3512)
diff --git a/Makefile b/Makefile
index b58f24f..1a7de86 100644
--- a/Makefile
+++ b/Makefile
@@ -8,6 +8,7 @@ TESTFOLDER := $(shell $(GO) list ./... | grep -E 'gin$$|binding$$|render$$' | gr
TESTTAGS ?= ""
.PHONY: test
+# Run tests to verify code functionality.
test:
echo "mode: count" > coverage.out
for d in $(TESTFOLDER); do \
@@ -30,10 +31,12 @@ test:
done
.PHONY: fmt
+# Ensure consistent code formatting.
fmt:
$(GOFMT) -w $(GOFILES)
.PHONY: fmt-check
+# format (check only).
fmt-check:
@diff=$$($(GOFMT) -d $(GOFILES)); \
if [ -n "$$diff" ]; then \
@@ -43,31 +46,36 @@ fmt-check:
fi;
.PHONY: vet
+# Examine packages and report suspicious constructs if any.
vet:
$(GO) vet $(VETPACKAGES)
.PHONY: lint
+# Inspect source code for stylistic errors or potential bugs.
lint:
@hash golint > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
$(GO) get -u golang.org/x/lint/golint; \
fi
for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
-.PHONY: misspell-check
-misspell-check:
- @hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
- $(GO) get -u github.com/client9/misspell/cmd/misspell; \
- fi
- misspell -error $(GOFILES)
-
.PHONY: misspell
+# Correct commonly misspelled English words in source code.
misspell:
@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
$(GO) get -u github.com/client9/misspell/cmd/misspell; \
fi
misspell -w $(GOFILES)
+.PHONY: misspell-check
+# misspell (check only).
+misspell-check:
+ @hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+ $(GO) get -u github.com/client9/misspell/cmd/misspell; \
+ fi
+ misspell -error $(GOFILES)
+
.PHONY: tools
+# Install tools (golint and misspell).
tools:
@if [ $(GO_VERSION) -gt 15 ]; then \
$(GO) install golang.org/x/lint/golint@latest; \
@@ -76,3 +84,23 @@ tools:
$(GO) install golang.org/x/lint/golint; \
$(GO) install github.com/client9/misspell/cmd/misspell; \
fi
+
+.PHONY: help
+# Help.
+help:
+ @echo ''
+ @echo 'Usage:'
+ @echo ' make [target]'
+ @echo ''
+ @echo 'Targets:'
+ @awk '/^[a-zA-Z\-\0-9]+:/ { \
+ helpMessage = match(lastLine, /^# (.*)/); \
+ if (helpMessage) { \
+ helpCommand = substr($$1, 0, index($$1, ":")-1); \
+ helpMessage = substr(lastLine, RSTART + 2, RLENGTH); \
+ printf " - \033[36m%-20s\033[0m %s\n", helpCommand, helpMessage; \
+ } \
+ } \
+ { lastLine = $$0 }' $(MAKEFILE_LIST)
+
+.DEFAULT_GOAL := help
diff --git a/README.md b/README.md
index 5850ee9..0a081e4 100644
--- a/README.md
+++ b/README.md
@@ -1,46 +1,43 @@
# Gin Web Framework
-Gin is a web framework written in [Go](https://go.dev/). It features a martini-like API with performance that is up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
+Gin is a web framework written in [Go](https://go.dev/). It features a martini-like API with performance that is up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter).
+If you need performance and good productivity, you will love Gin.
-Copied from [gin-gonic/gin](https://github.com/gin-gonic/gin)
-
-**The key features of Gin are:**
+**Gin's key features are:**
- Zero allocation router
-- Fast
+- Speed
- Middleware support
- Crash-free
- JSON validation
-- Routes grouping
+- Route grouping
- Error management
-- Rendering built-in
-- Extendable
+- Built-in rendering
+- Extensible
## Getting started
### Prerequisites
-- **[Go](https://go.dev/)**: any one of the **three latest major** [releases](https://go.dev/doc/devel/release) (we test it with these).
+Gin requires [Go](https://go.dev/) version [1.21](https://go.dev/doc/devel/release#go1.21.0) or above.
### Getting Gin
-With [Go module](https://github.com/golang/go/wiki/Modules) support, simply add the following import
-
-```
-import "git.company.lan/gopkg/gin"
-```
-
-to your code, and then `go [build|run|test]` will automatically fetch the necessary dependencies.
-
-Otherwise, run the following Go command to install the `gin` package:
+With [Go's module support](https://go.dev/wiki/Modules#how-to-use-modules), `go [build|run|test]` automatically fetches the necessary dependencies when you add the import in your code:
```sh
-$ go get -u git.company.lan/gopkg/gin
+import "github.com/gin-gonic/gin"
+```
+
+Alternatively, use `go get`:
+
+```sh
+go get -u github.com/gin-gonic/gin
```
### Running Gin
-First you need to import Gin package for using Gin, one simplest example likes the follow `example.go`:
+A basic example:
```go
package main
@@ -62,28 +59,29 @@ func main() {
}
```
-And use the Go command to run the demo:
+To run the code, use the `go run` command, like:
-```
-# run example.go and visit 0.0.0.0:8080/ping on browser
+```sh
$ go run example.go
```
-### Learn more examples
+Then visit [`0.0.0.0:8080/ping`](http://0.0.0.0:8080/ping) in your browser to see the response!
+
+### See more examples
#### Quick Start
-Learn and practice more examples, please read the [Gin Quick Start](docs/doc.md) which includes API examples and builds tag.
+Learn and practice with the [Gin Quick Start](docs/doc.md), which includes API examples and builds tag.
#### Examples
-A number of ready-to-run examples demonstrating various use cases of Gin on the [Gin examples](https://github.com/gin-gonic/examples) repository.
+A number of ready-to-run examples demonstrating various use cases of Gin are available in the [Gin examples](https://github.com/gin-gonic/examples) repository.
## Documentation
-See [API documentation and descriptions](https://godoc.org/github.com/gin-gonic/gin) for package.
+See the [API documentation on go.dev](https://pkg.go.dev/github.com/gin-gonic/gin).
-All documentation is available on the Gin website.
+The documentation is also available on [gin-gonic.com](https://gin-gonic.com) in several languages:
- [English](https://gin-gonic.com/docs/)
- [简体中文](https://gin-gonic.com/zh-cn/docs/)
@@ -93,16 +91,15 @@ All documentation is available on the Gin website.
- [한국어](https://gin-gonic.com/ko-kr/docs/)
- [Turkish](https://gin-gonic.com/tr/docs/)
- [Persian](https://gin-gonic.com/fa/docs/)
+- [Português](https://gin-gonic.com/pt/docs/)
-### Articles about Gin
-
-A curated list of awesome Gin framework.
+### Articles
- [Tutorial: Developing a RESTful API with Go and Gin](https://go.dev/doc/tutorial/web-service-gin)
## Benchmarks
-Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter), [see all benchmarks details](/BENCHMARKS.md).
+Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter), [see all benchmarks](/BENCHMARKS.md).
| Benchmark name | (1) | (2) | (3) | (4) |
| ------------------------------ | --------: | --------------: | -----------: | --------------: |
@@ -142,23 +139,23 @@ Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httpr
- (3): Heap Memory (B/op), lower is better
- (4): Average Allocations per Repetition (allocs/op), lower is better
-## Middlewares
+## Middleware
You can find many useful Gin middlewares at [gin-contrib](https://git.company.lan/gopkg/gin-contrib).
-## Users
+## Uses
-Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framework.
+Here are some awesome projects that are using the [Gin](https://github.com/gin-gonic/gin) web framework.
-- [gorush](https://github.com/appleboy/gorush): A push notification server written in Go.
-- [fnproject](https://github.com/fnproject/fn): The container native, cloud agnostic serverless platform.
-- [photoprism](https://github.com/photoprism/photoprism): Personal photo management powered by Go and Google TensorFlow.
-- [lura](https://github.com/luraproject/lura): Ultra performant API Gateway with middlewares.
-- [picfit](https://github.com/thoas/picfit): An image resizing server written in Go.
+- [gorush](https://github.com/appleboy/gorush): A push notification server.
+- [fnproject](https://github.com/fnproject/fn): A container native, cloud agnostic serverless platform.
+- [photoprism](https://github.com/photoprism/photoprism): Personal photo management powered by Google TensorFlow.
+- [lura](https://github.com/luraproject/lura): Ultra performant API Gateway with middleware.
+- [picfit](https://github.com/thoas/picfit): An image resizing server.
- [dkron](https://github.com/distribworks/dkron): Distributed, fault tolerant job scheduling system.
## Contributing
Gin is the work of hundreds of contributors. We appreciate your help!
-Please see [CONTRIBUTING](CONTRIBUTING.md) for details on submitting patches and the contribution workflow.
+Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on submitting patches and the contribution workflow.
diff --git a/binding/binding.go b/binding/binding.go
index 9472387..702d0e8 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -84,6 +84,7 @@ var (
YAML BindingBody = yamlBinding{}
Uri BindingUri = uriBinding{}
Header Binding = headerBinding{}
+ Plain BindingBody = plainBinding{}
TOML BindingBody = tomlBinding{}
)
diff --git a/binding/binding_msgpack_test.go b/binding/binding_msgpack_test.go
index a6cd6aa..a811639 100644
--- a/binding/binding_msgpack_test.go
+++ b/binding/binding_msgpack_test.go
@@ -11,6 +11,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/ugorji/go/codec"
)
@@ -24,7 +25,7 @@ func TestBindingMsgPack(t *testing.T) {
buf := bytes.NewBuffer([]byte{})
assert.NotNil(t, buf)
err := codec.NewEncoder(buf, h).Encode(test)
- assert.NoError(t, err)
+ require.NoError(t, err)
data := buf.Bytes()
@@ -41,14 +42,14 @@ func testMsgPackBodyBinding(t *testing.T, b Binding, name, path, badPath, body,
req := requestWithBody("POST", path, body)
req.Header.Add("Content-Type", MIMEMSGPACK)
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "bar", obj.Foo)
obj = FooStruct{}
req = requestWithBody("POST", badPath, badBody)
req.Header.Add("Content-Type", MIMEMSGPACK)
err = MsgPack.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestBindingDefaultMsgPack(t *testing.T) {
diff --git a/binding/binding_nomsgpack.go b/binding/binding_nomsgpack.go
index 552a86b..c8e6131 100644
--- a/binding/binding_nomsgpack.go
+++ b/binding/binding_nomsgpack.go
@@ -81,6 +81,7 @@ var (
Uri = uriBinding{}
Header = headerBinding{}
TOML = tomlBinding{}
+ Plain = plainBinding{}
)
// Default returns the appropriate Binding instance based on the HTTP method
diff --git a/binding/binding_test.go b/binding/binding_test.go
index 1d2bf3f..039e63d 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -20,6 +20,7 @@ import (
"git.company.lan/gopkg/gin/testdata/protoexample"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"google.golang.org/protobuf/proto"
)
@@ -175,7 +176,7 @@ func TestBindingJSONNilBody(t *testing.T) {
var obj FooStruct
req, _ := http.NewRequest(http.MethodPost, "/", nil)
err := JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestBindingJSON(t *testing.T) {
@@ -376,7 +377,7 @@ func TestBindingFormStringSliceMap(t *testing.T) {
req := requestWithBody("POST", "/", "foo=something&foo=bar&hello=world")
req.Header.Add("Content-Type", MIMEPOSTForm)
err := Form.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, obj)
assert.Len(t, obj, 2)
target := map[string][]string{
@@ -389,7 +390,7 @@ func TestBindingFormStringSliceMap(t *testing.T) {
req = requestWithBody("POST", "/", "foo=something&foo=bar&hello=world")
req.Header.Add("Content-Type", MIMEPOSTForm)
err = Form.Bind(req, &objInvalid)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestBindingQuery(t *testing.T) {
@@ -428,7 +429,7 @@ func TestBindingQueryStringMap(t *testing.T) {
obj := make(map[string]string)
req := requestWithBody("GET", "/?foo=bar&hello=world", "")
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, obj)
assert.Len(t, obj, 2)
assert.Equal(t, "bar", obj["foo"])
@@ -437,7 +438,7 @@ func TestBindingQueryStringMap(t *testing.T) {
obj = make(map[string]string)
req = requestWithBody("GET", "/?foo=bar&foo=2&hello=world", "") // should pick last
err = b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, obj)
assert.Len(t, obj, 2)
assert.Equal(t, "2", obj["foo"])
@@ -495,28 +496,28 @@ func TestBindingYAMLFail(t *testing.T) {
func createFormPostRequest(t *testing.T) *http.Request {
req, err := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar&bar=foo"))
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEPOSTForm)
return req
}
func createDefaultFormPostRequest(t *testing.T) *http.Request {
req, err := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar"))
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEPOSTForm)
return req
}
func createFormPostRequestForMap(t *testing.T) *http.Request {
req, err := http.NewRequest("POST", "/?map_foo=getfoo", bytes.NewBufferString("map_foo={\"bar\":123}"))
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEPOSTForm)
return req
}
func createFormPostRequestForMapFail(t *testing.T) *http.Request {
req, err := http.NewRequest("POST", "/?map_foo=getfoo", bytes.NewBufferString("map_foo=hello"))
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEPOSTForm)
return req
}
@@ -527,20 +528,20 @@ func createFormFilesMultipartRequest(t *testing.T) *http.Request {
mw := multipart.NewWriter(body)
defer mw.Close()
- assert.NoError(t, mw.SetBoundary(boundary))
- assert.NoError(t, mw.WriteField("foo", "bar"))
- assert.NoError(t, mw.WriteField("bar", "foo"))
+ require.NoError(t, mw.SetBoundary(boundary))
+ require.NoError(t, mw.WriteField("foo", "bar"))
+ require.NoError(t, mw.WriteField("bar", "foo"))
f, err := os.Open("form.go")
- assert.NoError(t, err)
+ require.NoError(t, err)
defer f.Close()
fw, err1 := mw.CreateFormFile("file", "form.go")
- assert.NoError(t, err1)
+ require.NoError(t, err1)
_, err = io.Copy(fw, f)
- assert.NoError(t, err)
+ require.NoError(t, err)
req, err2 := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", body)
- assert.NoError(t, err2)
+ require.NoError(t, err2)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
return req
@@ -552,20 +553,20 @@ func createFormFilesMultipartRequestFail(t *testing.T) *http.Request {
mw := multipart.NewWriter(body)
defer mw.Close()
- assert.NoError(t, mw.SetBoundary(boundary))
- assert.NoError(t, mw.WriteField("foo", "bar"))
- assert.NoError(t, mw.WriteField("bar", "foo"))
+ require.NoError(t, mw.SetBoundary(boundary))
+ require.NoError(t, mw.WriteField("foo", "bar"))
+ require.NoError(t, mw.WriteField("bar", "foo"))
f, err := os.Open("form.go")
- assert.NoError(t, err)
+ require.NoError(t, err)
defer f.Close()
fw, err1 := mw.CreateFormFile("file_foo", "form_foo.go")
- assert.NoError(t, err1)
+ require.NoError(t, err1)
_, err = io.Copy(fw, f)
- assert.NoError(t, err)
+ require.NoError(t, err)
req, err2 := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", body)
- assert.NoError(t, err2)
+ require.NoError(t, err2)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
return req
@@ -577,11 +578,11 @@ func createFormMultipartRequest(t *testing.T) *http.Request {
mw := multipart.NewWriter(body)
defer mw.Close()
- assert.NoError(t, mw.SetBoundary(boundary))
- assert.NoError(t, mw.WriteField("foo", "bar"))
- assert.NoError(t, mw.WriteField("bar", "foo"))
+ require.NoError(t, mw.SetBoundary(boundary))
+ require.NoError(t, mw.WriteField("foo", "bar"))
+ require.NoError(t, mw.WriteField("bar", "foo"))
req, err := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", body)
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
return req
}
@@ -592,10 +593,10 @@ func createFormMultipartRequestForMap(t *testing.T) *http.Request {
mw := multipart.NewWriter(body)
defer mw.Close()
- assert.NoError(t, mw.SetBoundary(boundary))
- assert.NoError(t, mw.WriteField("map_foo", "{\"bar\":123, \"name\":\"thinkerou\", \"pai\": 3.14}"))
+ require.NoError(t, mw.SetBoundary(boundary))
+ require.NoError(t, mw.WriteField("map_foo", "{\"bar\":123, \"name\":\"thinkerou\", \"pai\": 3.14}"))
req, err := http.NewRequest("POST", "/?map_foo=getfoo", body)
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
return req
}
@@ -606,10 +607,10 @@ func createFormMultipartRequestForMapFail(t *testing.T) *http.Request {
mw := multipart.NewWriter(body)
defer mw.Close()
- assert.NoError(t, mw.SetBoundary(boundary))
- assert.NoError(t, mw.WriteField("map_foo", "3.14"))
+ require.NoError(t, mw.SetBoundary(boundary))
+ require.NoError(t, mw.WriteField("map_foo", "3.14"))
req, err := http.NewRequest("POST", "/?map_foo=getfoo", body)
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
return req
}
@@ -617,7 +618,7 @@ func createFormMultipartRequestForMapFail(t *testing.T) *http.Request {
func TestBindingFormPost(t *testing.T) {
req := createFormPostRequest(t)
var obj FooBarStruct
- assert.NoError(t, FormPost.Bind(req, &obj))
+ require.NoError(t, FormPost.Bind(req, &obj))
assert.Equal(t, "form-urlencoded", FormPost.Name())
assert.Equal(t, "bar", obj.Foo)
@@ -627,7 +628,7 @@ func TestBindingFormPost(t *testing.T) {
func TestBindingDefaultValueFormPost(t *testing.T) {
req := createDefaultFormPostRequest(t)
var obj FooDefaultBarStruct
- assert.NoError(t, FormPost.Bind(req, &obj))
+ require.NoError(t, FormPost.Bind(req, &obj))
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, "hello", obj.Bar)
@@ -637,22 +638,22 @@ func TestBindingFormPostForMap(t *testing.T) {
req := createFormPostRequestForMap(t)
var obj FooStructForMapType
err := FormPost.Bind(req, &obj)
- assert.NoError(t, err)
- assert.Equal(t, float64(123), obj.MapFoo["bar"].(float64))
+ require.NoError(t, err)
+ assert.InDelta(t, float64(123), obj.MapFoo["bar"].(float64), 0.01)
}
func TestBindingFormPostForMapFail(t *testing.T) {
req := createFormPostRequestForMapFail(t)
var obj FooStructForMapType
err := FormPost.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestBindingFormFilesMultipart(t *testing.T) {
req := createFormFilesMultipartRequest(t)
var obj FooBarFileStruct
err := FormMultipart.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
// file from os
f, _ := os.Open("form.go")
@@ -664,9 +665,9 @@ func TestBindingFormFilesMultipart(t *testing.T) {
defer mf.Close()
fileExpect, _ := io.ReadAll(mf)
- assert.Equal(t, FormMultipart.Name(), "multipart/form-data")
- assert.Equal(t, obj.Foo, "bar")
- assert.Equal(t, obj.Bar, "foo")
+ assert.Equal(t, "multipart/form-data", FormMultipart.Name())
+ assert.Equal(t, "bar", obj.Foo)
+ assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, fileExpect, fileActual)
}
@@ -674,13 +675,13 @@ func TestBindingFormFilesMultipartFail(t *testing.T) {
req := createFormFilesMultipartRequestFail(t)
var obj FooBarFileFailStruct
err := FormMultipart.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestBindingFormMultipart(t *testing.T) {
req := createFormMultipartRequest(t)
var obj FooBarStruct
- assert.NoError(t, FormMultipart.Bind(req, &obj))
+ require.NoError(t, FormMultipart.Bind(req, &obj))
assert.Equal(t, "multipart/form-data", FormMultipart.Name())
assert.Equal(t, "bar", obj.Foo)
@@ -691,17 +692,17 @@ func TestBindingFormMultipartForMap(t *testing.T) {
req := createFormMultipartRequestForMap(t)
var obj FooStructForMapType
err := FormMultipart.Bind(req, &obj)
- assert.NoError(t, err)
- assert.Equal(t, float64(123), obj.MapFoo["bar"].(float64))
+ require.NoError(t, err)
+ assert.InDelta(t, float64(123), obj.MapFoo["bar"].(float64), 0.01)
assert.Equal(t, "thinkerou", obj.MapFoo["name"].(string))
- assert.Equal(t, float64(3.14), obj.MapFoo["pai"].(float64))
+ assert.InDelta(t, float64(3.14), obj.MapFoo["pai"].(float64), 0.01)
}
func TestBindingFormMultipartForMapFail(t *testing.T) {
req := createFormMultipartRequestForMapFail(t)
var obj FooStructForMapType
err := FormMultipart.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestBindingProtoBuf(t *testing.T) {
@@ -732,7 +733,7 @@ func TestValidationFails(t *testing.T) {
var obj FooStruct
req := requestWithBody("POST", "/", `{"bar": "foo"}`)
err := JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestValidationDisabled(t *testing.T) {
@@ -743,7 +744,7 @@ func TestValidationDisabled(t *testing.T) {
var obj FooStruct
req := requestWithBody("POST", "/", `{"bar": "foo"}`)
err := JSON.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
}
func TestRequiredSucceeds(t *testing.T) {
@@ -754,7 +755,7 @@ func TestRequiredSucceeds(t *testing.T) {
var obj HogeStruct
req := requestWithBody("POST", "/", `{"hoge": 0}`)
err := JSON.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
}
func TestRequiredFails(t *testing.T) {
@@ -765,7 +766,7 @@ func TestRequiredFails(t *testing.T) {
var obj HogeStruct
req := requestWithBody("POST", "/", `{"boen": 0}`)
err := JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestHeaderBinding(t *testing.T) {
@@ -779,7 +780,7 @@ func TestHeaderBinding(t *testing.T) {
var theader tHeader
req := requestWithBody("GET", "/", "")
req.Header.Add("limit", "1000")
- assert.NoError(t, h.Bind(req, &theader))
+ require.NoError(t, h.Bind(req, &theader))
assert.Equal(t, 1000, theader.Limit)
req = requestWithBody("GET", "/", "")
@@ -790,7 +791,7 @@ func TestHeaderBinding(t *testing.T) {
}
err := h.Bind(req, &failStruct{})
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestUriBinding(t *testing.T) {
@@ -803,14 +804,14 @@ func TestUriBinding(t *testing.T) {
var tag Tag
m := make(map[string][]string)
m["name"] = []string{"thinkerou"}
- assert.NoError(t, b.BindUri(m, &tag))
+ require.NoError(t, b.BindUri(m, &tag))
assert.Equal(t, "thinkerou", tag.Name)
type NotSupportStruct struct {
Name map[string]any `uri:"name"`
}
var not NotSupportStruct
- assert.Error(t, b.BindUri(m, ¬))
+ require.Error(t, b.BindUri(m, ¬))
assert.Equal(t, map[string]any(nil), not.Name)
}
@@ -831,9 +832,9 @@ func TestUriInnerBinding(t *testing.T) {
}
var tag Tag
- assert.NoError(t, Uri.BindUri(m, &tag))
- assert.Equal(t, tag.Name, expectedName)
- assert.Equal(t, tag.S.Age, expectedAge)
+ require.NoError(t, Uri.BindUri(m, &tag))
+ assert.Equal(t, expectedName, tag.Name)
+ assert.Equal(t, expectedAge, tag.S.Age)
}
func testFormBindingEmbeddedStruct(t *testing.T, method, path, badPath, body, badBody string) {
@@ -846,7 +847,7 @@ func testFormBindingEmbeddedStruct(t *testing.T, method, path, badPath, body, ba
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 1, obj.Page)
assert.Equal(t, 2, obj.Size)
assert.Equal(t, "test-appkey", obj.Appkey)
@@ -862,14 +863,14 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, "foo", obj.Bar)
obj = FooBarStruct{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badBody string) {
@@ -882,14 +883,14 @@ func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badB
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, "hello", obj.Bar)
obj = FooDefaultBarStruct{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestFormBindingFail(t *testing.T) {
@@ -899,18 +900,18 @@ func TestFormBindingFail(t *testing.T) {
obj := FooBarStruct{}
req, _ := http.NewRequest("POST", "/", nil)
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestFormBindingMultipartFail(t *testing.T) {
obj := FooBarStruct{}
req, err := http.NewRequest("POST", "/", strings.NewReader("foo=bar"))
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+";boundary=testboundary")
_, err = req.MultipartReader()
- assert.NoError(t, err)
+ require.NoError(t, err)
err = Form.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestFormPostBindingFail(t *testing.T) {
@@ -920,7 +921,7 @@ func TestFormPostBindingFail(t *testing.T) {
obj := FooBarStruct{}
req, _ := http.NewRequest("POST", "/", nil)
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestFormMultipartBindingFail(t *testing.T) {
@@ -930,7 +931,7 @@ func TestFormMultipartBindingFail(t *testing.T) {
obj := FooBarStruct{}
req, _ := http.NewRequest("POST", "/", nil)
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody string) {
@@ -944,7 +945,7 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, int64(1510675200), obj.TimeFoo.Unix())
assert.Equal(t, "Asia/Chongqing", obj.TimeFoo.Location().String())
assert.Equal(t, int64(-62135596800), obj.TimeBar.Unix())
@@ -955,7 +956,7 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
obj = FooBarStructForTimeType{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingForTimeNotUnixFormat(t *testing.T, method, path, badPath, body, badBody string) {
@@ -968,12 +969,12 @@ func testFormBindingForTimeNotUnixFormat(t *testing.T, method, path, badPath, bo
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
obj = FooStructForTimeTypeNotUnixFormat{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body, badBody string) {
@@ -986,12 +987,12 @@ func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body,
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
obj = FooStructForTimeTypeNotFormat{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body, badBody string) {
@@ -1004,12 +1005,12 @@ func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body,
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
obj = FooStructForTimeTypeFailFormat{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, body, badBody string) {
@@ -1022,12 +1023,12 @@ func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, bod
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
obj = FooStructForTimeTypeFailLocation{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingIgnoreField(t *testing.T, method, path, badPath, body, badBody string) {
@@ -1040,7 +1041,7 @@ func testFormBindingIgnoreField(t *testing.T, method, path, badPath, body, badBo
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Nil(t, obj.Foo)
}
@@ -1055,13 +1056,13 @@ func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBo
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "", obj.TestName)
obj = InvalidNameType{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badBody string) {
@@ -1074,12 +1075,12 @@ func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badB
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
obj = InvalidNameMapType{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody string, typ string) {
@@ -1094,17 +1095,17 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
case "Slice":
obj := FooStructForSliceType{}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, []int{1, 2}, obj.SliceFoo)
obj = FooStructForSliceType{}
req = requestWithBody(method, badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
case "Struct":
obj := FooStructForStructType{}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t,
struct {
Idx int "form:\"idx\""
@@ -1113,7 +1114,7 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
case "StructPointer":
obj := FooStructForStructPointerType{}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t,
struct {
Name string "form:\"name\""
@@ -1122,33 +1123,33 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
case "Map":
obj := FooStructForMapType{}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
- assert.Equal(t, float64(123), obj.MapFoo["bar"].(float64))
+ require.NoError(t, err)
+ assert.InDelta(t, float64(123), obj.MapFoo["bar"].(float64), 0.01)
case "SliceMap":
obj := FooStructForSliceMapType{}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
case "Ptr":
obj := FooStructForStringPtrType{}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Nil(t, obj.PtrFoo)
assert.Equal(t, "test", *obj.PtrBar)
obj = FooStructForStringPtrType{}
obj.PtrBar = new(string)
err = b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "test", *obj.PtrBar)
objErr := FooStructForMapPtrType{}
err = b.Bind(req, &objErr)
- assert.Error(t, err)
+ require.Error(t, err)
obj = FooStructForStringPtrType{}
req = requestWithBody(method, badPath, badBody)
err = b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
}
@@ -1162,7 +1163,7 @@ func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string)
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, "foo", obj.Bar)
}
@@ -1177,7 +1178,7 @@ func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody str
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testQueryBindingBoolFail(t *testing.T, method, path, badPath, body, badBody string) {
@@ -1190,7 +1191,7 @@ func testQueryBindingBoolFail(t *testing.T, method, path, badPath, body, badBody
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
@@ -1199,13 +1200,13 @@ func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody
obj := FooStruct{}
req := requestWithBody("POST", path, body)
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "bar", obj.Foo)
obj = FooStruct{}
req = requestWithBody("POST", badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testBodyBindingSlice(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
@@ -1214,12 +1215,12 @@ func testBodyBindingSlice(t *testing.T, b Binding, name, path, badPath, body, ba
var obj1 []FooStruct
req := requestWithBody("POST", path, body)
err := b.Bind(req, &obj1)
- assert.NoError(t, err)
+ require.NoError(t, err)
var obj2 []FooStruct
req = requestWithBody("POST", badPath, badBody)
err = JSON.Bind(req, &obj2)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testBodyBindingStringMap(t *testing.T, b Binding, path, badPath, body, badBody string) {
@@ -1229,7 +1230,7 @@ func testBodyBindingStringMap(t *testing.T, b Binding, path, badPath, body, badB
req.Header.Add("Content-Type", MIMEPOSTForm)
}
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, obj)
assert.Len(t, obj, 2)
assert.Equal(t, "bar", obj["foo"])
@@ -1239,13 +1240,13 @@ func testBodyBindingStringMap(t *testing.T, b Binding, path, badPath, body, badB
obj = make(map[string]string)
req = requestWithBody("POST", badPath, badBody)
err = b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
objInt := make(map[string]int)
req = requestWithBody("POST", path, body)
err = b.Bind(req, &objInt)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
@@ -1255,16 +1256,16 @@ func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body
req := requestWithBody("POST", path, body)
EnableDecoderUseNumber = true
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
// we hope it is int64(123)
v, e := obj.Foo.(json.Number).Int64()
- assert.NoError(t, e)
+ require.NoError(t, e)
assert.Equal(t, int64(123), v)
obj = FooStructUseNumber{}
req = requestWithBody("POST", badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
@@ -1274,15 +1275,15 @@ func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, bod
req := requestWithBody("POST", path, body)
EnableDecoderUseNumber = false
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
// it will return float64(123) if not use EnableDecoderUseNumber
// maybe it is not hoped
- assert.Equal(t, float64(123), obj.Foo)
+ assert.InDelta(t, float64(123), obj.Foo, 0.01)
obj = FooStructUseNumber{}
req = requestWithBody("POST", badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testBodyBindingDisallowUnknownFields(t *testing.T, b Binding, path, badPath, body, badBody string) {
@@ -1294,13 +1295,13 @@ func testBodyBindingDisallowUnknownFields(t *testing.T, b Binding, path, badPath
obj := FooStructDisallowUnknownFields{}
req := requestWithBody("POST", path, body)
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "bar", obj.Foo)
obj = FooStructDisallowUnknownFields{}
req = requestWithBody("POST", badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
assert.Contains(t, err.Error(), "what")
}
@@ -1310,13 +1311,13 @@ func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, bad
obj := FooStruct{}
req := requestWithBody("POST", path, body)
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
assert.Equal(t, "", obj.Foo)
obj = FooStruct{}
req = requestWithBody("POST", badPath, badBody)
err = JSON.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
@@ -1326,14 +1327,14 @@ func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, ba
req := requestWithBody("POST", path, body)
req.Header.Add("Content-Type", MIMEPROTOBUF)
err := b.Bind(req, &obj)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "yes", *obj.Label)
obj = protoexample.Test{}
req = requestWithBody("POST", badPath, badBody)
req.Header.Add("Content-Type", MIMEPROTOBUF)
err = ProtoBuf.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
type hook struct{}
@@ -1342,6 +1343,46 @@ func (h hook) Read([]byte) (int, error) {
return 0, errors.New("error")
}
+type failRead struct{}
+
+func (f *failRead) Read(b []byte) (n int, err error) {
+ return 0, errors.New("my fail")
+}
+
+func (f *failRead) Close() error {
+ return nil
+}
+
+func TestPlainBinding(t *testing.T) {
+ p := Plain
+ assert.Equal(t, "plain", p.Name())
+
+ var s string
+ req := requestWithBody("POST", "/", "test string")
+ require.NoError(t, p.Bind(req, &s))
+ assert.Equal(t, "test string", s)
+
+ var bs []byte
+ req = requestWithBody("POST", "/", "test []byte")
+ require.NoError(t, p.Bind(req, &bs))
+ assert.Equal(t, bs, []byte("test []byte"))
+
+ var i int
+ req = requestWithBody("POST", "/", "test fail")
+ require.Error(t, p.Bind(req, &i))
+
+ req = requestWithBody("POST", "/", "")
+ req.Body = &failRead{}
+ require.Error(t, p.Bind(req, &s))
+
+ req = requestWithBody("POST", "/", "")
+ require.NoError(t, p.Bind(req, nil))
+
+ var ptr *string
+ req = requestWithBody("POST", "/", "")
+ require.NoError(t, p.Bind(req, ptr))
+}
+
func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
assert.Equal(t, name, b.Name())
@@ -1351,20 +1392,20 @@ func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body
req.Body = io.NopCloser(&hook{})
req.Header.Add("Content-Type", MIMEPROTOBUF)
err := b.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
invalidobj := FooStruct{}
req.Body = io.NopCloser(strings.NewReader(`{"msg":"hello"}`))
req.Header.Add("Content-Type", MIMEPROTOBUF)
err = b.Bind(req, &invalidobj)
- assert.Error(t, err)
- assert.Equal(t, err.Error(), "obj is not ProtoMessage")
+ require.Error(t, err)
+ assert.Equal(t, "obj is not ProtoMessage", err.Error())
obj = protoexample.Test{}
req = requestWithBody("POST", badPath, badBody)
req.Header.Add("Content-Type", MIMEPROTOBUF)
err = ProtoBuf.Bind(req, &obj)
- assert.Error(t, err)
+ require.Error(t, err)
}
func requestWithBody(method, path, body string) (req *http.Request) {
diff --git a/binding/default_validator.go b/binding/default_validator.go
index ac43d7c..44b7a2a 100644
--- a/binding/default_validator.go
+++ b/binding/default_validator.go
@@ -5,8 +5,8 @@
package binding
import (
- "fmt"
"reflect"
+ "strconv"
"strings"
"sync"
@@ -22,25 +22,20 @@ type SliceValidationError []error
// Error concatenates all error elements in SliceValidationError into a single string separated by \n.
func (err SliceValidationError) Error() string {
- n := len(err)
- switch n {
- case 0:
+ if len(err) == 0 {
return ""
- default:
- var b strings.Builder
- if err[0] != nil {
- fmt.Fprintf(&b, "[%d]: %s", 0, err[0].Error())
- }
- if n > 1 {
- for i := 1; i < n; i++ {
- if err[i] != nil {
- b.WriteString("\n")
- fmt.Fprintf(&b, "[%d]: %s", i, err[i].Error())
- }
- }
- }
- return b.String()
}
+
+ var b strings.Builder
+ for i := 0; i < len(err); i++ {
+ if err[i] != nil {
+ if b.Len() > 0 {
+ b.WriteString("\n")
+ }
+ b.WriteString("[" + strconv.Itoa(i) + "]: " + err[i].Error())
+ }
+ }
+ return b.String()
}
var _ StructValidator = (*defaultValidator)(nil)
diff --git a/binding/default_validator_benchmark_test.go b/binding/default_validator_benchmark_test.go
index 9292e2a..4454741 100644
--- a/binding/default_validator_benchmark_test.go
+++ b/binding/default_validator_benchmark_test.go
@@ -12,11 +12,15 @@ import (
func BenchmarkSliceValidationError(b *testing.B) {
const size int = 100
+ e := make(SliceValidationError, size)
+ for j := 0; j < size; j++ {
+ e[j] = errors.New(strconv.Itoa(j))
+ }
+
+ b.ReportAllocs()
+ b.ResetTimer()
+
for i := 0; i < b.N; i++ {
- e := make(SliceValidationError, size)
- for j := 0; j < size; j++ {
- e[j] = errors.New(strconv.Itoa(j))
- }
if len(e.Error()) == 0 {
b.Errorf("error")
}
diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index 6c69755..417e005 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -159,6 +159,14 @@ func tryToSetValue(value reflect.Value, field reflect.StructField, setter setter
if k, v := head(opt, "="); k == "default" {
setOpt.isDefaultExists = true
setOpt.defaultValue = v
+
+ // convert semicolon-separated default values to csv-separated values for processing in setByForm
+ if field.Type.Kind() == reflect.Slice || field.Type.Kind() == reflect.Array {
+ cfTag := field.Tag.Get("collection_format")
+ if cfTag == "" || cfTag == "multi" || cfTag == "csv" {
+ setOpt.defaultValue = strings.ReplaceAll(v, ";", ",")
+ }
+ }
}
}
@@ -182,6 +190,38 @@ func trySetCustom(val string, value reflect.Value) (isSet bool, err error) {
return false, nil
}
+func trySplit(vs []string, field reflect.StructField) (newVs []string, err error) {
+ cfTag := field.Tag.Get("collection_format")
+ if cfTag == "" || cfTag == "multi" {
+ return vs, nil
+ }
+
+ var sep string
+ switch cfTag {
+ case "csv":
+ sep = ","
+ case "ssv":
+ sep = " "
+ case "tsv":
+ sep = "\t"
+ case "pipes":
+ sep = "|"
+ default:
+ return vs, fmt.Errorf("%s is not supported in the collection_format. (csv, ssv, pipes)", cfTag)
+ }
+
+ totalLength := 0
+ for _, v := range vs {
+ totalLength += strings.Count(v, sep) + 1
+ }
+ newVs = make([]string, 0, totalLength)
+ for _, v := range vs {
+ newVs = append(newVs, strings.Split(v, sep)...)
+ }
+
+ return newVs, nil
+}
+
func setByForm(value reflect.Value, field reflect.StructField, form map[string][]string, tagValue string, opt setOptions) (isSet bool, err error) {
vs, ok := form[tagValue]
if !ok && !opt.isDefaultExists {
@@ -192,15 +232,46 @@ func setByForm(value reflect.Value, field reflect.StructField, form map[string][
case reflect.Slice:
if !ok {
vs = []string{opt.defaultValue}
+
+ // pre-process the default value for multi if present
+ cfTag := field.Tag.Get("collection_format")
+ if cfTag == "" || cfTag == "multi" {
+ vs = strings.Split(opt.defaultValue, ",")
+ }
}
+
+ if ok, err = trySetCustom(vs[0], value); ok {
+ return ok, err
+ }
+
+ if vs, err = trySplit(vs, field); err != nil {
+ return false, err
+ }
+
return true, setSlice(vs, value, field)
case reflect.Array:
if !ok {
vs = []string{opt.defaultValue}
+
+ // pre-process the default value for multi if present
+ cfTag := field.Tag.Get("collection_format")
+ if cfTag == "" || cfTag == "multi" {
+ vs = strings.Split(opt.defaultValue, ",")
+ }
}
+
+ if ok, err = trySetCustom(vs[0], value); ok {
+ return ok, err
+ }
+
+ if vs, err = trySplit(vs, field); err != nil {
+ return false, err
+ }
+
if len(vs) != value.Len() {
return false, fmt.Errorf("%q is not valid value for %s", vs, value.Type().String())
}
+
return true, setArray(vs, value, field)
default:
var val string
@@ -210,6 +281,9 @@ func setByForm(value reflect.Value, field reflect.StructField, form map[string][
if len(vs) > 0 {
val = vs[0]
+ if val == "" {
+ val = opt.defaultValue
+ }
}
if ok, err := trySetCustom(val, value); ok {
return ok, err
@@ -397,11 +471,8 @@ func setTimeDuration(val string, value reflect.Value) error {
}
func head(str, sep string) (head string, tail string) {
- idx := strings.Index(str, sep)
- if idx < 0 {
- return str, ""
- }
- return str[:idx], str[idx+len(sep):]
+ head, tail, _ = strings.Cut(str, sep)
+ return head, tail
}
func setFormMap(ptr any, form map[string][]string) error {
diff --git a/binding/form_mapping_test.go b/binding/form_mapping_test.go
index ed01a08..810315b 100644
--- a/binding/form_mapping_test.go
+++ b/binding/form_mapping_test.go
@@ -5,6 +5,7 @@
package binding
import (
+ "encoding/hex"
"fmt"
"mime/multipart"
"reflect"
@@ -14,6 +15,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestMappingBaseTypes(t *testing.T) {
@@ -58,7 +60,7 @@ func TestMappingBaseTypes(t *testing.T) {
field := val.Elem().Type().Field(0)
_, err := mapping(val, emptyField, formSource{field.Name: {tt.form}}, "form")
- assert.NoError(t, err, testName)
+ require.NoError(t, err, testName)
actual := val.Elem().Field(0).Interface()
assert.Equal(t, tt.expect, actual, testName)
@@ -67,13 +69,15 @@ func TestMappingBaseTypes(t *testing.T) {
func TestMappingDefault(t *testing.T) {
var s struct {
+ Str string `form:",default=defaultVal"`
Int int `form:",default=9"`
Slice []int `form:",default=9"`
Array [1]int `form:",default=9"`
}
err := mappingByPtr(&s, formSource{}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
+ assert.Equal(t, "defaultVal", s.Str)
assert.Equal(t, 9, s.Int)
assert.Equal(t, []int{9}, s.Slice)
assert.Equal(t, [1]int{9}, s.Array)
@@ -84,7 +88,7 @@ func TestMappingSkipField(t *testing.T) {
A int
}
err := mappingByPtr(&s, formSource{}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 0, s.A)
}
@@ -95,7 +99,7 @@ func TestMappingIgnoreField(t *testing.T) {
B int `form:"-"`
}
err := mappingByPtr(&s, formSource{"A": {"9"}, "B": {"9"}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 9, s.A)
assert.Equal(t, 0, s.B)
@@ -107,7 +111,7 @@ func TestMappingUnexportedField(t *testing.T) {
b int `form:"b"`
}
err := mappingByPtr(&s, formSource{"a": {"9"}, "b": {"9"}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 9, s.A)
assert.Equal(t, 0, s.b)
@@ -118,7 +122,7 @@ func TestMappingPrivateField(t *testing.T) {
f int `form:"field"`
}
err := mappingByPtr(&s, formSource{"field": {"6"}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 0, s.f)
}
@@ -128,7 +132,7 @@ func TestMappingUnknownFieldType(t *testing.T) {
}
err := mappingByPtr(&s, formSource{"U": {"unknown"}}, "form")
- assert.Error(t, err)
+ require.Error(t, err)
assert.Equal(t, errUnknownType, err)
}
@@ -137,7 +141,7 @@ func TestMappingURI(t *testing.T) {
F int `uri:"field"`
}
err := mapURI(&s, map[string][]string{"field": {"6"}})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 6, s.F)
}
@@ -146,16 +150,34 @@ func TestMappingForm(t *testing.T) {
F int `form:"field"`
}
err := mapForm(&s, map[string][]string{"field": {"6"}})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 6, s.F)
}
+func TestMappingFormFieldNotSent(t *testing.T) {
+ var s struct {
+ F string `form:"field,default=defVal"`
+ }
+ err := mapForm(&s, map[string][]string{})
+ require.NoError(t, err)
+ assert.Equal(t, "defVal", s.F)
+}
+
+func TestMappingFormWithEmptyToDefault(t *testing.T) {
+ var s struct {
+ F string `form:"field,default=DefVal"`
+ }
+ err := mapForm(&s, map[string][]string{"field": {""}})
+ require.NoError(t, err)
+ assert.Equal(t, "DefVal", s.F)
+}
+
func TestMapFormWithTag(t *testing.T) {
var s struct {
F int `externalTag:"field"`
}
err := MapFormWithTag(&s, map[string][]string{"field": {"6"}}, "externalTag")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 6, s.F)
}
@@ -170,7 +192,7 @@ func TestMappingTime(t *testing.T) {
var err error
time.Local, err = time.LoadLocation("Europe/Berlin")
- assert.NoError(t, err)
+ require.NoError(t, err)
err = mapForm(&s, map[string][]string{
"Time": {"2019-01-20T16:02:58Z"},
@@ -179,7 +201,7 @@ func TestMappingTime(t *testing.T) {
"CSTTime": {"2019-01-20"},
"UTCTime": {"2019-01-20"},
})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "2019-01-20 16:02:58 +0000 UTC", s.Time.String())
assert.Equal(t, "2019-01-20 00:00:00 +0100 CET", s.LocalTime.String())
@@ -194,14 +216,14 @@ func TestMappingTime(t *testing.T) {
Time time.Time `time_location:"wrong"`
}
err = mapForm(&wrongLoc, map[string][]string{"Time": {"2019-01-20T16:02:58Z"}})
- assert.Error(t, err)
+ require.Error(t, err)
// wrong time value
var wrongTime struct {
Time time.Time
}
err = mapForm(&wrongTime, map[string][]string{"Time": {"wrong"}})
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestMappingTimeDuration(t *testing.T) {
@@ -211,12 +233,12 @@ func TestMappingTimeDuration(t *testing.T) {
// ok
err := mappingByPtr(&s, formSource{"D": {"5s"}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 5*time.Second, s.D)
// error
err = mappingByPtr(&s, formSource{"D": {"wrong"}}, "form")
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestMappingSlice(t *testing.T) {
@@ -226,17 +248,17 @@ func TestMappingSlice(t *testing.T) {
// default value
err := mappingByPtr(&s, formSource{}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, []int{9}, s.Slice)
// ok
err = mappingByPtr(&s, formSource{"slice": {"3", "4"}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, []int{3, 4}, s.Slice)
// error
err = mappingByPtr(&s, formSource{"slice": {"wrong"}}, "form")
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestMappingArray(t *testing.T) {
@@ -246,20 +268,125 @@ func TestMappingArray(t *testing.T) {
// wrong default
err := mappingByPtr(&s, formSource{}, "form")
- assert.Error(t, err)
+ require.Error(t, err)
// ok
err = mappingByPtr(&s, formSource{"array": {"3", "4"}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, [2]int{3, 4}, s.Array)
// error - not enough vals
err = mappingByPtr(&s, formSource{"array": {"3"}}, "form")
- assert.Error(t, err)
+ require.Error(t, err)
// error - wrong value
err = mappingByPtr(&s, formSource{"array": {"wrong"}}, "form")
- assert.Error(t, err)
+ require.Error(t, err)
+}
+
+func TestMappingCollectionFormat(t *testing.T) {
+ var s struct {
+ SliceMulti []int `form:"slice_multi" collection_format:"multi"`
+ SliceCsv []int `form:"slice_csv" collection_format:"csv"`
+ SliceSsv []int `form:"slice_ssv" collection_format:"ssv"`
+ SliceTsv []int `form:"slice_tsv" collection_format:"tsv"`
+ SlicePipes []int `form:"slice_pipes" collection_format:"pipes"`
+ ArrayMulti [2]int `form:"array_multi" collection_format:"multi"`
+ ArrayCsv [2]int `form:"array_csv" collection_format:"csv"`
+ ArraySsv [2]int `form:"array_ssv" collection_format:"ssv"`
+ ArrayTsv [2]int `form:"array_tsv" collection_format:"tsv"`
+ ArrayPipes [2]int `form:"array_pipes" collection_format:"pipes"`
+ }
+ err := mappingByPtr(&s, formSource{
+ "slice_multi": {"1", "2"},
+ "slice_csv": {"1,2"},
+ "slice_ssv": {"1 2"},
+ "slice_tsv": {"1 2"},
+ "slice_pipes": {"1|2"},
+ "array_multi": {"1", "2"},
+ "array_csv": {"1,2"},
+ "array_ssv": {"1 2"},
+ "array_tsv": {"1 2"},
+ "array_pipes": {"1|2"},
+ }, "form")
+ require.NoError(t, err)
+
+ assert.Equal(t, []int{1, 2}, s.SliceMulti)
+ assert.Equal(t, []int{1, 2}, s.SliceCsv)
+ assert.Equal(t, []int{1, 2}, s.SliceSsv)
+ assert.Equal(t, []int{1, 2}, s.SliceTsv)
+ assert.Equal(t, []int{1, 2}, s.SlicePipes)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayMulti)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayCsv)
+ assert.Equal(t, [2]int{1, 2}, s.ArraySsv)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayTsv)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayPipes)
+}
+
+func TestMappingCollectionFormatInvalid(t *testing.T) {
+ var s struct {
+ SliceCsv []int `form:"slice_csv" collection_format:"xxx"`
+ }
+ err := mappingByPtr(&s, formSource{
+ "slice_csv": {"1,2"},
+ }, "form")
+ require.Error(t, err)
+
+ var s2 struct {
+ ArrayCsv [2]int `form:"array_csv" collection_format:"xxx"`
+ }
+ err = mappingByPtr(&s2, formSource{
+ "array_csv": {"1,2"},
+ }, "form")
+ require.Error(t, err)
+}
+
+func TestMappingMultipleDefaultWithCollectionFormat(t *testing.T) {
+ var s struct {
+ SliceMulti []int `form:",default=1;2;3" collection_format:"multi"`
+ SliceCsv []int `form:",default=1;2;3" collection_format:"csv"`
+ SliceSsv []int `form:",default=1 2 3" collection_format:"ssv"`
+ SliceTsv []int `form:",default=1\t2\t3" collection_format:"tsv"`
+ SlicePipes []int `form:",default=1|2|3" collection_format:"pipes"`
+ ArrayMulti [2]int `form:",default=1;2" collection_format:"multi"`
+ ArrayCsv [2]int `form:",default=1;2" collection_format:"csv"`
+ ArraySsv [2]int `form:",default=1 2" collection_format:"ssv"`
+ ArrayTsv [2]int `form:",default=1\t2" collection_format:"tsv"`
+ ArrayPipes [2]int `form:",default=1|2" collection_format:"pipes"`
+ SliceStringMulti []string `form:",default=1;2;3" collection_format:"multi"`
+ SliceStringCsv []string `form:",default=1;2;3" collection_format:"csv"`
+ SliceStringSsv []string `form:",default=1 2 3" collection_format:"ssv"`
+ SliceStringTsv []string `form:",default=1\t2\t3" collection_format:"tsv"`
+ SliceStringPipes []string `form:",default=1|2|3" collection_format:"pipes"`
+ ArrayStringMulti [2]string `form:",default=1;2" collection_format:"multi"`
+ ArrayStringCsv [2]string `form:",default=1;2" collection_format:"csv"`
+ ArrayStringSsv [2]string `form:",default=1 2" collection_format:"ssv"`
+ ArrayStringTsv [2]string `form:",default=1\t2" collection_format:"tsv"`
+ ArrayStringPipes [2]string `form:",default=1|2" collection_format:"pipes"`
+ }
+ err := mappingByPtr(&s, formSource{}, "form")
+ require.NoError(t, err)
+
+ assert.Equal(t, []int{1, 2, 3}, s.SliceMulti)
+ assert.Equal(t, []int{1, 2, 3}, s.SliceCsv)
+ assert.Equal(t, []int{1, 2, 3}, s.SliceSsv)
+ assert.Equal(t, []int{1, 2, 3}, s.SliceTsv)
+ assert.Equal(t, []int{1, 2, 3}, s.SlicePipes)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayMulti)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayCsv)
+ assert.Equal(t, [2]int{1, 2}, s.ArraySsv)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayTsv)
+ assert.Equal(t, [2]int{1, 2}, s.ArrayPipes)
+ assert.Equal(t, []string{"1", "2", "3"}, s.SliceStringMulti)
+ assert.Equal(t, []string{"1", "2", "3"}, s.SliceStringCsv)
+ assert.Equal(t, []string{"1", "2", "3"}, s.SliceStringSsv)
+ assert.Equal(t, []string{"1", "2", "3"}, s.SliceStringTsv)
+ assert.Equal(t, []string{"1", "2", "3"}, s.SliceStringPipes)
+ assert.Equal(t, [2]string{"1", "2"}, s.ArrayStringMulti)
+ assert.Equal(t, [2]string{"1", "2"}, s.ArrayStringCsv)
+ assert.Equal(t, [2]string{"1", "2"}, s.ArrayStringSsv)
+ assert.Equal(t, [2]string{"1", "2"}, s.ArrayStringTsv)
+ assert.Equal(t, [2]string{"1", "2"}, s.ArrayStringPipes)
}
func TestMappingStructField(t *testing.T) {
@@ -270,7 +397,7 @@ func TestMappingStructField(t *testing.T) {
}
err := mappingByPtr(&s, formSource{"J": {`{"I": 9}`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 9, s.J.I)
}
@@ -288,20 +415,20 @@ func TestMappingPtrField(t *testing.T) {
// With 0 items.
var req0 ptrRequest
err = mappingByPtr(&req0, formSource{}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Empty(t, req0.Items)
// With 1 item.
var req1 ptrRequest
err = mappingByPtr(&req1, formSource{"items": {`{"key": 1}`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Len(t, req1.Items, 1)
assert.EqualValues(t, 1, req1.Items[0].Key)
// With 2 items.
var req2 ptrRequest
err = mappingByPtr(&req2, formSource{"items": {`{"key": 1}`, `{"key": 2}`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Len(t, req2.Items, 2)
assert.EqualValues(t, 1, req2.Items[0].Key)
assert.EqualValues(t, 2, req2.Items[1].Key)
@@ -313,7 +440,7 @@ func TestMappingMapField(t *testing.T) {
}
err := mappingByPtr(&s, formSource{"M": {`{"one": 1}`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, map[string]int{"one": 1}, s.M)
}
@@ -324,7 +451,7 @@ func TestMappingIgnoredCircularRef(t *testing.T) {
var s S
err := mappingByPtr(&s, formSource{}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
}
type customUnmarshalParamHex int
@@ -343,7 +470,7 @@ func TestMappingCustomUnmarshalParamHexWithFormTag(t *testing.T) {
Foo customUnmarshalParamHex `form:"foo"`
}
err := mappingByPtr(&s, formSource{"foo": {`f5`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.EqualValues(t, 245, s.Foo)
}
@@ -353,7 +480,7 @@ func TestMappingCustomUnmarshalParamHexWithURITag(t *testing.T) {
Foo customUnmarshalParamHex `uri:"foo"`
}
err := mappingByPtr(&s, formSource{"foo": {`f5`}}, "uri")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.EqualValues(t, 245, s.Foo)
}
@@ -380,7 +507,7 @@ func TestMappingCustomStructTypeWithFormTag(t *testing.T) {
FileData customUnmarshalParamType `form:"data"`
}
err := mappingByPtr(&s, formSource{"data": {`file:/foo:happiness`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.EqualValues(t, "file", s.FileData.Protocol)
assert.EqualValues(t, "/foo", s.FileData.Path)
@@ -392,7 +519,7 @@ func TestMappingCustomStructTypeWithURITag(t *testing.T) {
FileData customUnmarshalParamType `uri:"data"`
}
err := mappingByPtr(&s, formSource{"data": {`file:/foo:happiness`}}, "uri")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.EqualValues(t, "file", s.FileData.Protocol)
assert.EqualValues(t, "/foo", s.FileData.Path)
@@ -404,7 +531,7 @@ func TestMappingCustomPointerStructTypeWithFormTag(t *testing.T) {
FileData *customUnmarshalParamType `form:"data"`
}
err := mappingByPtr(&s, formSource{"data": {`file:/foo:happiness`}}, "form")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.EqualValues(t, "file", s.FileData.Protocol)
assert.EqualValues(t, "/foo", s.FileData.Path)
@@ -416,9 +543,95 @@ func TestMappingCustomPointerStructTypeWithURITag(t *testing.T) {
FileData *customUnmarshalParamType `uri:"data"`
}
err := mappingByPtr(&s, formSource{"data": {`file:/foo:happiness`}}, "uri")
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.EqualValues(t, "file", s.FileData.Protocol)
assert.EqualValues(t, "/foo", s.FileData.Path)
assert.EqualValues(t, "happiness", s.FileData.Name)
}
+
+type customPath []string
+
+func (p *customPath) UnmarshalParam(param string) error {
+ elems := strings.Split(param, "/")
+ n := len(elems)
+ if n < 2 {
+ return fmt.Errorf("invalid format")
+ }
+
+ *p = elems
+ return nil
+}
+
+func TestMappingCustomSliceUri(t *testing.T) {
+ var s struct {
+ FileData customPath `uri:"path"`
+ }
+ err := mappingByPtr(&s, formSource{"path": {`bar/foo`}}, "uri")
+ require.NoError(t, err)
+
+ assert.EqualValues(t, "bar", s.FileData[0])
+ assert.EqualValues(t, "foo", s.FileData[1])
+}
+
+func TestMappingCustomSliceForm(t *testing.T) {
+ var s struct {
+ FileData customPath `form:"path"`
+ }
+ err := mappingByPtr(&s, formSource{"path": {`bar/foo`}}, "form")
+ require.NoError(t, err)
+
+ assert.EqualValues(t, "bar", s.FileData[0])
+ assert.EqualValues(t, "foo", s.FileData[1])
+}
+
+type objectID [12]byte
+
+func (o *objectID) UnmarshalParam(param string) error {
+ oid, err := convertTo(param)
+ if err != nil {
+ return err
+ }
+
+ *o = oid
+ return nil
+}
+
+func convertTo(s string) (objectID, error) {
+ var nilObjectID objectID
+ if len(s) != 24 {
+ return nilObjectID, fmt.Errorf("invalid format")
+ }
+
+ var oid [12]byte
+ _, err := hex.Decode(oid[:], []byte(s))
+ if err != nil {
+ return nilObjectID, err
+ }
+
+ return oid, nil
+}
+
+func TestMappingCustomArrayUri(t *testing.T) {
+ var s struct {
+ FileData objectID `uri:"id"`
+ }
+ val := `664a062ac74a8ad104e0e80f`
+ err := mappingByPtr(&s, formSource{"id": {val}}, "uri")
+ require.NoError(t, err)
+
+ expected, _ := convertTo(val)
+ assert.EqualValues(t, expected, s.FileData)
+}
+
+func TestMappingCustomArrayForm(t *testing.T) {
+ var s struct {
+ FileData objectID `form:"id"`
+ }
+ val := `664a062ac74a8ad104e0e80f`
+ err := mappingByPtr(&s, formSource{"id": {val}}, "form")
+ require.NoError(t, err)
+
+ expected, _ := convertTo(val)
+ assert.EqualValues(t, expected, s.FileData)
+}
diff --git a/binding/multipart_form_mapping_test.go b/binding/multipart_form_mapping_test.go
index 4e97c0f..9782b81 100644
--- a/binding/multipart_form_mapping_test.go
+++ b/binding/multipart_form_mapping_test.go
@@ -12,6 +12,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestFormMultipartBindingBindOneFile(t *testing.T) {
@@ -27,7 +28,7 @@ func TestFormMultipartBindingBindOneFile(t *testing.T) {
req := createRequestMultipartFiles(t, file)
err := FormMultipart.Bind(req, &s)
- assert.NoError(t, err)
+ require.NoError(t, err)
assertMultipartFileHeader(t, &s.FileValue, file)
assertMultipartFileHeader(t, s.FilePtr, file)
@@ -53,7 +54,7 @@ func TestFormMultipartBindingBindTwoFiles(t *testing.T) {
req := createRequestMultipartFiles(t, files...)
err := FormMultipart.Bind(req, &s)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Len(t, s.SliceValues, len(files))
assert.Len(t, s.SlicePtrs, len(files))
@@ -90,7 +91,7 @@ func TestFormMultipartBindingBindError(t *testing.T) {
} {
req := createRequestMultipartFiles(t, files...)
err := FormMultipart.Bind(req, tt.s)
- assert.Error(t, err)
+ require.Error(t, err)
}
}
@@ -106,17 +107,17 @@ func createRequestMultipartFiles(t *testing.T, files ...testFile) *http.Request
mw := multipart.NewWriter(&body)
for _, file := range files {
fw, err := mw.CreateFormFile(file.Fieldname, file.Filename)
- assert.NoError(t, err)
+ require.NoError(t, err)
n, err := fw.Write(file.Content)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, len(file.Content), n)
}
err := mw.Close()
- assert.NoError(t, err)
+ require.NoError(t, err)
req, err := http.NewRequest("POST", "/", &body)
- assert.NoError(t, err)
+ require.NoError(t, err)
req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+mw.Boundary())
return req
@@ -127,12 +128,12 @@ func assertMultipartFileHeader(t *testing.T, fh *multipart.FileHeader, file test
assert.Equal(t, int64(len(file.Content)), fh.Size)
fl, err := fh.Open()
- assert.NoError(t, err)
+ require.NoError(t, err)
body, err := io.ReadAll(fl)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, string(file.Content), string(body))
err = fl.Close()
- assert.NoError(t, err)
+ require.NoError(t, err)
}
diff --git a/binding/plain.go b/binding/plain.go
new file mode 100644
index 0000000..f994319
--- /dev/null
+++ b/binding/plain.go
@@ -0,0 +1,56 @@
+package binding
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "reflect"
+
+ "git.company.lan/gopkg/gin/internal/bytesconv"
+)
+
+type plainBinding struct{}
+
+func (plainBinding) Name() string {
+ return "plain"
+}
+
+func (plainBinding) Bind(req *http.Request, obj interface{}) error {
+ all, err := io.ReadAll(req.Body)
+ if err != nil {
+ return err
+ }
+
+ return decodePlain(all, obj)
+}
+
+func (plainBinding) BindBody(body []byte, obj any) error {
+ return decodePlain(body, obj)
+}
+
+func decodePlain(data []byte, obj any) error {
+ if obj == nil {
+ return nil
+ }
+
+ v := reflect.ValueOf(obj)
+
+ for v.Kind() == reflect.Ptr {
+ if v.IsNil() {
+ return nil
+ }
+ v = v.Elem()
+ }
+
+ if v.Kind() == reflect.String {
+ v.SetString(bytesconv.BytesToString(data))
+ return nil
+ }
+
+ if _, ok := v.Interface().([]byte); ok {
+ v.SetBytes(data)
+ return nil
+ }
+
+ return fmt.Errorf("type (%T) unknown type", v)
+}
diff --git a/binding/validate_test.go b/binding/validate_test.go
index 1fc15ff..c9bbe60 100644
--- a/binding/validate_test.go
+++ b/binding/validate_test.go
@@ -11,6 +11,7 @@ import (
"github.com/go-playground/validator/v10"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
type testInterface interface {
@@ -113,10 +114,10 @@ func TestValidateNoValidationValues(t *testing.T) {
test := createNoValidationValues()
empty := structNoValidationValues{}
- assert.Nil(t, validate(test))
- assert.Nil(t, validate(&test))
- assert.Nil(t, validate(empty))
- assert.Nil(t, validate(&empty))
+ require.NoError(t, validate(test))
+ require.NoError(t, validate(&test))
+ require.NoError(t, validate(empty))
+ require.NoError(t, validate(&empty))
assert.Equal(t, origin, test)
}
@@ -163,8 +164,8 @@ func TestValidateNoValidationPointers(t *testing.T) {
//assert.Nil(t, validate(test))
//assert.Nil(t, validate(&test))
- assert.Nil(t, validate(empty))
- assert.Nil(t, validate(&empty))
+ require.NoError(t, validate(empty))
+ require.NoError(t, validate(&empty))
//assert.Equal(t, origin, test)
}
@@ -173,22 +174,22 @@ type Object map[string]any
func TestValidatePrimitives(t *testing.T) {
obj := Object{"foo": "bar", "bar": 1}
- assert.NoError(t, validate(obj))
- assert.NoError(t, validate(&obj))
+ require.NoError(t, validate(obj))
+ require.NoError(t, validate(&obj))
assert.Equal(t, Object{"foo": "bar", "bar": 1}, obj)
obj2 := []Object{{"foo": "bar", "bar": 1}, {"foo": "bar", "bar": 1}}
- assert.NoError(t, validate(obj2))
- assert.NoError(t, validate(&obj2))
+ require.NoError(t, validate(obj2))
+ require.NoError(t, validate(&obj2))
nu := 10
- assert.NoError(t, validate(nu))
- assert.NoError(t, validate(&nu))
+ require.NoError(t, validate(nu))
+ require.NoError(t, validate(&nu))
assert.Equal(t, 10, nu)
str := "value"
- assert.NoError(t, validate(str))
- assert.NoError(t, validate(&str))
+ require.NoError(t, validate(str))
+ require.NoError(t, validate(&str))
assert.Equal(t, "value", str)
}
@@ -212,8 +213,8 @@ func TestValidateAndModifyStruct(t *testing.T) {
s := structModifyValidation{Integer: 1}
errs := validate(&s)
- assert.Nil(t, errs)
- assert.Equal(t, s, structModifyValidation{Integer: 0})
+ require.NoError(t, errs)
+ assert.Equal(t, structModifyValidation{Integer: 0}, s)
}
// structCustomValidation is a helper struct we use to check that
@@ -239,14 +240,14 @@ func TestValidatorEngine(t *testing.T) {
err := engine.RegisterValidation("notone", notOne)
// Check that we can register custom validation without error
- assert.Nil(t, err)
+ require.NoError(t, err)
// Create an instance which will fail validation
withOne := structCustomValidation{Integer: 1}
errs := validate(withOne)
// Check that we got back non-nil errs
- assert.NotNil(t, errs)
+ require.Error(t, errs)
// Check that the error matches expectation
- assert.Error(t, errs, "", "", "notone")
+ require.Error(t, errs, "", "", "notone")
}
diff --git a/context.go b/context.go
index 704e6ff..ed960eb 100644
--- a/context.go
+++ b/context.go
@@ -34,6 +34,7 @@ const (
MIMEPOSTForm = binding.MIMEPOSTForm
MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
MIMEYAML = binding.MIMEYAML
+ MIMEYAML2 = binding.MIMEYAML2
MIMETOML = binding.MIMETOML
)
@@ -152,6 +153,9 @@ func (c *Context) HandlerName() string {
func (c *Context) HandlerNames() []string {
hn := make([]string, 0, len(c.handlers))
for _, val := range c.handlers {
+ if val == nil {
+ continue
+ }
hn = append(hn, nameOfFunction(val))
}
return hn
@@ -182,6 +186,9 @@ func (c *Context) FullPath() string {
func (c *Context) Next() {
c.index++
for c.index < int8(len(c.handlers)) {
+ if c.handlers[c.index] == nil {
+ continue
+ }
c.handlers[c.index](c)
c.index++
}
@@ -308,7 +315,31 @@ func (c *Context) GetInt(key string) (i int) {
return
}
-// GetInt64 returns the value associated with the key as an integer.
+// GetInt8 returns the value associated with the key as an integer 8.
+func (c *Context) GetInt8(key string) (i8 int8) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i8, _ = val.(int8)
+ }
+ return
+}
+
+// GetInt16 returns the value associated with the key as an integer 16.
+func (c *Context) GetInt16(key string) (i16 int16) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i16, _ = val.(int16)
+ }
+ return
+}
+
+// GetInt32 returns the value associated with the key as an integer 32.
+func (c *Context) GetInt32(key string) (i32 int32) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i32, _ = val.(int32)
+ }
+ return
+}
+
+// GetInt64 returns the value associated with the key as an integer 64.
func (c *Context) GetInt64(key string) (i64 int64) {
if val, ok := c.Get(key); ok && val != nil {
i64, _ = val.(int64)
@@ -324,7 +355,31 @@ func (c *Context) GetUint(key string) (ui uint) {
return
}
-// GetUint64 returns the value associated with the key as an unsigned integer.
+// GetUint8 returns the value associated with the key as an unsigned integer 8.
+func (c *Context) GetUint8(key string) (ui8 uint8) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui8, _ = val.(uint8)
+ }
+ return
+}
+
+// GetUint16 returns the value associated with the key as an unsigned integer 16.
+func (c *Context) GetUint16(key string) (ui16 uint16) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui16, _ = val.(uint16)
+ }
+ return
+}
+
+// GetUint32 returns the value associated with the key as an unsigned integer 32.
+func (c *Context) GetUint32(key string) (ui32 uint32) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui32, _ = val.(uint32)
+ }
+ return
+}
+
+// GetUint64 returns the value associated with the key as an unsigned integer 64.
func (c *Context) GetUint64(key string) (ui64 uint64) {
if val, ok := c.Get(key); ok && val != nil {
ui64, _ = val.(uint64)
@@ -332,6 +387,14 @@ func (c *Context) GetUint64(key string) (ui64 uint64) {
return
}
+// GetFloat32 returns the value associated with the key as a float32.
+func (c *Context) GetFloat32(key string) (f32 float32) {
+ if val, ok := c.Get(key); ok && val != nil {
+ f32, _ = val.(float32)
+ }
+ return
+}
+
// GetFloat64 returns the value associated with the key as a float64.
func (c *Context) GetFloat64(key string) (f64 float64) {
if val, ok := c.Get(key); ok && val != nil {
@@ -356,6 +419,90 @@ func (c *Context) GetDuration(key string) (d time.Duration) {
return
}
+func (c *Context) GetIntSlice(key string) (is []int) {
+ if val, ok := c.Get(key); ok && val != nil {
+ is, _ = val.([]int)
+ }
+ return
+}
+
+func (c *Context) GetInt8Slice(key string) (i8s []int8) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i8s, _ = val.([]int8)
+ }
+ return
+}
+
+func (c *Context) GetInt16Slice(key string) (i16s []int16) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i16s, _ = val.([]int16)
+ }
+ return
+}
+
+func (c *Context) GetInt32Slice(key string) (i32s []int32) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i32s, _ = val.([]int32)
+ }
+ return
+}
+
+func (c *Context) GetInt64Slice(key string) (i64s []int64) {
+ if val, ok := c.Get(key); ok && val != nil {
+ i64s, _ = val.([]int64)
+ }
+ return
+}
+
+func (c *Context) GetUintSlice(key string) (uis []uint) {
+ if val, ok := c.Get(key); ok && val != nil {
+ uis, _ = val.([]uint)
+ }
+ return
+}
+
+func (c *Context) GetUint8Slice(key string) (ui8s []uint8) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui8s, _ = val.([]uint8)
+ }
+ return
+}
+
+func (c *Context) GetUint16Slice(key string) (ui16s []uint16) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui16s, _ = val.([]uint16)
+ }
+ return
+}
+
+func (c *Context) GetUint32Slice(key string) (ui32s []uint32) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui32s, _ = val.([]uint32)
+ }
+ return
+}
+
+func (c *Context) GetUint64Slice(key string) (ui64s []uint64) {
+ if val, ok := c.Get(key); ok && val != nil {
+ ui64s, _ = val.([]uint64)
+ }
+ return
+}
+
+func (c *Context) GetFloat32Slice(key string) (f32s []float32) {
+ if val, ok := c.Get(key); ok && val != nil {
+ f32s, _ = val.([]float32)
+ }
+ return
+}
+
+func (c *Context) GetFloat64Slice(key string) (f64s []float64) {
+ if val, ok := c.Get(key); ok && val != nil {
+ f64s, _ = val.([]float64)
+ }
+ return
+}
+
// GetStringSlice returns the value associated with the key as a slice of strings.
func (c *Context) GetStringSlice(key string) (ss []string) {
if val, ok := c.Get(key); ok && val != nil {
@@ -468,7 +615,7 @@ func (c *Context) QueryArray(key string) (values []string) {
func (c *Context) initQueryCache() {
if c.queryCache == nil {
- if c.Request != nil {
+ if c.Request != nil && c.Request.URL != nil {
c.queryCache = c.Request.URL.Query()
} else {
c.queryCache = url.Values{}
@@ -614,7 +761,7 @@ func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error
}
defer src.Close()
- if err = os.MkdirAll(filepath.Dir(dst), 0750); err != nil {
+ if err = os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
return err
}
@@ -667,6 +814,11 @@ func (c *Context) BindTOML(obj any) error {
return c.MustBindWith(obj, binding.TOML)
}
+// BindPlain is a shortcut for c.MustBindWith(obj, binding.Plain).
+func (c *Context) BindPlain(obj any) error {
+ return c.MustBindWith(obj, binding.Plain)
+}
+
// BindHeader is a shortcut for c.MustBindWith(obj, binding.Header).
func (c *Context) BindHeader(obj any) error {
return c.MustBindWith(obj, binding.Header)
@@ -732,6 +884,11 @@ func (c *Context) ShouldBindTOML(obj any) error {
return c.ShouldBindWith(obj, binding.TOML)
}
+// ShouldBindPlain is a shortcut for c.ShouldBindWith(obj, binding.Plain).
+func (c *Context) ShouldBindPlain(obj any) error {
+ return c.ShouldBindWith(obj, binding.Plain)
+}
+
// ShouldBindHeader is a shortcut for c.ShouldBindWith(obj, binding.Header).
func (c *Context) ShouldBindHeader(obj any) error {
return c.ShouldBindWith(obj, binding.Header)
@@ -794,6 +951,11 @@ func (c *Context) ShouldBindBodyWithTOML(obj any) error {
return c.ShouldBindBodyWith(obj, binding.TOML)
}
+// ShouldBindBodyWithPlain is a shortcut for c.ShouldBindBodyWith(obj, binding.Plain).
+func (c *Context) ShouldBindBodyWithPlain(obj any) error {
+ return c.ShouldBindBodyWith(obj, binding.Plain)
+}
+
// ClientIP implements one best effort algorithm to return the real client IP.
// It calls c.RemoteIP() under the hood, to check if the remote IP is a trusted proxy or not.
// If it is it will then try to parse the headers defined in Engine.RemoteIPHeaders (defaulting to [X-Forwarded-For, X-Real-Ip]).
@@ -1161,7 +1323,7 @@ func (c *Context) Negotiate(code int, config Negotiate) {
data := chooseData(config.XMLData, config.Data)
c.XML(code, data)
- case binding.MIMEYAML:
+ case binding.MIMEYAML, binding.MIMEYAML2:
data := chooseData(config.YAMLData, config.Data)
c.YAML(code, data)
diff --git a/context_1.18_test.go b/context_1.18_test.go
deleted file mode 100644
index 6118bea..0000000
--- a/context_1.18_test.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2021 Gin Core Team. All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.19
-
-package gin
-
-import (
- "bytes"
- "mime/multipart"
- "net/http"
- "net/http/httptest"
- "testing"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestContextFormFileFailed18(t *testing.T) {
- buf := new(bytes.Buffer)
- mw := multipart.NewWriter(buf)
- defer func(mw *multipart.Writer) {
- err := mw.Close()
- if err != nil {
- assert.Error(t, err)
- }
- }(mw)
- c, _ := CreateTestContext(httptest.NewRecorder())
- c.Request, _ = http.NewRequest("POST", "/", nil)
- c.Request.Header.Set("Content-Type", mw.FormDataContentType())
- c.engine.MaxMultipartMemory = 8 << 20
- assert.Panics(t, func() {
- f, err := c.FormFile("file")
- assert.Error(t, err)
- assert.Nil(t, f)
- })
-}
diff --git a/context_1.19_test.go b/context_1.19_test.go
deleted file mode 100644
index dd75325..0000000
--- a/context_1.19_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2022 Gin Core Team. All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-//go:build go1.19
-
-package gin
-
-import (
- "bytes"
- "mime/multipart"
- "net/http"
- "net/http/httptest"
- "testing"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestContextFormFileFailed19(t *testing.T) {
- buf := new(bytes.Buffer)
- mw := multipart.NewWriter(buf)
- mw.Close()
- c, _ := CreateTestContext(httptest.NewRecorder())
- c.Request, _ = http.NewRequest("POST", "/", nil)
- c.Request.Header.Set("Content-Type", mw.FormDataContentType())
- c.engine.MaxMultipartMemory = 8 << 20
- f, err := c.FormFile("file")
- assert.Error(t, err)
- assert.Nil(t, f)
-}
diff --git a/context_test.go b/context_test.go
index f0ff449..d52de24 100644
--- a/context_test.go
+++ b/context_test.go
@@ -27,6 +27,7 @@ import (
testdata "git.company.lan/gopkg/gin/testdata/protoexample"
"git.company.lan/gopkg/gin-sse"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"google.golang.org/protobuf/proto"
)
@@ -74,41 +75,50 @@ func TestContextFormFile(t *testing.T) {
buf := new(bytes.Buffer)
mw := multipart.NewWriter(buf)
w, err := mw.CreateFormFile("file", "test")
- if assert.NoError(t, err) {
- _, err = w.Write([]byte("test"))
- assert.NoError(t, err)
- }
+ require.NoError(t, err)
+ _, err = w.Write([]byte("test"))
+ require.NoError(t, err)
mw.Close()
c, _ := CreateTestContext(httptest.NewRecorder())
c.Request, _ = http.NewRequest("POST", "/", buf)
c.Request.Header.Set("Content-Type", mw.FormDataContentType())
f, err := c.FormFile("file")
- if assert.NoError(t, err) {
- assert.Equal(t, "test", f.Filename)
- }
+ require.NoError(t, err)
+ assert.Equal(t, "test", f.Filename)
- assert.NoError(t, c.SaveUploadedFile(f, "test"))
+ require.NoError(t, c.SaveUploadedFile(f, "test"))
+}
+
+func TestContextFormFileFailed(t *testing.T) {
+ buf := new(bytes.Buffer)
+ mw := multipart.NewWriter(buf)
+ mw.Close()
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ c.Request, _ = http.NewRequest("POST", "/", nil)
+ c.Request.Header.Set("Content-Type", mw.FormDataContentType())
+ c.engine.MaxMultipartMemory = 8 << 20
+ f, err := c.FormFile("file")
+ require.Error(t, err)
+ assert.Nil(t, f)
}
func TestContextMultipartForm(t *testing.T) {
buf := new(bytes.Buffer)
mw := multipart.NewWriter(buf)
- assert.NoError(t, mw.WriteField("foo", "bar"))
+ require.NoError(t, mw.WriteField("foo", "bar"))
w, err := mw.CreateFormFile("file", "test")
- if assert.NoError(t, err) {
- _, err = w.Write([]byte("test"))
- assert.NoError(t, err)
- }
+ require.NoError(t, err)
+ _, err = w.Write([]byte("test"))
+ require.NoError(t, err)
mw.Close()
c, _ := CreateTestContext(httptest.NewRecorder())
c.Request, _ = http.NewRequest("POST", "/", buf)
c.Request.Header.Set("Content-Type", mw.FormDataContentType())
f, err := c.MultipartForm()
- if assert.NoError(t, err) {
- assert.NotNil(t, f)
- }
+ require.NoError(t, err)
+ assert.NotNil(t, f)
- assert.NoError(t, c.SaveUploadedFile(f.File["file"][0], "test"))
+ require.NoError(t, c.SaveUploadedFile(f.File["file"][0], "test"))
}
func TestSaveUploadedOpenFailed(t *testing.T) {
@@ -123,27 +133,25 @@ func TestSaveUploadedOpenFailed(t *testing.T) {
f := &multipart.FileHeader{
Filename: "file",
}
- assert.Error(t, c.SaveUploadedFile(f, "test"))
+ require.Error(t, c.SaveUploadedFile(f, "test"))
}
func TestSaveUploadedCreateFailed(t *testing.T) {
buf := new(bytes.Buffer)
mw := multipart.NewWriter(buf)
w, err := mw.CreateFormFile("file", "test")
- if assert.NoError(t, err) {
- _, err = w.Write([]byte("test"))
- assert.NoError(t, err)
- }
+ require.NoError(t, err)
+ _, err = w.Write([]byte("test"))
+ require.NoError(t, err)
mw.Close()
c, _ := CreateTestContext(httptest.NewRecorder())
c.Request, _ = http.NewRequest("POST", "/", buf)
c.Request.Header.Set("Content-Type", mw.FormDataContentType())
f, err := c.FormFile("file")
- if assert.NoError(t, err) {
- assert.Equal(t, "test", f.Filename)
- }
+ require.NoError(t, err)
+ assert.Equal(t, "test", f.Filename)
- assert.Error(t, c.SaveUploadedFile(f, "/"))
+ require.Error(t, c.SaveUploadedFile(f, "/"))
}
func TestContextReset(t *testing.T) {
@@ -161,10 +169,10 @@ func TestContextReset(t *testing.T) {
assert.False(t, c.IsAborted())
assert.Nil(t, c.Keys)
assert.Nil(t, c.Accepted)
- assert.Len(t, c.Errors, 0)
+ assert.Empty(t, c.Errors)
assert.Empty(t, c.Errors.Errors())
assert.Empty(t, c.Errors.ByType(ErrorTypeAny))
- assert.Len(t, c.Params, 0)
+ assert.Empty(t, c.Params)
assert.EqualValues(t, c.index, -1)
assert.Equal(t, c.Writer.(*responseWriter), &c.writermem)
}
@@ -217,13 +225,13 @@ func TestContextSetGetValues(t *testing.T) {
var a any = 1
c.Set("intInterface", a)
- assert.Exactly(t, c.MustGet("string").(string), "this is a string")
+ assert.Exactly(t, "this is a string", c.MustGet("string").(string))
assert.Exactly(t, c.MustGet("int32").(int32), int32(-42))
- assert.Exactly(t, c.MustGet("int64").(int64), int64(42424242424242))
- assert.Exactly(t, c.MustGet("uint64").(uint64), uint64(42))
- assert.Exactly(t, c.MustGet("float32").(float32), float32(4.2))
- assert.Exactly(t, c.MustGet("float64").(float64), 4.2)
- assert.Exactly(t, c.MustGet("intInterface").(int), 1)
+ assert.Exactly(t, int64(42424242424242), c.MustGet("int64").(int64))
+ assert.Exactly(t, uint64(42), c.MustGet("uint64").(uint64))
+ assert.InDelta(t, float32(4.2), c.MustGet("float32").(float32), 0.01)
+ assert.InDelta(t, 4.2, c.MustGet("float64").(float64), 0.01)
+ assert.Exactly(t, 1, c.MustGet("intInterface").(int))
}
func TestContextGetString(t *testing.T) {
@@ -244,6 +252,30 @@ func TestContextGetInt(t *testing.T) {
assert.Equal(t, 1, c.GetInt("int"))
}
+func TestContextGetInt8(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int8"
+ value := int8(0x7F)
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt8(key))
+}
+
+func TestContextGetInt16(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int16"
+ value := int16(0x7FFF)
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt16(key))
+}
+
+func TestContextGetInt32(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int32"
+ value := int32(0x7FFFFFFF)
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt32(key))
+}
+
func TestContextGetInt64(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder())
c.Set("int64", int64(42424242424242))
@@ -256,16 +288,48 @@ func TestContextGetUint(t *testing.T) {
assert.Equal(t, uint(1), c.GetUint("uint"))
}
+func TestContextGetUint8(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint8"
+ value := uint8(0xFF)
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint8(key))
+}
+
+func TestContextGetUint16(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint16"
+ value := uint16(0xFFFF)
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint16(key))
+}
+
+func TestContextGetUint32(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint32"
+ value := uint32(0xFFFFFFFF)
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint32(key))
+}
+
func TestContextGetUint64(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder())
c.Set("uint64", uint64(18446744073709551615))
assert.Equal(t, uint64(18446744073709551615), c.GetUint64("uint64"))
}
+func TestContextGetFloat32(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "float32"
+ value := float32(3.14)
+ c.Set(key, value)
+ assert.InDelta(t, value, c.GetFloat32(key), 0.01)
+}
+
func TestContextGetFloat64(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder())
c.Set("float64", 4.2)
- assert.Equal(t, 4.2, c.GetFloat64("float64"))
+ assert.InDelta(t, 4.2, c.GetFloat64("float64"), 0.01)
}
func TestContextGetTime(t *testing.T) {
@@ -281,6 +345,102 @@ func TestContextGetDuration(t *testing.T) {
assert.Equal(t, time.Second, c.GetDuration("duration"))
}
+func TestContextGetIntSlice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int-slice"
+ value := []int{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetIntSlice(key))
+}
+
+func TestContextGetInt8Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int8-slice"
+ value := []int8{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt8Slice(key))
+}
+
+func TestContextGetInt16Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int16-slice"
+ value := []int16{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt16Slice(key))
+}
+
+func TestContextGetInt32Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int32-slice"
+ value := []int32{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt32Slice(key))
+}
+
+func TestContextGetInt64Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "int64-slice"
+ value := []int64{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetInt64Slice(key))
+}
+
+func TestContextGetUintSlice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint-slice"
+ value := []uint{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUintSlice(key))
+}
+
+func TestContextGetUint8Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint8-slice"
+ value := []uint8{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint8Slice(key))
+}
+
+func TestContextGetUint16Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint16-slice"
+ value := []uint16{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint16Slice(key))
+}
+
+func TestContextGetUint32Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint32-slice"
+ value := []uint32{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint32Slice(key))
+}
+
+func TestContextGetUint64Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "uint64-slice"
+ value := []uint64{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetUint64Slice(key))
+}
+
+func TestContextGetFloat32Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "float32-slice"
+ value := []float32{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetFloat32Slice(key))
+}
+
+func TestContextGetFloat64Slice(t *testing.T) {
+ c, _ := CreateTestContext(httptest.NewRecorder())
+ key := "float64-slice"
+ value := []float64{1, 2}
+ c.Set(key, value)
+ assert.Equal(t, value, c.GetFloat64Slice(key))
+}
+
func TestContextGetStringSlice(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder())
c.Set("slice", []string{"foo"})
@@ -331,12 +491,12 @@ func TestContextCopy(t *testing.T) {
assert.Nil(t, cp.writermem.ResponseWriter)
assert.Equal(t, &cp.writermem, cp.Writer.(*responseWriter))
assert.Equal(t, cp.Request, c.Request)
- assert.Equal(t, cp.index, abortIndex)
+ assert.Equal(t, abortIndex, cp.index)
assert.Equal(t, cp.Keys, c.Keys)
assert.Equal(t, cp.engine, c.engine)
assert.Equal(t, cp.Params, c.Params)
cp.Set("foo", "notBar")
- assert.False(t, cp.Keys["foo"] == c.Keys["foo"])
+ assert.NotEqual(t, cp.Keys["foo"], c.Keys["foo"])
assert.Equal(t, cp.fullPath, c.fullPath)
}
@@ -349,11 +509,11 @@ func TestContextHandlerName(t *testing.T) {
func TestContextHandlerNames(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder())
- c.handlers = HandlersChain{func(c *Context) {}, handlerNameTest, func(c *Context) {}, handlerNameTest2}
+ c.handlers = HandlersChain{func(c *Context) {}, nil, handlerNameTest, func(c *Context) {}, handlerNameTest2}
names := c.HandlerNames()
- assert.True(t, len(names) == 4)
+ assert.Len(t, names, 4)
for _, name := range names {
assert.Regexp(t, `^(.*/vendor/)?(github\.com/gin-gonic/gin\.){1}(TestContextHandlerNames\.func.*){0,1}(handlerNameTest.*){0,1}`, name)
}
@@ -410,6 +570,49 @@ func TestContextQuery(t *testing.T) {
assert.Empty(t, c.PostForm("foo"))
}
+func TestContextInitQueryCache(t *testing.T) {
+ validURL, err := url.Parse("https://github.com/gin-gonic/gin/pull/3969?key=value&otherkey=othervalue")
+ require.NoError(t, err)
+
+ tests := []struct {
+ testName string
+ testContext *Context
+ expectedQueryCache url.Values
+ }{
+ {
+ testName: "queryCache should remain unchanged if already not nil",
+ testContext: &Context{
+ queryCache: url.Values{"a": []string{"b"}},
+ Request: &http.Request{URL: validURL}, // valid request for evidence that values weren't extracted
+ },
+ expectedQueryCache: url.Values{"a": []string{"b"}},
+ },
+ {
+ testName: "queryCache should be empty when Request is nil",
+ testContext: &Context{Request: nil}, // explicit nil for readability
+ expectedQueryCache: url.Values{},
+ },
+ {
+ testName: "queryCache should be empty when Request.URL is nil",
+ testContext: &Context{Request: &http.Request{URL: nil}}, // explicit nil for readability
+ expectedQueryCache: url.Values{},
+ },
+ {
+ testName: "queryCache should be populated when it not yet populated and Request + Request.URL are non nil",
+ testContext: &Context{Request: &http.Request{URL: validURL}}, // explicit nil for readability
+ expectedQueryCache: url.Values{"key": []string{"value"}, "otherkey": []string{"othervalue"}},
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.testName, func(t *testing.T) {
+ test.testContext.initQueryCache()
+ assert.Equal(t, test.expectedQueryCache, test.testContext.queryCache)
+ })
+ }
+
+}
+
func TestContextDefaultQueryOnEmptyRequest(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder()) // here c.Request == nil
assert.NotPanics(t, func() {
@@ -475,7 +678,7 @@ func TestContextQueryAndPostForm(t *testing.T) {
Both string `form:"both"`
Array []string `form:"array[]"`
}
- assert.NoError(t, c.Bind(&obj))
+ require.NoError(t, c.Bind(&obj))
assert.Equal(t, "bar", obj.Foo, "bar")
assert.Equal(t, "main", obj.ID, "main")
assert.Equal(t, 11, obj.Page, 11)
@@ -492,10 +695,10 @@ func TestContextQueryAndPostForm(t *testing.T) {
assert.Equal(t, "second", values[1])
values = c.QueryArray("nokey")
- assert.Equal(t, 0, len(values))
+ assert.Empty(t, values)
values = c.QueryArray("both")
- assert.Equal(t, 1, len(values))
+ assert.Len(t, values, 1)
assert.Equal(t, "GET", values[0])
dicts, ok := c.GetQueryMap("ids")
@@ -505,22 +708,22 @@ func TestContextQueryAndPostForm(t *testing.T) {
dicts, ok = c.GetQueryMap("nokey")
assert.False(t, ok)
- assert.Equal(t, 0, len(dicts))
+ assert.Empty(t, dicts)
dicts, ok = c.GetQueryMap("both")
assert.False(t, ok)
- assert.Equal(t, 0, len(dicts))
+ assert.Empty(t, dicts)
dicts, ok = c.GetQueryMap("array")
assert.False(t, ok)
- assert.Equal(t, 0, len(dicts))
+ assert.Empty(t, dicts)
dicts = c.QueryMap("ids")
assert.Equal(t, "hi", dicts["a"])
assert.Equal(t, "3.14", dicts["b"])
dicts = c.QueryMap("nokey")
- assert.Equal(t, 0, len(dicts))
+ assert.Empty(t, dicts)
}
func TestContextPostFormMultipart(t *testing.T) {
@@ -538,7 +741,7 @@ func TestContextPostFormMultipart(t *testing.T) {
TimeLocation time.Time `form:"time_location" time_format:"02/01/2006 15:04" time_location:"Asia/Tokyo"`
BlankTime time.Time `form:"blank_time" time_format:"02/01/2006 15:04"`
}
- assert.NoError(t, c.Bind(&obj))
+ require.NoError(t, c.Bind(&obj))
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, "10", obj.Bar)
assert.Equal(t, 10, obj.BarAsInt)
@@ -592,10 +795,10 @@ func TestContextPostFormMultipart(t *testing.T) {
assert.Equal(t, "second", values[1])
values = c.PostFormArray("nokey")
- assert.Equal(t, 0, len(values))
+ assert.Empty(t, values)
values = c.PostFormArray("foo")
- assert.Equal(t, 1, len(values))
+ assert.Len(t, values, 1)
assert.Equal(t, "bar", values[0])
dicts, ok := c.GetPostFormMap("names")
@@ -605,14 +808,14 @@ func TestContextPostFormMultipart(t *testing.T) {
dicts, ok = c.GetPostFormMap("nokey")
assert.False(t, ok)
- assert.Equal(t, 0, len(dicts))
+ assert.Empty(t, dicts)
dicts = c.PostFormMap("names")
assert.Equal(t, "thinkerou", dicts["a"])
assert.Equal(t, "tianou", dicts["b"])
dicts = c.PostFormMap("nokey")
- assert.Equal(t, 0, len(dicts))
+ assert.Empty(t, dicts)
}
func TestContextSetCookie(t *testing.T) {
@@ -637,7 +840,7 @@ func TestContextGetCookie(t *testing.T) {
assert.Equal(t, "gin", cookie)
_, err := c.Cookie("nokey")
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestContextBodyAllowedForStatus(t *testing.T) {
@@ -742,7 +945,7 @@ func TestContextRenderNoContentAPIJSON(t *testing.T) {
assert.Equal(t, http.StatusNoContent, w.Code)
assert.Empty(t, w.Body.String())
- assert.Equal(t, w.Header().Get("Content-Type"), "application/vnd.api+json")
+ assert.Equal(t, "application/vnd.api+json", w.Header().Get("Content-Type"))
}
// Tests that the response is serialized as JSON
@@ -950,7 +1153,7 @@ func TestContextRenderNoContentHTMLString(t *testing.T) {
assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
}
-// TestContextData tests that the response can be written from `bytestring`
+// TestContextRenderData tests that the response can be written from `bytestring`
// with specified MIME type
func TestContextRenderData(t *testing.T) {
w := httptest.NewRecorder()
@@ -1104,7 +1307,7 @@ func TestContextRenderProtoBuf(t *testing.T) {
c.ProtoBuf(http.StatusCreated, data)
protoData, err := proto.Marshal(data)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, http.StatusCreated, w.Code)
assert.Equal(t, string(protoData), w.Body.String())
@@ -1183,7 +1386,7 @@ func TestContextNegotiationWithJSON(t *testing.T) {
c.Request, _ = http.NewRequest("POST", "", nil)
c.Negotiate(http.StatusOK, Negotiate{
- Offered: []string{MIMEJSON, MIMEXML, MIMEYAML},
+ Offered: []string{MIMEJSON, MIMEXML, MIMEYAML, MIMEYAML2},
Data: H{"foo": "bar"},
})
@@ -1198,7 +1401,7 @@ func TestContextNegotiationWithXML(t *testing.T) {
c.Request, _ = http.NewRequest("POST", "", nil)
c.Negotiate(http.StatusOK, Negotiate{
- Offered: []string{MIMEXML, MIMEJSON, MIMEYAML},
+ Offered: []string{MIMEXML, MIMEJSON, MIMEYAML, MIMEYAML2},
Data: H{"foo": "bar"},
})
@@ -1213,7 +1416,7 @@ func TestContextNegotiationWithYAML(t *testing.T) {
c.Request, _ = http.NewRequest("POST", "", nil)
c.Negotiate(http.StatusOK, Negotiate{
- Offered: []string{MIMEYAML, MIMEXML, MIMEJSON, MIMETOML},
+ Offered: []string{MIMEYAML, MIMEXML, MIMEJSON, MIMETOML, MIMEYAML2},
Data: H{"foo": "bar"},
})
@@ -1228,7 +1431,7 @@ func TestContextNegotiationWithTOML(t *testing.T) {
c.Request, _ = http.NewRequest("POST", "", nil)
c.Negotiate(http.StatusOK, Negotiate{
- Offered: []string{MIMETOML, MIMEXML, MIMEJSON, MIMEYAML},
+ Offered: []string{MIMETOML, MIMEXML, MIMEJSON, MIMEYAML, MIMEYAML2},
Data: H{"foo": "bar"},
})
@@ -1265,7 +1468,7 @@ func TestContextNegotiationNotSupport(t *testing.T) {
})
assert.Equal(t, http.StatusNotAcceptable, w.Code)
- assert.Equal(t, c.index, abortIndex)
+ assert.Equal(t, abortIndex, c.index)
assert.True(t, c.IsAborted())
}
@@ -1293,23 +1496,23 @@ func TestContextNegotiationFormatWithWildcardAccept(t *testing.T) {
c.Request, _ = http.NewRequest("POST", "/", nil)
c.Request.Header.Add("Accept", "*/*")
- assert.Equal(t, c.NegotiateFormat("*/*"), "*/*")
- assert.Equal(t, c.NegotiateFormat("text/*"), "text/*")
- assert.Equal(t, c.NegotiateFormat("application/*"), "application/*")
- assert.Equal(t, c.NegotiateFormat(MIMEJSON), MIMEJSON)
- assert.Equal(t, c.NegotiateFormat(MIMEXML), MIMEXML)
- assert.Equal(t, c.NegotiateFormat(MIMEHTML), MIMEHTML)
+ assert.Equal(t, "*/*", c.NegotiateFormat("*/*"))
+ assert.Equal(t, "text/*", c.NegotiateFormat("text/*"))
+ assert.Equal(t, "application/*", c.NegotiateFormat("application/*"))
+ assert.Equal(t, MIMEJSON, c.NegotiateFormat(MIMEJSON))
+ assert.Equal(t, MIMEXML, c.NegotiateFormat(MIMEXML))
+ assert.Equal(t, MIMEHTML, c.NegotiateFormat(MIMEHTML))
c, _ = CreateTestContext(httptest.NewRecorder())
c.Request, _ = http.NewRequest("POST", "/", nil)
c.Request.Header.Add("Accept", "text/*")
- assert.Equal(t, c.NegotiateFormat("*/*"), "*/*")
- assert.Equal(t, c.NegotiateFormat("text/*"), "text/*")
- assert.Equal(t, c.NegotiateFormat("application/*"), "")
- assert.Equal(t, c.NegotiateFormat(MIMEJSON), "")
- assert.Equal(t, c.NegotiateFormat(MIMEXML), "")
- assert.Equal(t, c.NegotiateFormat(MIMEHTML), MIMEHTML)
+ assert.Equal(t, "*/*", c.NegotiateFormat("*/*"))
+ assert.Equal(t, "text/*", c.NegotiateFormat("text/*"))
+ assert.Equal(t, "", c.NegotiateFormat("application/*"))
+ assert.Equal(t, "", c.NegotiateFormat(MIMEJSON))
+ assert.Equal(t, "", c.NegotiateFormat(MIMEXML))
+ assert.Equal(t, MIMEHTML, c.NegotiateFormat(MIMEHTML))
}
func TestContextNegotiationFormatCustom(t *testing.T) {
@@ -1347,7 +1550,7 @@ func TestContextIsAborted(t *testing.T) {
assert.True(t, c.IsAborted())
}
-// TestContextData tests that the response can be written from `bytestring`
+// TestContextAbortWithStatus tests that the response can be written from `bytestring`
// with specified MIME type
func TestContextAbortWithStatus(t *testing.T) {
w := httptest.NewRecorder()
@@ -1388,7 +1591,7 @@ func TestContextAbortWithStatusJSON(t *testing.T) {
buf := new(bytes.Buffer)
_, err := buf.ReadFrom(w.Body)
- assert.NoError(t, err)
+ require.NoError(t, err)
jsonStringBody := buf.String()
assert.Equal(t, "{\"foo\":\"fooValue\",\"bar\":\"barValue\"}", jsonStringBody)
}
@@ -1613,7 +1816,7 @@ func TestContextAutoBindJSON(t *testing.T) {
Foo string `json:"foo"`
Bar string `json:"bar"`
}
- assert.NoError(t, c.Bind(&obj))
+ require.NoError(t, c.Bind(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Empty(t, c.Errors)
@@ -1630,7 +1833,7 @@ func TestContextBindWithJSON(t *testing.T) {
Foo string `json:"foo"`
Bar string `json:"bar"`
}
- assert.NoError(t, c.BindJSON(&obj))
+ require.NoError(t, c.BindJSON(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1651,12 +1854,36 @@ func TestContextBindWithXML(t *testing.T) {
Foo string `xml:"foo"`
Bar string `xml:"bar"`
}
- assert.NoError(t, c.BindXML(&obj))
+ require.NoError(t, c.BindXML(&obj))
assert.Equal(t, "FOO", obj.Foo)
assert.Equal(t, "BAR", obj.Bar)
assert.Equal(t, 0, w.Body.Len())
}
+func TestContextBindPlain(t *testing.T) {
+ // string
+ w := httptest.NewRecorder()
+ c, _ := CreateTestContext(w)
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`test string`))
+ c.Request.Header.Add("Content-Type", MIMEPlain)
+
+ var s string
+
+ require.NoError(t, c.BindPlain(&s))
+ assert.Equal(t, "test string", s)
+ assert.Equal(t, 0, w.Body.Len())
+
+ // []byte
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`test []byte`))
+ c.Request.Header.Add("Content-Type", MIMEPlain)
+
+ var bs []byte
+
+ require.NoError(t, c.BindPlain(&bs))
+ assert.Equal(t, []byte("test []byte"), bs)
+ assert.Equal(t, 0, w.Body.Len())
+}
+
func TestContextBindHeader(t *testing.T) {
w := httptest.NewRecorder()
c, _ := CreateTestContext(w)
@@ -1672,7 +1899,7 @@ func TestContextBindHeader(t *testing.T) {
Limit int `header:"limit"`
}
- assert.NoError(t, c.BindHeader(&testHeader))
+ require.NoError(t, c.BindHeader(&testHeader))
assert.Equal(t, 8000, testHeader.Rate)
assert.Equal(t, "music", testHeader.Domain)
assert.Equal(t, 1000, testHeader.Limit)
@@ -1689,7 +1916,7 @@ func TestContextBindWithQuery(t *testing.T) {
Foo string `form:"foo"`
Bar string `form:"bar"`
}
- assert.NoError(t, c.BindQuery(&obj))
+ require.NoError(t, c.BindQuery(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1706,7 +1933,7 @@ func TestContextBindWithYAML(t *testing.T) {
Foo string `yaml:"foo"`
Bar string `yaml:"bar"`
}
- assert.NoError(t, c.BindYAML(&obj))
+ require.NoError(t, c.BindYAML(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1723,7 +1950,7 @@ func TestContextBindWithTOML(t *testing.T) {
Foo string `toml:"foo"`
Bar string `toml:"bar"`
}
- assert.NoError(t, c.BindTOML(&obj))
+ require.NoError(t, c.BindTOML(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1741,7 +1968,7 @@ func TestContextBadAutoBind(t *testing.T) {
}
assert.False(t, c.IsAborted())
- assert.Error(t, c.Bind(&obj))
+ require.Error(t, c.Bind(&obj))
c.Writer.WriteHeaderNow()
assert.Empty(t, obj.Bar)
@@ -1759,7 +1986,7 @@ func TestContextAutoShouldBindJSON(t *testing.T) {
Foo string `json:"foo"`
Bar string `json:"bar"`
}
- assert.NoError(t, c.ShouldBind(&obj))
+ require.NoError(t, c.ShouldBind(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Empty(t, c.Errors)
@@ -1776,7 +2003,7 @@ func TestContextShouldBindWithJSON(t *testing.T) {
Foo string `json:"foo"`
Bar string `json:"bar"`
}
- assert.NoError(t, c.ShouldBindJSON(&obj))
+ require.NoError(t, c.ShouldBindJSON(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1797,12 +2024,36 @@ func TestContextShouldBindWithXML(t *testing.T) {
Foo string `xml:"foo"`
Bar string `xml:"bar"`
}
- assert.NoError(t, c.ShouldBindXML(&obj))
+ require.NoError(t, c.ShouldBindXML(&obj))
assert.Equal(t, "FOO", obj.Foo)
assert.Equal(t, "BAR", obj.Bar)
assert.Equal(t, 0, w.Body.Len())
}
+func TestContextShouldBindPlain(t *testing.T) {
+ // string
+ w := httptest.NewRecorder()
+ c, _ := CreateTestContext(w)
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`test string`))
+ c.Request.Header.Add("Content-Type", MIMEPlain)
+
+ var s string
+
+ require.NoError(t, c.ShouldBindPlain(&s))
+ assert.Equal(t, "test string", s)
+ assert.Equal(t, 0, w.Body.Len())
+ // []byte
+
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`test []byte`))
+ c.Request.Header.Add("Content-Type", MIMEPlain)
+
+ var bs []byte
+
+ require.NoError(t, c.ShouldBindPlain(&bs))
+ assert.Equal(t, []byte("test []byte"), bs)
+ assert.Equal(t, 0, w.Body.Len())
+}
+
func TestContextShouldBindHeader(t *testing.T) {
w := httptest.NewRecorder()
c, _ := CreateTestContext(w)
@@ -1818,7 +2069,7 @@ func TestContextShouldBindHeader(t *testing.T) {
Limit int `header:"limit"`
}
- assert.NoError(t, c.ShouldBindHeader(&testHeader))
+ require.NoError(t, c.ShouldBindHeader(&testHeader))
assert.Equal(t, 8000, testHeader.Rate)
assert.Equal(t, "music", testHeader.Domain)
assert.Equal(t, 1000, testHeader.Limit)
@@ -1837,7 +2088,7 @@ func TestContextShouldBindWithQuery(t *testing.T) {
Foo1 string `form:"Foo"`
Bar1 string `form:"Bar"`
}
- assert.NoError(t, c.ShouldBindQuery(&obj))
+ require.NoError(t, c.ShouldBindQuery(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, "foo1", obj.Bar1)
@@ -1856,7 +2107,7 @@ func TestContextShouldBindWithYAML(t *testing.T) {
Foo string `yaml:"foo"`
Bar string `yaml:"bar"`
}
- assert.NoError(t, c.ShouldBindYAML(&obj))
+ require.NoError(t, c.ShouldBindYAML(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1873,7 +2124,7 @@ func TestContextShouldBindWithTOML(t *testing.T) {
Foo string `toml:"foo"`
Bar string `toml:"bar"`
}
- assert.NoError(t, c.ShouldBindTOML(&obj))
+ require.NoError(t, c.ShouldBindTOML(&obj))
assert.Equal(t, "foo", obj.Bar)
assert.Equal(t, "bar", obj.Foo)
assert.Equal(t, 0, w.Body.Len())
@@ -1891,7 +2142,7 @@ func TestContextBadAutoShouldBind(t *testing.T) {
}
assert.False(t, c.IsAborted())
- assert.Error(t, c.ShouldBind(&obj))
+ require.Error(t, c.ShouldBind(&obj))
assert.Empty(t, obj.Bar)
assert.Empty(t, obj.Foo)
@@ -1952,10 +2203,10 @@ func TestContextShouldBindBodyWith(t *testing.T) {
// When it binds to typeA and typeB, it finds the body is
// not typeB but typeA.
objA := typeA{}
- assert.NoError(t, c.ShouldBindBodyWith(&objA, tt.bindingA))
+ require.NoError(t, c.ShouldBindBodyWith(&objA, tt.bindingA))
assert.Equal(t, typeA{"FOO"}, objA)
objB := typeB{}
- assert.Error(t, c.ShouldBindBodyWith(&objB, tt.bindingB))
+ require.Error(t, c.ShouldBindBodyWith(&objB, tt.bindingB))
assert.NotEqual(t, typeB{"BAR"}, objB)
}
// bodyB to typeA and typeB
@@ -1968,10 +2219,10 @@ func TestContextShouldBindBodyWith(t *testing.T) {
"POST", "http://example.com", bytes.NewBufferString(tt.bodyB),
)
objA := typeA{}
- assert.Error(t, c.ShouldBindBodyWith(&objA, tt.bindingA))
+ require.Error(t, c.ShouldBindBodyWith(&objA, tt.bindingA))
assert.NotEqual(t, typeA{"FOO"}, objA)
objB := typeB{}
- assert.NoError(t, c.ShouldBindBodyWith(&objB, tt.bindingB))
+ require.NoError(t, c.ShouldBindBodyWith(&objB, tt.bindingB))
assert.Equal(t, typeB{"BAR"}, objB)
}
}
@@ -2020,22 +2271,22 @@ func TestContextShouldBindBodyWithJSON(t *testing.T) {
objJSON := typeJSON{}
if tt.bindingBody == binding.JSON {
- assert.NoError(t, c.ShouldBindBodyWithJSON(&objJSON))
+ require.NoError(t, c.ShouldBindBodyWithJSON(&objJSON))
assert.Equal(t, typeJSON{"FOO"}, objJSON)
}
if tt.bindingBody == binding.XML {
- assert.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
+ require.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
assert.Equal(t, typeJSON{}, objJSON)
}
if tt.bindingBody == binding.YAML {
- assert.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
+ require.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
assert.Equal(t, typeJSON{}, objJSON)
}
if tt.bindingBody == binding.TOML {
- assert.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
+ require.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
assert.Equal(t, typeJSON{}, objJSON)
}
}
@@ -2084,22 +2335,22 @@ func TestContextShouldBindBodyWithXML(t *testing.T) {
objXML := typeXML{}
if tt.bindingBody == binding.JSON {
- assert.Error(t, c.ShouldBindBodyWithXML(&objXML))
+ require.Error(t, c.ShouldBindBodyWithXML(&objXML))
assert.Equal(t, typeXML{}, objXML)
}
if tt.bindingBody == binding.XML {
- assert.NoError(t, c.ShouldBindBodyWithXML(&objXML))
+ require.NoError(t, c.ShouldBindBodyWithXML(&objXML))
assert.Equal(t, typeXML{"FOO"}, objXML)
}
if tt.bindingBody == binding.YAML {
- assert.Error(t, c.ShouldBindBodyWithXML(&objXML))
+ require.Error(t, c.ShouldBindBodyWithXML(&objXML))
assert.Equal(t, typeXML{}, objXML)
}
if tt.bindingBody == binding.TOML {
- assert.Error(t, c.ShouldBindBodyWithXML(&objXML))
+ require.Error(t, c.ShouldBindBodyWithXML(&objXML))
assert.Equal(t, typeXML{}, objXML)
}
}
@@ -2149,22 +2400,22 @@ func TestContextShouldBindBodyWithYAML(t *testing.T) {
// YAML belongs to a super collection of JSON, so JSON can be parsed by YAML
if tt.bindingBody == binding.JSON {
- assert.NoError(t, c.ShouldBindBodyWithYAML(&objYAML))
+ require.NoError(t, c.ShouldBindBodyWithYAML(&objYAML))
assert.Equal(t, typeYAML{"FOO"}, objYAML)
}
if tt.bindingBody == binding.XML {
- assert.Error(t, c.ShouldBindBodyWithYAML(&objYAML))
+ require.Error(t, c.ShouldBindBodyWithYAML(&objYAML))
assert.Equal(t, typeYAML{}, objYAML)
}
if tt.bindingBody == binding.YAML {
- assert.NoError(t, c.ShouldBindBodyWithYAML(&objYAML))
+ require.NoError(t, c.ShouldBindBodyWithYAML(&objYAML))
assert.Equal(t, typeYAML{"FOO"}, objYAML)
}
if tt.bindingBody == binding.TOML {
- assert.Error(t, c.ShouldBindBodyWithYAML(&objYAML))
+ require.Error(t, c.ShouldBindBodyWithYAML(&objYAML))
assert.Equal(t, typeYAML{}, objYAML)
}
}
@@ -2213,34 +2464,109 @@ func TestContextShouldBindBodyWithTOML(t *testing.T) {
objTOML := typeTOML{}
if tt.bindingBody == binding.JSON {
- assert.Error(t, c.ShouldBindBodyWithTOML(&objTOML))
+ require.Error(t, c.ShouldBindBodyWithTOML(&objTOML))
assert.Equal(t, typeTOML{}, objTOML)
}
if tt.bindingBody == binding.XML {
- assert.Error(t, c.ShouldBindBodyWithTOML(&objTOML))
+ require.Error(t, c.ShouldBindBodyWithTOML(&objTOML))
assert.Equal(t, typeTOML{}, objTOML)
}
if tt.bindingBody == binding.YAML {
- assert.Error(t, c.ShouldBindBodyWithTOML(&objTOML))
+ require.Error(t, c.ShouldBindBodyWithTOML(&objTOML))
assert.Equal(t, typeTOML{}, objTOML)
}
if tt.bindingBody == binding.TOML {
- assert.NoError(t, c.ShouldBindBodyWithTOML(&objTOML))
+ require.NoError(t, c.ShouldBindBodyWithTOML(&objTOML))
assert.Equal(t, typeTOML{"FOO"}, objTOML)
}
}
}
+func TestContextShouldBindBodyWithPlain(t *testing.T) {
+ for _, tt := range []struct {
+ name string
+ bindingBody binding.BindingBody
+ body string
+ }{
+ {
+ name: " JSON & JSON-BODY ",
+ bindingBody: binding.JSON,
+ body: `{"foo":"FOO"}`,
+ },
+ {
+ name: " JSON & XML-BODY ",
+ bindingBody: binding.XML,
+ body: `
+
+FOO
+`,
+ },
+ {
+ name: " JSON & YAML-BODY ",
+ bindingBody: binding.YAML,
+ body: `foo: FOO`,
+ },
+ {
+ name: " JSON & TOM-BODY ",
+ bindingBody: binding.TOML,
+ body: `foo=FOO`,
+ },
+ {
+ name: " JSON & Plain-BODY ",
+ bindingBody: binding.Plain,
+ body: `foo=FOO`,
+ },
+ } {
+ t.Logf("testing: %s", tt.name)
+
+ w := httptest.NewRecorder()
+ c, _ := CreateTestContext(w)
+
+ c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(tt.body))
+
+ type typeJSON struct {
+ Foo string `json:"foo" binding:"required"`
+ }
+ objJSON := typeJSON{}
+
+ if tt.bindingBody == binding.Plain {
+ body := ""
+ require.NoError(t, c.ShouldBindBodyWithPlain(&body))
+ assert.Equal(t, "foo=FOO", body)
+ }
+
+ if tt.bindingBody == binding.JSON {
+ require.NoError(t, c.ShouldBindBodyWithJSON(&objJSON))
+ assert.Equal(t, typeJSON{"FOO"}, objJSON)
+ }
+
+ if tt.bindingBody == binding.XML {
+ require.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
+ assert.Equal(t, typeJSON{}, objJSON)
+ }
+
+ if tt.bindingBody == binding.YAML {
+ require.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
+ assert.Equal(t, typeJSON{}, objJSON)
+ }
+
+ if tt.bindingBody == binding.TOML {
+ require.Error(t, c.ShouldBindBodyWithJSON(&objJSON))
+ assert.Equal(t, typeJSON{}, objJSON)
+ }
+ }
+}
+
func TestContextGolangContext(t *testing.T) {
c, _ := CreateTestContext(httptest.NewRecorder())
c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString("{\"foo\":\"bar\", \"bar\":\"foo\"}"))
- assert.NoError(t, c.Err())
+ require.NoError(t, c.Err())
assert.Nil(t, c.Done())
ti, ok := c.Deadline()
- assert.Equal(t, ti, time.Time{})
+ assert.Equal(t, time.Time{}, ti)
assert.False(t, ok)
assert.Equal(t, c.Value(ContextRequestKey), c.Request)
assert.Equal(t, c.Value(ContextKey), c)
@@ -2289,7 +2615,7 @@ func TestContextGetRawData(t *testing.T) {
c.Request.Header.Add("Content-Type", MIMEPOSTForm)
data, err := c.GetRawData()
- assert.Nil(t, err)
+ require.NoError(t, err)
assert.Equal(t, "Fetch binary post data", string(data))
}
@@ -2360,7 +2686,7 @@ func TestContextStream(t *testing.T) {
}()
_, err := w.Write([]byte("test"))
- assert.NoError(t, err)
+ require.NoError(t, err)
return stopStream
})
@@ -2378,7 +2704,7 @@ func TestContextStreamWithClientGone(t *testing.T) {
}()
_, err := writer.Write([]byte("test"))
- assert.NoError(t, err)
+ require.NoError(t, err)
return true
})
@@ -2506,7 +2832,7 @@ func TestContextWithFallbackErrFromRequestContext(t *testing.T) {
// enable ContextWithFallback feature flag
c.engine.ContextWithFallback = true
- assert.Nil(t, c.Err())
+ require.NoError(t, c.Err())
c2, _ := CreateTestContext(httptest.NewRecorder())
// enable ContextWithFallback feature flag
@@ -2531,7 +2857,8 @@ func TestContextWithFallbackValueFromRequestContext(t *testing.T) {
{
name: "c with struct context key",
getContextAndKey: func() (*Context, any) {
- var key struct{}
+ type KeyStruct struct{} // https://staticcheck.dev/docs/checks/#SA1029
+ var key KeyStruct
c, _ := CreateTestContext(httptest.NewRecorder())
// enable ContextWithFallback feature flag
c.engine.ContextWithFallback = true
@@ -2655,7 +2982,7 @@ func TestContextAddParam(t *testing.T) {
c.AddParam(id, value)
v, ok := c.Params.Get(id)
- assert.Equal(t, ok, true)
+ assert.True(t, ok)
assert.Equal(t, value, v)
}
diff --git a/debug.go b/debug.go
index 1761fe3..62085c5 100644
--- a/debug.go
+++ b/debug.go
@@ -10,14 +10,15 @@ import (
"runtime"
"strconv"
"strings"
+ "sync/atomic"
)
-const ginSupportMinGoVer = 18
+const ginSupportMinGoVer = 21
// IsDebugging returns true if the framework is running in debug mode.
// Use SetMode(gin.ReleaseMode) to disable debug mode.
func IsDebugging() bool {
- return ginMode == debugCode
+ return atomic.LoadInt32(&ginMode) == debugCode
}
// DebugPrintRouteFunc indicates debug log output format.
@@ -77,7 +78,7 @@ func getMinVer(v string) (uint64, error) {
func debugPrintWARNINGDefault() {
if v, e := getMinVer(runtime.Version()); e == nil && v < ginSupportMinGoVer {
- debugPrint(`[WARNING] Now Gin requires Go 1.18+.
+ debugPrint(`[WARNING] Now Gin requires Go 1.21+.
`)
}
diff --git a/debug_test.go b/debug_test.go
index b28d2f7..feb90e0 100644
--- a/debug_test.go
+++ b/debug_test.go
@@ -17,6 +17,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
// TODO
@@ -104,7 +105,7 @@ func TestDebugPrintWARNINGDefault(t *testing.T) {
})
m, e := getMinVer(runtime.Version())
if e == nil && m < ginSupportMinGoVer {
- assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.18+.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
+ assert.Equal(t, "[GIN-debug] [WARNING] Now Gin requires Go 1.21+.\n\n[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
} else {
assert.Equal(t, "[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.\n\n", re)
}
@@ -154,13 +155,13 @@ func TestGetMinVer(t *testing.T) {
var m uint64
var e error
_, e = getMinVer("go1")
- assert.NotNil(t, e)
+ require.Error(t, e)
m, e = getMinVer("go1.1")
assert.Equal(t, uint64(1), m)
- assert.Nil(t, e)
+ require.NoError(t, e)
m, e = getMinVer("go1.1.1")
- assert.Nil(t, e)
+ require.NoError(t, e)
assert.Equal(t, uint64(1), m)
_, e = getMinVer("go1.1.1.1")
- assert.NotNil(t, e)
+ require.Error(t, e)
}
diff --git a/docs/doc.md b/docs/doc.md
index beeebf0..874192b 100644
--- a/docs/doc.md
+++ b/docs/doc.md
@@ -26,6 +26,8 @@
- [Custom Validators](#custom-validators)
- [Only Bind Query String](#only-bind-query-string)
- [Bind Query String or Post Data](#bind-query-string-or-post-data)
+ - [Bind default value if none provided](#bind-default-value-if-none-provided)
+ - [Collection format for arrays](#collection-format-for-arrays)
- [Bind Uri](#bind-uri)
- [Bind custom unmarshaler](#bind-custom-unmarshaler)
- [Bind Header](#bind-header)
@@ -170,7 +172,7 @@ func main() {
router := gin.Default()
// Query string parameters are parsed using the existing underlying request object.
- // The request responds to an url matching: /welcome?firstname=Jane&lastname=Doe
+ // The request responds to an url matching: /welcome?firstname=Jane&lastname=Doe
router.GET("/welcome", func(c *gin.Context) {
firstname := c.DefaultQuery("firstname", "Guest")
lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
@@ -338,16 +340,16 @@ func main() {
router := gin.Default()
// Simple group: v1
- v1 := router.Group("/v1")
{
+ v1 := router.Group("/v1")
v1.POST("/login", loginEndpoint)
v1.POST("/submit", submitEndpoint)
v1.POST("/read", readEndpoint)
}
// Simple group: v2
- v2 := router.Group("/v2")
{
+ v2 := router.Group("/v2")
v2.POST("/login", loginEndpoint)
v2.POST("/submit", submitEndpoint)
v2.POST("/read", readEndpoint)
@@ -524,7 +526,7 @@ func main() {
return c.Writer.Status() < http.StatusInternalServerError
}
- engine.Use(gin.LoggerWithConfig(loggerConfig))
+ router.Use(gin.LoggerWithConfig(loggerConfig))
router.Use(gin.Recovery())
// skipped
@@ -613,7 +615,7 @@ You can also specify that specific fields are required. If a field is decorated
```go
// Binding from JSON
type Login struct {
- User string `form:"user" json:"user" xml:"user" binding:"required"`
+ User string `form:"user" json:"user" xml:"user" binding:"required"`
Password string `form:"password" json:"password" xml:"password" binding:"required"`
}
@@ -861,6 +863,106 @@ Test it with:
curl -X GET "localhost:8085/testing?name=appleboy&address=xyz&birthday=1992-03-15&createTime=1562400033000000123&unixTime=1562400033"
```
+### Bind default value if none provided
+
+If the server should bind a default value to a field when the client does not provide one, specify the default value using the `default` key within the `form` tag:
+
+```
+package main
+
+import (
+ "net/http"
+
+ "github.com/gin-gonic/gin"
+)
+
+type Person struct {
+ Name string `form:"name,default=William"`
+ Age int `form:"age,default=10"`
+ Friends []string `form:"friends,default=Will;Bill"`
+ Addresses [2]string `form:"addresses,default=foo bar" collection_format:"ssv"`
+ LapTimes []int `form:"lap_times,default=1;2;3" collection_format:"csv"`
+}
+
+func main() {
+ g := gin.Default()
+ g.POST("/person", func(c *gin.Context) {
+ var req Person
+ if err := c.ShouldBindQuery(&req); err != nil {
+ c.JSON(http.StatusBadRequest, err)
+ return
+ }
+ c.JSON(http.StatusOK, req)
+ })
+ _ = g.Run("localhost:8080")
+}
+```
+
+```
+curl -X POST http://localhost:8080/person
+{"Name":"William","Age":10,"Friends":["Will","Bill"],"Colors":["red","blue"],"LapTimes":[1,2,3]}
+```
+
+NOTE: For default [collection values](#collection-format-for-arrays), the following rules apply:
+
+- Since commas are used to delimit tag options, they are not supported within a default value and will result in undefined behavior
+- For the collection formats "multi" and "csv", a semicolon should be used in place of a comma to delimited default values
+- Since semicolons are used to delimit default values for "multi" and "csv", they are not supported within a default value for "multi" and "csv"
+
+#### Collection format for arrays
+
+| Format | Description | Example |
+| --------------- | --------------------------------------------------------- | ----------------------- |
+| multi (default) | Multiple parameter instances rather than multiple values. | key=foo&key=bar&key=baz |
+| csv | Comma-separated values. | foo,bar,baz |
+| ssv | Space-separated values. | foo bar baz |
+| tsv | Tab-separated values. | "foo\tbar\tbaz" |
+| pipes | Pipe-separated values. | foo\|bar\|baz |
+
+```go
+package main
+
+import (
+ "log"
+ "time"
+ "github.com/gin-gonic/gin"
+)
+
+type Person struct {
+ Name string `form:"name"`
+ Addresses []string `form:"addresses" collection_format:"csv"`
+ Birthday time.Time `form:"birthday" time_format:"2006-01-02" time_utc:"1"`
+ CreateTime time.Time `form:"createTime" time_format:"unixNano"`
+ UnixTime time.Time `form:"unixTime" time_format:"unix"`
+}
+
+func main() {
+ route := gin.Default()
+ route.GET("/testing", startPage)
+ route.Run(":8085")
+}
+func startPage(c *gin.Context) {
+ var person Person
+ // If `GET`, only `Form` binding engine (`query`) used.
+ // If `POST`, first checks the `content-type` for `JSON` or `XML`, then uses `Form` (`form-data`).
+ // See more at https://github.com/gin-gonic/gin/blob/master/binding/binding.go#L48
+ if c.ShouldBind(&person) == nil {
+ log.Println(person.Name)
+ log.Println(person.Addresses)
+ log.Println(person.Birthday)
+ log.Println(person.CreateTime)
+ log.Println(person.UnixTime)
+ }
+ c.String(200, "Success")
+}
+```
+
+Test it with:
+
+```sh
+$ curl -X GET "localhost:8085/testing?name=appleboy&addresses=foo,bar&birthday=1992-03-15&createTime=1562400033000000123&unixTime=1562400033"
+```
+
### Bind Uri
See the [detail information](https://github.com/gin-gonic/gin/issues/846).
diff --git a/errors_test.go b/errors_test.go
index 6546f9b..12479e1 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -11,6 +11,7 @@ import (
"git.company.lan/gopkg/gin/internal/json"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestError(t *testing.T) {
@@ -122,7 +123,7 @@ func TestErrorUnwrap(t *testing.T) {
})
// check that 'errors.Is()' and 'errors.As()' behave as expected :
- assert.True(t, errors.Is(err, innerErr))
+ require.ErrorIs(t, err, innerErr)
var testErr TestErr
- assert.True(t, errors.As(err, &testErr))
+ require.ErrorAs(t, err, &testErr)
}
diff --git a/fs.go b/fs.go
index f17d743..51c3db8 100644
--- a/fs.go
+++ b/fs.go
@@ -9,37 +9,43 @@ import (
"os"
)
-type onlyFilesFS struct {
- fs http.FileSystem
+// OnlyFilesFS implements an http.FileSystem without `Readdir` functionality.
+type OnlyFilesFS struct {
+ FileSystem http.FileSystem
}
-type neuteredReaddirFile struct {
- http.File
-}
+// Open passes `Open` to the upstream implementation without `Readdir` functionality.
+func (o OnlyFilesFS) Open(name string) (http.File, error) {
+ f, err := o.FileSystem.Open(name)
-// Dir returns a http.FileSystem that can be used by http.FileServer(). It is used internally
-// in router.Static().
-// if listDirectory == true, then it works the same as http.Dir() otherwise it returns
-// a filesystem that prevents http.FileServer() to list the directory files.
-func Dir(root string, listDirectory bool) http.FileSystem {
- fs := http.Dir(root)
- if listDirectory {
- return fs
- }
- return &onlyFilesFS{fs}
-}
-
-// Open conforms to http.Filesystem.
-func (fs onlyFilesFS) Open(name string) (http.File, error) {
- f, err := fs.fs.Open(name)
if err != nil {
return nil, err
}
- return neuteredReaddirFile{f}, nil
+
+ return neutralizedReaddirFile{f}, nil
}
-// Readdir overrides the http.File default implementation.
-func (f neuteredReaddirFile) Readdir(_ int) ([]os.FileInfo, error) {
+// neutralizedReaddirFile wraps http.File with a specific implementation of `Readdir`.
+type neutralizedReaddirFile struct {
+ http.File
+}
+
+// Readdir overrides the http.File default implementation and always returns nil.
+func (n neutralizedReaddirFile) Readdir(_ int) ([]os.FileInfo, error) {
// this disables directory listing
return nil, nil
}
+
+// Dir returns an http.FileSystem that can be used by http.FileServer().
+// It is used internally in router.Static().
+// if listDirectory == true, then it works the same as http.Dir(),
+// otherwise it returns a filesystem that prevents http.FileServer() to list the directory files.
+func Dir(root string, listDirectory bool) http.FileSystem {
+ fs := http.Dir(root)
+
+ if listDirectory {
+ return fs
+ }
+
+ return &OnlyFilesFS{FileSystem: fs}
+}
diff --git a/fs_test.go b/fs_test.go
new file mode 100644
index 0000000..167ac1a
--- /dev/null
+++ b/fs_test.go
@@ -0,0 +1,72 @@
+package gin
+
+import (
+ "errors"
+ "net/http"
+ "os"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+type mockFileSystem struct {
+ open func(name string) (http.File, error)
+}
+
+func (m *mockFileSystem) Open(name string) (http.File, error) {
+ return m.open(name)
+}
+
+func TestOnlyFilesFS_Open(t *testing.T) {
+ var testFile *os.File
+ mockFS := &mockFileSystem{
+ open: func(name string) (http.File, error) {
+ return testFile, nil
+ },
+ }
+ fs := &OnlyFilesFS{FileSystem: mockFS}
+
+ file, err := fs.Open("foo")
+
+ require.NoError(t, err)
+ assert.Equal(t, testFile, file.(neutralizedReaddirFile).File)
+}
+
+func TestOnlyFilesFS_Open_err(t *testing.T) {
+ testError := errors.New("mock")
+ mockFS := &mockFileSystem{
+ open: func(_ string) (http.File, error) {
+ return nil, testError
+ },
+ }
+ fs := &OnlyFilesFS{FileSystem: mockFS}
+
+ file, err := fs.Open("foo")
+
+ require.ErrorIs(t, err, testError)
+ assert.Nil(t, file)
+}
+
+func Test_neuteredReaddirFile_Readdir(t *testing.T) {
+ n := neutralizedReaddirFile{}
+
+ res, err := n.Readdir(0)
+
+ require.NoError(t, err)
+ assert.Nil(t, res)
+}
+
+func TestDir_listDirectory(t *testing.T) {
+ testRoot := "foo"
+ fs := Dir(testRoot, true)
+
+ assert.Equal(t, http.Dir(testRoot), fs)
+}
+
+func TestDir(t *testing.T) {
+ testRoot := "foo"
+ fs := Dir(testRoot, false)
+
+ assert.Equal(t, &OnlyFilesFS{FileSystem: http.Dir(testRoot)}, fs)
+}
diff --git a/gin.go b/gin.go
index 72214e3..856f702 100644
--- a/gin.go
+++ b/gin.go
@@ -17,11 +17,16 @@ import (
"git.company.lan/gopkg/gin/internal/bytesconv"
"git.company.lan/gopkg/gin/render"
+
+ "github.com/quic-go/quic-go/http3"
"golang.org/x/net/http2"
"golang.org/x/net/http2/h2c"
)
const defaultMultipartMemory = 32 << 20 // 32 MB
+const escapedColon = "\\:"
+const colon = ":"
+const backslash = "\\"
var (
default404Body = []byte("404 page not found")
@@ -316,7 +321,7 @@ func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
return engine
}
-// With returns a new Engine instance with the provided options.
+// With returns a Engine with the configuration set in the OptionFunc.
func (engine *Engine) With(opts ...OptionFunc) *Engine {
for _, opt := range opts {
opt(engine)
@@ -383,23 +388,6 @@ func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo {
return routes
}
-// Run attaches the router to a http.Server and starts listening and serving HTTP requests.
-// It is a shortcut for http.ListenAndServe(addr, router)
-// Note: this method will block the calling goroutine indefinitely unless an error happens.
-func (engine *Engine) Run(addr ...string) (err error) {
- defer func() { debugPrintError(err) }()
-
- if engine.isUnsafeTrustedProxies() {
- debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
- "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
- }
-
- address := resolveAddress(addr)
- debugPrint("Listening and serving HTTP on %s\n", address)
- err = http.ListenAndServe(address, engine.Handler())
- return
-}
-
func (engine *Engine) prepareTrustedCIDRs() ([]*net.IPNet, error) {
if engine.trustedProxies == nil {
return nil, nil
@@ -489,6 +477,26 @@ func (engine *Engine) validateHeader(header string) (clientIP string, valid bool
return "", false
}
+// updateRouteTree do update to the route tree recursively
+func updateRouteTree(n *node) {
+ n.path = strings.ReplaceAll(n.path, escapedColon, colon)
+ n.fullPath = strings.ReplaceAll(n.fullPath, escapedColon, colon)
+ n.indices = strings.ReplaceAll(n.indices, backslash, colon)
+ if n.children == nil {
+ return
+ }
+ for _, child := range n.children {
+ updateRouteTree(child)
+ }
+}
+
+// updateRouteTrees do update to the route trees
+func (engine *Engine) updateRouteTrees() {
+ for _, tree := range engine.trees {
+ updateRouteTree(tree.root)
+ }
+}
+
// parseIP parse a string representation of an IP and returns a net.IP with the
// minimum byte representation or nil if input is invalid.
func parseIP(ip string) net.IP {
@@ -503,6 +511,23 @@ func parseIP(ip string) net.IP {
return parsedIP
}
+// Run attaches the router to a http.Server and starts listening and serving HTTP requests.
+// It is a shortcut for http.ListenAndServe(addr, router)
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) Run(addr ...string) (err error) {
+ defer func() { debugPrintError(err) }()
+
+ if engine.isUnsafeTrustedProxies() {
+ debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
+ "Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.")
+ }
+ engine.updateRouteTrees()
+ address := resolveAddress(addr)
+ debugPrint("Listening and serving HTTP on %s\n", address)
+ err = http.ListenAndServe(address, engine.Handler())
+ return
+}
+
// RunTLS attaches the router to a http.Server and starts listening and serving HTTPS (secure) requests.
// It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router)
// Note: this method will block the calling goroutine indefinitely unless an error happens.
@@ -512,7 +537,7 @@ func (engine *Engine) RunTLS(addr, certFile, keyFile string) (err error) {
if engine.isUnsafeTrustedProxies() {
debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
- "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
+ "Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.")
}
err = http.ListenAndServeTLS(addr, certFile, keyFile, engine.Handler())
@@ -564,6 +589,22 @@ func (engine *Engine) RunFd(fd int) (err error) {
return
}
+// RunQUIC attaches the router to a http.Server and starts listening and serving QUIC requests.
+// It is a shortcut for http3.ListenAndServeQUIC(addr, certFile, keyFile, router)
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) RunQUIC(addr, certFile, keyFile string) (err error) {
+ debugPrint("Listening and serving QUIC on %s\n", addr)
+ defer func() { debugPrintError(err) }()
+
+ if engine.isUnsafeTrustedProxies() {
+ debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
+ "Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.")
+ }
+
+ err = http3.ListenAndServeQUIC(addr, certFile, keyFile, engine.Handler())
+ return
+}
+
// RunListener attaches the router to a http.Server and starts listening and serving HTTP requests
// through the specified net.Listener
func (engine *Engine) RunListener(listener net.Listener) (err error) {
@@ -646,7 +687,7 @@ func (engine *Engine) handleHTTPRequest(c *Context) {
break
}
- if engine.HandleMethodNotAllowed {
+ if engine.HandleMethodNotAllowed && len(t) > 0 {
// According to RFC 7231 section 6.5.5, MUST generate an Allow header field in response
// containing a list of the target resource's currently supported methods.
allowed := make([]string, 0, len(t)-1)
diff --git a/gin_integration_test.go b/gin_integration_test.go
index 02b9622..3082bc2 100644
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@@ -21,6 +21,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
// params[0]=url example:http://127.0.0.1:8080/index (cannot be empty)
@@ -40,11 +41,11 @@ func testRequest(t *testing.T, params ...string) {
client := &http.Client{Transport: tr}
resp, err := client.Get(params[0])
- assert.NoError(t, err)
+ require.NoError(t, err)
defer resp.Body.Close()
body, ioerr := io.ReadAll(resp.Body)
- assert.NoError(t, ioerr)
+ require.NoError(t, ioerr)
var responseStatus = "200 OK"
if len(params) > 1 && params[1] != "" {
@@ -73,13 +74,13 @@ func TestRunEmpty(t *testing.T) {
// otherwise the main thread will complete
time.Sleep(5 * time.Millisecond)
- assert.Error(t, router.Run(":8080"))
+ require.Error(t, router.Run(":8080"))
testRequest(t, "http://localhost:8080/example")
}
func TestBadTrustedCIDRs(t *testing.T) {
router := New()
- assert.Error(t, router.SetTrustedProxies([]string{"hello/world"}))
+ require.Error(t, router.SetTrustedProxies([]string{"hello/world"}))
}
/* legacy tests
@@ -87,7 +88,7 @@ func TestBadTrustedCIDRsForRun(t *testing.T) {
os.Setenv("PORT", "")
router := New()
router.TrustedProxies = []string{"hello/world"}
- assert.Error(t, router.Run(":8080"))
+ require.Error(t, router.Run(":8080"))
}
func TestBadTrustedCIDRsForRunUnix(t *testing.T) {
@@ -100,7 +101,7 @@ func TestBadTrustedCIDRsForRunUnix(t *testing.T) {
go func() {
router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
- assert.Error(t, router.RunUnix(unixTestSocket))
+ require.Error(t, router.RunUnix(unixTestSocket))
}()
// have to wait for the goroutine to start and run the server
// otherwise the main thread will complete
@@ -112,15 +113,15 @@ func TestBadTrustedCIDRsForRunFd(t *testing.T) {
router.TrustedProxies = []string{"hello/world"}
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
- assert.NoError(t, err)
+ require.NoError(t, err)
listener, err := net.ListenTCP("tcp", addr)
- assert.NoError(t, err)
+ require.NoError(t, err)
socketFile, err := listener.File()
- assert.NoError(t, err)
+ require.NoError(t, err)
go func() {
router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
- assert.Error(t, router.RunFd(int(socketFile.Fd())))
+ require.Error(t, router.RunFd(int(socketFile.Fd())))
}()
// have to wait for the goroutine to start and run the server
// otherwise the main thread will complete
@@ -132,12 +133,12 @@ func TestBadTrustedCIDRsForRunListener(t *testing.T) {
router.TrustedProxies = []string{"hello/world"}
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
- assert.NoError(t, err)
+ require.NoError(t, err)
listener, err := net.ListenTCP("tcp", addr)
- assert.NoError(t, err)
+ require.NoError(t, err)
go func() {
router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
- assert.Error(t, router.RunListener(listener))
+ require.Error(t, router.RunListener(listener))
}()
// have to wait for the goroutine to start and run the server
// otherwise the main thread will complete
@@ -148,7 +149,7 @@ func TestBadTrustedCIDRsForRunTLS(t *testing.T) {
os.Setenv("PORT", "")
router := New()
router.TrustedProxies = []string{"hello/world"}
- assert.Error(t, router.RunTLS(":8080", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+ require.Error(t, router.RunTLS(":8080", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
}
*/
@@ -164,7 +165,7 @@ func TestRunTLS(t *testing.T) {
// otherwise the main thread will complete
time.Sleep(5 * time.Millisecond)
- assert.Error(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+ require.Error(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
testRequest(t, "https://localhost:8443/example")
}
@@ -201,7 +202,7 @@ func TestPusher(t *testing.T) {
// otherwise the main thread will complete
time.Sleep(5 * time.Millisecond)
- assert.Error(t, router.RunTLS(":8449", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+ require.Error(t, router.RunTLS(":8449", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
testRequest(t, "https://localhost:8449/pusher")
}
@@ -216,14 +217,14 @@ func TestRunEmptyWithEnv(t *testing.T) {
// otherwise the main thread will complete
time.Sleep(5 * time.Millisecond)
- assert.Error(t, router.Run(":3123"))
+ require.Error(t, router.Run(":3123"))
testRequest(t, "http://localhost:3123/example")
}
func TestRunTooMuchParams(t *testing.T) {
router := New()
assert.Panics(t, func() {
- assert.NoError(t, router.Run("2", "2"))
+ require.NoError(t, router.Run("2", "2"))
})
}
@@ -237,7 +238,7 @@ func TestRunWithPort(t *testing.T) {
// otherwise the main thread will complete
time.Sleep(5 * time.Millisecond)
- assert.Error(t, router.Run(":5150"))
+ require.Error(t, router.Run(":5150"))
testRequest(t, "http://localhost:5150/example")
}
@@ -257,7 +258,7 @@ func TestUnixSocket(t *testing.T) {
time.Sleep(5 * time.Millisecond)
c, err := net.Dial("unix", unixTestSocket)
- assert.NoError(t, err)
+ require.NoError(t, err)
fmt.Fprint(c, "GET /example HTTP/1.0\r\n\r\n")
scanner := bufio.NewScanner(c)
@@ -271,22 +272,38 @@ func TestUnixSocket(t *testing.T) {
func TestBadUnixSocket(t *testing.T) {
router := New()
- assert.Error(t, router.RunUnix("#/tmp/unix_unit_test"))
+ require.Error(t, router.RunUnix("#/tmp/unix_unit_test"))
+}
+
+func TestRunQUIC(t *testing.T) {
+ router := New()
+ go func() {
+ router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
+
+ assert.NoError(t, router.RunQUIC(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+ }()
+
+ // have to wait for the goroutine to start and run the server
+ // otherwise the main thread will complete
+ time.Sleep(5 * time.Millisecond)
+
+ require.Error(t, router.RunQUIC(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
+ testRequest(t, "https://localhost:8443/example")
}
func TestFileDescriptor(t *testing.T) {
router := New()
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
- assert.NoError(t, err)
+ require.NoError(t, err)
listener, err := net.ListenTCP("tcp", addr)
- assert.NoError(t, err)
+ require.NoError(t, err)
socketFile, err := listener.File()
if isWindows() {
// not supported by windows, it is unimplemented now
- assert.Error(t, err)
+ require.Error(t, err)
} else {
- assert.NoError(t, err)
+ require.NoError(t, err)
}
if socketFile == nil {
@@ -302,7 +319,7 @@ func TestFileDescriptor(t *testing.T) {
time.Sleep(5 * time.Millisecond)
c, err := net.Dial("tcp", listener.Addr().String())
- assert.NoError(t, err)
+ require.NoError(t, err)
fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
scanner := bufio.NewScanner(c)
@@ -316,15 +333,15 @@ func TestFileDescriptor(t *testing.T) {
func TestBadFileDescriptor(t *testing.T) {
router := New()
- assert.Error(t, router.RunFd(0))
+ require.Error(t, router.RunFd(0))
}
func TestListener(t *testing.T) {
router := New()
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
- assert.NoError(t, err)
+ require.NoError(t, err)
listener, err := net.ListenTCP("tcp", addr)
- assert.NoError(t, err)
+ require.NoError(t, err)
go func() {
router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
assert.NoError(t, router.RunListener(listener))
@@ -334,7 +351,7 @@ func TestListener(t *testing.T) {
time.Sleep(5 * time.Millisecond)
c, err := net.Dial("tcp", listener.Addr().String())
- assert.NoError(t, err)
+ require.NoError(t, err)
fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
scanner := bufio.NewScanner(c)
@@ -349,11 +366,11 @@ func TestListener(t *testing.T) {
func TestBadListener(t *testing.T) {
router := New()
addr, err := net.ResolveTCPAddr("tcp", "localhost:10086")
- assert.NoError(t, err)
+ require.NoError(t, err)
listener, err := net.ListenTCP("tcp", addr)
- assert.NoError(t, err)
+ require.NoError(t, err)
listener.Close()
- assert.Error(t, router.RunListener(listener))
+ require.Error(t, router.RunListener(listener))
}
func TestWithHttptestWithAutoSelectedPort(t *testing.T) {
@@ -379,7 +396,14 @@ func TestConcurrentHandleContext(t *testing.T) {
wg.Add(iterations)
for i := 0; i < iterations; i++ {
go func() {
- testGetRequestHandler(t, router, "/")
+ req, err := http.NewRequest(http.MethodGet, "/", nil)
+ assert.NoError(t, err)
+
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+
+ assert.Equal(t, "it worked", w.Body.String(), "resp body should match")
+ assert.Equal(t, 200, w.Code, "should get a 200")
wg.Done()
}()
}
@@ -401,17 +425,6 @@ func TestConcurrentHandleContext(t *testing.T) {
// testRequest(t, "http://localhost:8033/example")
// }
-func testGetRequestHandler(t *testing.T, h http.Handler, url string) {
- req, err := http.NewRequest(http.MethodGet, url, nil)
- assert.NoError(t, err)
-
- w := httptest.NewRecorder()
- h.ServeHTTP(w, req)
-
- assert.Equal(t, "it worked", w.Body.String(), "resp body should match")
- assert.Equal(t, 200, w.Code, "should get a 200")
-}
-
func TestTreeRunDynamicRouting(t *testing.T) {
router := New()
router.GET("/aa/*xx", func(c *Context) { c.String(http.StatusOK, "/aa/*xx") })
@@ -561,3 +574,28 @@ func TestTreeRunDynamicRouting(t *testing.T) {
func isWindows() bool {
return runtime.GOOS == "windows"
}
+
+func TestEscapedColon(t *testing.T) {
+ router := New()
+ f := func(u string) {
+ router.GET(u, func(c *Context) { c.String(http.StatusOK, u) })
+ }
+ f("/r/r\\:r")
+ f("/r/r:r")
+ f("/r/r/:r")
+ f("/r/r/\\:r")
+ f("/r/r/r\\:r")
+ assert.Panics(t, func() {
+ f("\\foo:")
+ })
+
+ router.updateRouteTrees()
+ ts := httptest.NewServer(router)
+ defer ts.Close()
+
+ testRequest(t, ts.URL+"/r/r123", "", "/r/r:r")
+ testRequest(t, ts.URL+"/r/r:r", "", "/r/r\\:r")
+ testRequest(t, ts.URL+"/r/r/r123", "", "/r/r/:r")
+ testRequest(t, ts.URL+"/r/r/:r", "", "/r/r/\\:r")
+ testRequest(t, ts.URL+"/r/r/r:r", "", "/r/r/r\\:r")
+}
diff --git a/gin_test.go b/gin_test.go
index eb8ad1c..f6eb558 100644
--- a/gin_test.go
+++ b/gin_test.go
@@ -20,6 +20,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"golang.org/x/net/http2"
)
@@ -547,10 +548,10 @@ func TestEngineHandleContextManyReEntries(t *testing.T) {
r.GET("/:count", func(c *Context) {
countStr := c.Param("count")
count, err := strconv.Atoi(countStr)
- assert.NoError(t, err)
+ require.NoError(t, err)
n, err := c.Writer.Write([]byte("."))
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, 1, n)
switch {
@@ -580,7 +581,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
expectedTrustedCIDRs := []*net.IPNet{parseCIDR("0.0.0.0/0")}
err := r.SetTrustedProxies([]string{"0.0.0.0/0"})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, expectedTrustedCIDRs, r.trustedCIDRs)
}
@@ -588,7 +589,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
{
err := r.SetTrustedProxies([]string{"192.168.1.33/33"})
- assert.Error(t, err)
+ require.Error(t, err)
}
// valid ipv4 address
@@ -597,7 +598,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
err := r.SetTrustedProxies([]string{"192.168.1.33"})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, expectedTrustedCIDRs, r.trustedCIDRs)
}
@@ -605,7 +606,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
{
err := r.SetTrustedProxies([]string{"192.168.1.256"})
- assert.Error(t, err)
+ require.Error(t, err)
}
// valid ipv6 address
@@ -613,7 +614,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
expectedTrustedCIDRs := []*net.IPNet{parseCIDR("2002:0000:0000:1234:abcd:ffff:c0a8:0101/128")}
err := r.SetTrustedProxies([]string{"2002:0000:0000:1234:abcd:ffff:c0a8:0101"})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, expectedTrustedCIDRs, r.trustedCIDRs)
}
@@ -621,7 +622,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
{
err := r.SetTrustedProxies([]string{"gggg:0000:0000:1234:abcd:ffff:c0a8:0101"})
- assert.Error(t, err)
+ require.Error(t, err)
}
// valid ipv6 cidr
@@ -629,7 +630,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
expectedTrustedCIDRs := []*net.IPNet{parseCIDR("::/0")}
err := r.SetTrustedProxies([]string{"::/0"})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, expectedTrustedCIDRs, r.trustedCIDRs)
}
@@ -637,7 +638,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
{
err := r.SetTrustedProxies([]string{"gggg:0000:0000:1234:abcd:ffff:c0a8:0101/129"})
- assert.Error(t, err)
+ require.Error(t, err)
}
// valid combination
@@ -653,7 +654,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
"172.16.0.1",
})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, expectedTrustedCIDRs, r.trustedCIDRs)
}
@@ -665,7 +666,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
"172.16.0.256",
})
- assert.Error(t, err)
+ require.Error(t, err)
}
// nil value
@@ -673,7 +674,7 @@ func TestPrepareTrustedCIRDsWith(t *testing.T) {
err := r.SetTrustedProxies(nil)
assert.Nil(t, r.trustedCIDRs)
- assert.Nil(t, err)
+ require.NoError(t, err)
}
}
@@ -754,3 +755,14 @@ func TestCustomUnmarshalStruct(t *testing.T) {
assert.Equal(t, 200, w.Code)
assert.Equal(t, `"2000/01/01"`, w.Body.String())
}
+
+// Test the fix for https://github.com/gin-gonic/gin/issues/4002
+func TestMethodNotAllowedNoRoute(t *testing.T) {
+ g := New()
+ g.HandleMethodNotAllowed = true
+
+ req := httptest.NewRequest("GET", "/", nil)
+ resp := httptest.NewRecorder()
+ assert.NotPanics(t, func() { g.ServeHTTP(resp, req) })
+ assert.Equal(t, http.StatusNotFound, resp.Code)
+}
diff --git a/githubapi_test.go b/githubapi_test.go
index 9276bed..6d34878 100644
--- a/githubapi_test.go
+++ b/githubapi_test.go
@@ -14,6 +14,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
type route struct {
@@ -295,9 +296,9 @@ func TestShouldBindUri(t *testing.T) {
}
router.Handle(http.MethodGet, "/rest/:name/:id", func(c *Context) {
var person Person
- assert.NoError(t, c.ShouldBindUri(&person))
- assert.True(t, person.Name != "")
- assert.True(t, person.ID != "")
+ require.NoError(t, c.ShouldBindUri(&person))
+ assert.NotEqual(t, "", person.Name)
+ assert.NotEqual(t, "", person.ID)
c.String(http.StatusOK, "ShouldBindUri test OK")
})
@@ -317,9 +318,9 @@ func TestBindUri(t *testing.T) {
}
router.Handle(http.MethodGet, "/rest/:name/:id", func(c *Context) {
var person Person
- assert.NoError(t, c.BindUri(&person))
- assert.True(t, person.Name != "")
- assert.True(t, person.ID != "")
+ require.NoError(t, c.BindUri(&person))
+ assert.NotEqual(t, "", person.Name)
+ assert.NotEqual(t, "", person.ID)
c.String(http.StatusOK, "BindUri test OK")
})
@@ -338,7 +339,7 @@ func TestBindUriError(t *testing.T) {
}
router.Handle(http.MethodGet, "/new/rest/:num", func(c *Context) {
var m Member
- assert.Error(t, c.BindUri(&m))
+ require.Error(t, c.BindUri(&m))
})
path1, _ := exampleFromPath("/new/rest/:num")
diff --git a/go.mod b/go.mod
index 29a3e9c..1b61141 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
module git.company.lan/gopkg/gin
-go 1.20
+go 1.21.0
require (
git.company.lan/gopkg/gin-sse v0.0.0-20241025130024-44e95010056c
@@ -10,9 +10,10 @@ require (
github.com/json-iterator/go v1.1.12
github.com/mattn/go-isatty v0.0.20
github.com/pelletier/go-toml/v2 v2.2.2
+ github.com/quic-go/quic-go v0.43.1
github.com/stretchr/testify v1.9.0
github.com/ugorji/go/codec v1.2.12
- golang.org/x/net v0.25.0
+ golang.org/x/net v0.27.0
google.golang.org/protobuf v1.34.1
gopkg.in/yaml.v3 v3.0.1
)
@@ -25,14 +26,23 @@ require (
github.com/gabriel-vasile/mimetype v1.4.3 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
+ github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
+ github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 // indirect
github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+ github.com/kr/pretty v0.3.1 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
+ github.com/onsi/ginkgo/v2 v2.9.5 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
+ github.com/quic-go/qpack v0.4.0 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+ go.uber.org/mock v0.4.0 // indirect
golang.org/x/arch v0.8.0 // indirect
- golang.org/x/crypto v0.23.0 // indirect
- golang.org/x/sys v0.20.0 // indirect
- golang.org/x/text v0.15.0 // indirect
+ golang.org/x/crypto v0.25.0 // indirect
+ golang.org/x/exp v0.0.0-20221205204356-47842c84f3db // indirect
+ golang.org/x/mod v0.17.0 // indirect
+ golang.org/x/sys v0.22.0 // indirect
+ golang.org/x/text v0.16.0 // indirect
+ golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
)
diff --git a/go.sum b/go.sum
index f3ee378..d513936 100644
--- a/go.sum
+++ b/go.sum
@@ -4,32 +4,51 @@ github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc
github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
+github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
-github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 h1:yAJXTCF9TqKcTiHJAE8dj7HMvPfh66eeA2JYW7eFpSE=
+github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -39,15 +58,27 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/onsi/ginkgo/v2 v2.9.5 h1:+6Hr4uxzP4XIUyAkg61dWBw8lb/gc4/X5luuxN/EC+Q=
+github.com/onsi/ginkgo/v2 v2.9.5/go.mod h1:tvAoo1QUJwNEU2ITftXTpR7R1RbCzoZUOs3RonqW57k=
+github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
+github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
+github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
+github.com/quic-go/quic-go v0.43.1 h1:fLiMNfQVe9q2JvSsiXo4fXOEguXHGGl9+6gLp4RPeZQ=
+github.com/quic-go/quic-go v0.43.1/go.mod h1:132kz4kL3F9vxhW3CtQJLDVwcFe5wdWeJXXijhsO57M=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
@@ -59,24 +90,37 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
+go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
-golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
+golang.org/x/exp v0.0.0-20221205204356-47842c84f3db h1:D/cFflL63o2KSLJIwjlcIt8PR064j/xsmdEJL/YvY/o=
+golang.org/x/exp v0.0.0-20221205204356-47842c84f3db/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
+golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/internal/bytesconv/bytesconv_1.20.go b/internal/bytesconv/bytesconv.go
similarity index 97%
rename from internal/bytesconv/bytesconv_1.20.go
rename to internal/bytesconv/bytesconv.go
index 5b6040a..a02c53c 100644
--- a/internal/bytesconv/bytesconv_1.20.go
+++ b/internal/bytesconv/bytesconv.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.
-//go:build go1.20
-
package bytesconv
import (
diff --git a/internal/bytesconv/bytesconv_1.19.go b/internal/bytesconv/bytesconv_1.19.go
deleted file mode 100644
index 669c9c9..0000000
--- a/internal/bytesconv/bytesconv_1.19.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2020 Gin Core Team. All rights reserved.
-// Use of this source code is governed by a MIT style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.20
-
-package bytesconv
-
-import (
- "unsafe"
-)
-
-// StringToBytes converts string to byte slice without a memory allocation.
-func StringToBytes(s string) []byte {
- return *(*[]byte)(unsafe.Pointer(
- &struct {
- string
- Cap int
- }{s, len(s)},
- ))
-}
-
-// BytesToString converts byte slice to string without a memory allocation.
-func BytesToString(b []byte) string {
- return *(*string)(unsafe.Pointer(&b))
-}
diff --git a/logger_test.go b/logger_test.go
index 6c1814d..b05df74 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -329,13 +329,13 @@ func TestIsOutputColor(t *testing.T) {
}
consoleColorMode = autoColor
- assert.Equal(t, true, p.IsOutputColor())
+ assert.True(t, p.IsOutputColor())
ForceConsoleColor()
- assert.Equal(t, true, p.IsOutputColor())
+ assert.True(t, p.IsOutputColor())
DisableConsoleColor()
- assert.Equal(t, false, p.IsOutputColor())
+ assert.False(t, p.IsOutputColor())
// test with isTerm flag false.
p = LogFormatterParams{
@@ -343,13 +343,13 @@ func TestIsOutputColor(t *testing.T) {
}
consoleColorMode = autoColor
- assert.Equal(t, false, p.IsOutputColor())
+ assert.False(t, p.IsOutputColor())
ForceConsoleColor()
- assert.Equal(t, true, p.IsOutputColor())
+ assert.True(t, p.IsOutputColor())
DisableConsoleColor()
- assert.Equal(t, false, p.IsOutputColor())
+ assert.False(t, p.IsOutputColor())
// reset console color mode.
consoleColorMode = autoColor
diff --git a/mode.go b/mode.go
index 667f6ee..fcbb57c 100644
--- a/mode.go
+++ b/mode.go
@@ -8,6 +8,7 @@ import (
"flag"
"io"
"os"
+ "sync/atomic"
"git.company.lan/gopkg/gin/binding"
)
@@ -43,10 +44,8 @@ var DefaultWriter io.Writer = os.Stdout
// DefaultErrorWriter is the default io.Writer used by Gin to debug errors
var DefaultErrorWriter io.Writer = os.Stderr
-var (
- ginMode = debugCode
- modeName = DebugMode
-)
+var ginMode int32 = debugCode
+var modeName atomic.Value
func init() {
mode := os.Getenv(EnvGinMode)
@@ -64,17 +63,16 @@ func SetMode(value string) {
}
switch value {
- case DebugMode:
- ginMode = debugCode
+ case DebugMode, "":
+ atomic.StoreInt32(&ginMode, debugCode)
case ReleaseMode:
- ginMode = releaseCode
+ atomic.StoreInt32(&ginMode, releaseCode)
case TestMode:
- ginMode = testCode
+ atomic.StoreInt32(&ginMode, testCode)
default:
panic("gin mode unknown: " + value + " (available mode: debug release test)")
}
-
- modeName = value
+ modeName.Store(value)
}
// DisableBindValidation closes the default validator.
@@ -96,5 +94,5 @@ func EnableJsonDecoderDisallowUnknownFields() {
// Mode returns current gin mode.
func Mode() string {
- return modeName
+ return modeName.Load().(string)
}
diff --git a/mode_test.go b/mode_test.go
index 1ed9908..2efdcdc 100644
--- a/mode_test.go
+++ b/mode_test.go
@@ -5,8 +5,8 @@
package gin
import (
- "flag"
"os"
+ "sync/atomic"
"testing"
"git.company.lan/gopkg/gin/binding"
@@ -18,31 +18,24 @@ func init() {
}
func TestSetMode(t *testing.T) {
- assert.Equal(t, testCode, ginMode)
+ assert.Equal(t, int32(testCode), atomic.LoadInt32(&ginMode))
assert.Equal(t, TestMode, Mode())
os.Unsetenv(EnvGinMode)
SetMode("")
- assert.Equal(t, testCode, ginMode)
+ assert.Equal(t, int32(testCode), atomic.LoadInt32(&ginMode))
assert.Equal(t, TestMode, Mode())
- tmp := flag.CommandLine
- flag.CommandLine = flag.NewFlagSet("", flag.ContinueOnError)
- SetMode("")
- assert.Equal(t, debugCode, ginMode)
- assert.Equal(t, DebugMode, Mode())
- flag.CommandLine = tmp
-
SetMode(DebugMode)
- assert.Equal(t, debugCode, ginMode)
+ assert.Equal(t, int32(debugCode), atomic.LoadInt32(&ginMode))
assert.Equal(t, DebugMode, Mode())
SetMode(ReleaseMode)
- assert.Equal(t, releaseCode, ginMode)
+ assert.Equal(t, int32(releaseCode), atomic.LoadInt32(&ginMode))
assert.Equal(t, ReleaseMode, Mode())
SetMode(TestMode)
- assert.Equal(t, testCode, ginMode)
+ assert.Equal(t, int32(testCode), atomic.LoadInt32(&ginMode))
assert.Equal(t, TestMode, Mode())
assert.Panics(t, func() { SetMode("unknown") })
diff --git a/path_test.go b/path_test.go
index 864302f..2269b78 100644
--- a/path_test.go
+++ b/path_test.go
@@ -87,7 +87,7 @@ func TestPathCleanMallocs(t *testing.T) {
for _, test := range cleanTests {
allocs := testing.AllocsPerRun(100, func() { cleanPath(test.result) })
- assert.EqualValues(t, allocs, 0)
+ assert.InDelta(t, 0, allocs, 0.01)
}
}
diff --git a/render/render_msgpack_test.go b/render/render_msgpack_test.go
index db4b71e..579897c 100644
--- a/render/render_msgpack_test.go
+++ b/render/render_msgpack_test.go
@@ -12,6 +12,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"github.com/ugorji/go/codec"
)
@@ -29,7 +30,7 @@ func TestRenderMsgPack(t *testing.T) {
err := (MsgPack{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
h := new(codec.MsgpackHandle)
assert.NotNil(t, h)
@@ -37,7 +38,7 @@ func TestRenderMsgPack(t *testing.T) {
assert.NotNil(t, buf)
err = codec.NewEncoder(buf, h).Encode(data)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, w.Body.String(), buf.String())
assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
}
diff --git a/render/render_test.go b/render/render_test.go
index bf74852..7c18cfe 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -18,6 +18,7 @@ import (
"git.company.lan/gopkg/gin/internal/json"
testdata "git.company.lan/gopkg/gin/testdata/protoexample"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"google.golang.org/protobuf/proto"
)
@@ -36,7 +37,7 @@ func TestRenderJSON(t *testing.T) {
err := (JSON{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}", w.Body.String())
assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -46,7 +47,7 @@ func TestRenderJSONError(t *testing.T) {
data := make(chan int)
// json: unsupported type: chan int
- assert.Error(t, (JSON{data}).Render(w))
+ require.Error(t, (JSON{data}).Render(w))
}
func TestRenderIndentedJSON(t *testing.T) {
@@ -58,7 +59,7 @@ func TestRenderIndentedJSON(t *testing.T) {
err := (IndentedJSON{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "{\n \"bar\": \"foo\",\n \"foo\": \"bar\"\n}", w.Body.String())
assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -69,7 +70,7 @@ func TestRenderIndentedJSONPanics(t *testing.T) {
// json: unsupported type: chan int
err := (IndentedJSON{data}).Render(w)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestRenderSecureJSON(t *testing.T) {
@@ -83,7 +84,7 @@ func TestRenderSecureJSON(t *testing.T) {
err1 := (SecureJSON{"while(1);", data}).Render(w1)
- assert.NoError(t, err1)
+ require.NoError(t, err1)
assert.Equal(t, "{\"foo\":\"bar\"}", w1.Body.String())
assert.Equal(t, "application/json; charset=utf-8", w1.Header().Get("Content-Type"))
@@ -95,7 +96,7 @@ func TestRenderSecureJSON(t *testing.T) {
}}
err2 := (SecureJSON{"while(1);", datas}).Render(w2)
- assert.NoError(t, err2)
+ require.NoError(t, err2)
assert.Equal(t, "while(1);[{\"foo\":\"bar\"},{\"bar\":\"foo\"}]", w2.Body.String())
assert.Equal(t, "application/json; charset=utf-8", w2.Header().Get("Content-Type"))
}
@@ -106,7 +107,7 @@ func TestRenderSecureJSONFail(t *testing.T) {
// json: unsupported type: chan int
err := (SecureJSON{"while(1);", data}).Render(w)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestRenderJsonpJSON(t *testing.T) {
@@ -120,7 +121,7 @@ func TestRenderJsonpJSON(t *testing.T) {
err1 := (JsonpJSON{"x", data}).Render(w1)
- assert.NoError(t, err1)
+ require.NoError(t, err1)
assert.Equal(t, "x({\"foo\":\"bar\"});", w1.Body.String())
assert.Equal(t, "application/javascript; charset=utf-8", w1.Header().Get("Content-Type"))
@@ -132,7 +133,7 @@ func TestRenderJsonpJSON(t *testing.T) {
}}
err2 := (JsonpJSON{"x", datas}).Render(w2)
- assert.NoError(t, err2)
+ require.NoError(t, err2)
assert.Equal(t, "x([{\"foo\":\"bar\"},{\"bar\":\"foo\"}]);", w2.Body.String())
assert.Equal(t, "application/javascript; charset=utf-8", w2.Header().Get("Content-Type"))
}
@@ -191,7 +192,7 @@ func TestRenderJsonpJSONError2(t *testing.T) {
assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
e := (JsonpJSON{"", data}).Render(w)
- assert.NoError(t, e)
+ require.NoError(t, e)
assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
assert.Equal(t, "application/javascript; charset=utf-8", w.Header().Get("Content-Type"))
@@ -203,7 +204,7 @@ func TestRenderJsonpJSONFail(t *testing.T) {
// json: unsupported type: chan int
err := (JsonpJSON{"x", data}).Render(w)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestRenderAsciiJSON(t *testing.T) {
@@ -215,7 +216,7 @@ func TestRenderAsciiJSON(t *testing.T) {
err := (AsciiJSON{data1}).Render(w1)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "{\"lang\":\"GO\\u8bed\\u8a00\",\"tag\":\"\\u003cbr\\u003e\"}", w1.Body.String())
assert.Equal(t, "application/json", w1.Header().Get("Content-Type"))
@@ -223,7 +224,7 @@ func TestRenderAsciiJSON(t *testing.T) {
data2 := 3.1415926
err = (AsciiJSON{data2}).Render(w2)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "3.1415926", w2.Body.String())
}
@@ -232,7 +233,7 @@ func TestRenderAsciiJSONFail(t *testing.T) {
data := make(chan int)
// json: unsupported type: chan int
- assert.Error(t, (AsciiJSON{data}).Render(w))
+ require.Error(t, (AsciiJSON{data}).Render(w))
}
func TestRenderPureJSON(t *testing.T) {
@@ -242,7 +243,7 @@ func TestRenderPureJSON(t *testing.T) {
"html": "",
}
err := (PureJSON{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\"}\n", w.Body.String())
assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -283,7 +284,7 @@ b:
assert.Equal(t, "application/yaml; charset=utf-8", w.Header().Get("Content-Type"))
err := (YAML{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "|4-\n a : Easy!\n b:\n \tc: 2\n \td: [3, 4]\n \t\n", w.Body.String())
assert.Equal(t, "application/yaml; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -298,7 +299,7 @@ func (ft *fail) MarshalYAML() (any, error) {
func TestRenderYAMLFail(t *testing.T) {
w := httptest.NewRecorder()
err := (YAML{&fail{}}).Render(w)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestRenderTOML(t *testing.T) {
@@ -311,7 +312,7 @@ func TestRenderTOML(t *testing.T) {
assert.Equal(t, "application/toml; charset=utf-8", w.Header().Get("Content-Type"))
err := (TOML{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "foo = 'bar'\nhtml = ''\n", w.Body.String())
assert.Equal(t, "application/toml; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -319,7 +320,7 @@ func TestRenderTOML(t *testing.T) {
func TestRenderTOMLFail(t *testing.T) {
w := httptest.NewRecorder()
err := (TOML{net.IPv4bcast}).Render(w)
- assert.Error(t, err)
+ require.Error(t, err)
}
// test Protobuf rendering
@@ -334,12 +335,12 @@ func TestRenderProtoBuf(t *testing.T) {
(ProtoBuf{data}).WriteContentType(w)
protoData, err := proto.Marshal(data)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
err = (ProtoBuf{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, string(protoData), w.Body.String())
assert.Equal(t, "application/x-protobuf", w.Header().Get("Content-Type"))
}
@@ -348,7 +349,7 @@ func TestRenderProtoBufFail(t *testing.T) {
w := httptest.NewRecorder()
data := &testdata.Test{}
err := (ProtoBuf{data}).Render(w)
- assert.Error(t, err)
+ require.Error(t, err)
}
func TestRenderXML(t *testing.T) {
@@ -362,14 +363,14 @@ func TestRenderXML(t *testing.T) {
err := (XML{data}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "", w.Body.String())
assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
}
func TestRenderRedirect(t *testing.T) {
req, err := http.NewRequest("GET", "/test-redirect", nil)
- assert.NoError(t, err)
+ require.NoError(t, err)
data1 := Redirect{
Code: http.StatusMovedPermanently,
@@ -379,7 +380,7 @@ func TestRenderRedirect(t *testing.T) {
w := httptest.NewRecorder()
err = data1.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
data2 := Redirect{
Code: http.StatusOK,
@@ -390,7 +391,7 @@ func TestRenderRedirect(t *testing.T) {
w = httptest.NewRecorder()
assert.PanicsWithValue(t, "Cannot redirect with status code 200", func() {
err := data2.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
})
data3 := Redirect{
@@ -401,7 +402,7 @@ func TestRenderRedirect(t *testing.T) {
w = httptest.NewRecorder()
err = data3.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
// only improve coverage
data2.WriteContentType(w)
@@ -416,7 +417,7 @@ func TestRenderData(t *testing.T) {
Data: data,
}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "#!PNG some raw data", w.Body.String())
assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
}
@@ -435,7 +436,7 @@ func TestRenderString(t *testing.T) {
Data: []any{"manu", 2},
}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "hola manu 2", w.Body.String())
assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -448,7 +449,7 @@ func TestRenderStringLenZero(t *testing.T) {
Data: []any{},
}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "hola %s %d", w.Body.String())
assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -464,7 +465,7 @@ func TestRenderHTMLTemplate(t *testing.T) {
err := instance.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "Hello alexandernyquist", w.Body.String())
assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -480,7 +481,7 @@ func TestRenderHTMLTemplateEmptyName(t *testing.T) {
err := instance.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "Hello alexandernyquist", w.Body.String())
assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -499,7 +500,7 @@ func TestRenderHTMLDebugFiles(t *testing.T) {
err := instance.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "Hello thinkerou
", w.Body.String())
assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -518,7 +519,7 @@ func TestRenderHTMLDebugGlob(t *testing.T) {
err := instance.Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, "Hello thinkerou
", w.Body.String())
assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
}
@@ -548,7 +549,7 @@ func TestRenderReader(t *testing.T) {
Headers: headers,
}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, body, w.Body.String())
assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
assert.Equal(t, strconv.Itoa(len(body)), w.Header().Get("Content-Length"))
@@ -571,7 +572,7 @@ func TestRenderReaderNoContentLength(t *testing.T) {
Headers: headers,
}).Render(w)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, body, w.Body.String())
assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
assert.NotContains(t, "Content-Length", w.Header())
@@ -588,6 +589,6 @@ func TestRenderWriteError(t *testing.T) {
ResponseRecorder: httptest.NewRecorder(),
}
err := r.Render(ew)
- assert.NotNil(t, err)
+ require.Error(t, err)
assert.Equal(t, `write "my-prefix:" error`, err.Error())
}
diff --git a/response_writer_test.go b/response_writer_test.go
index 964aa30..259b8fa 100644
--- a/response_writer_test.go
+++ b/response_writer_test.go
@@ -10,6 +10,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
// TODO
@@ -95,13 +96,13 @@ func TestResponseWriterWrite(t *testing.T) {
assert.Equal(t, http.StatusOK, w.Status())
assert.Equal(t, http.StatusOK, testWriter.Code)
assert.Equal(t, "hola", testWriter.Body.String())
- assert.NoError(t, err)
+ require.NoError(t, err)
n, err = w.Write([]byte(" adios"))
assert.Equal(t, 6, n)
assert.Equal(t, 10, w.Size())
assert.Equal(t, "hola adios", testWriter.Body.String())
- assert.NoError(t, err)
+ require.NoError(t, err)
}
func TestResponseWriterHijack(t *testing.T) {
@@ -112,7 +113,7 @@ func TestResponseWriterHijack(t *testing.T) {
assert.Panics(t, func() {
_, _, err := w.Hijack()
- assert.NoError(t, err)
+ require.NoError(t, err)
})
assert.True(t, w.Written())
@@ -135,7 +136,7 @@ func TestResponseWriterFlush(t *testing.T) {
// should return 500
resp, err := http.Get(testServer.URL)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, http.StatusInternalServerError, resp.StatusCode)
}
diff --git a/routergroup.go b/routergroup.go
index c833fe8..b2540ec 100644
--- a/routergroup.go
+++ b/routergroup.go
@@ -218,7 +218,7 @@ func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileS
fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
return func(c *Context) {
- if _, noListing := fs.(*onlyFilesFS); noListing {
+ if _, noListing := fs.(*OnlyFilesFS); noListing {
c.Writer.WriteHeader(http.StatusNotFound)
}
diff --git a/routes_test.go b/routes_test.go
index 73f393e..d6233b0 100644
--- a/routes_test.go
+++ b/routes_test.go
@@ -13,6 +13,7 @@ import (
"testing"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
type header struct {
@@ -386,7 +387,7 @@ func TestRouteStaticFile(t *testing.T) {
}
defer os.Remove(f.Name())
_, err = f.WriteString("Gin Web Framework")
- assert.NoError(t, err)
+ require.NoError(t, err)
f.Close()
dir, filename := filepath.Split(f.Name())
@@ -421,7 +422,7 @@ func TestRouteStaticFileFS(t *testing.T) {
}
defer os.Remove(f.Name())
_, err = f.WriteString("Gin Web Framework")
- assert.NoError(t, err)
+ require.NoError(t, err)
f.Close()
dir, filename := filepath.Split(f.Name())
@@ -484,7 +485,7 @@ func TestRouterMiddlewareAndStatic(t *testing.T) {
// Content-Type='text/plain; charset=utf-8' when go version <= 1.16,
// else, Content-Type='text/x-go; charset=utf-8'
assert.NotEqual(t, "", w.Header().Get("Content-Type"))
- assert.NotEqual(t, w.Header().Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST")
+ assert.NotEqual(t, "Mon, 02 Jan 2006 15:04:05 MST", w.Header().Get("Last-Modified"))
assert.Equal(t, "Mon, 02 Jan 2006 15:04:05 MST", w.Header().Get("Expires"))
assert.Equal(t, "Gin Framework", w.Header().Get("x-GIN"))
}
diff --git a/tree.go b/tree.go
index 2b3edb4..a4b7f8b 100644
--- a/tree.go
+++ b/tree.go
@@ -65,17 +65,10 @@ func (trees methodTrees) get(method string) *node {
return nil
}
-func min(a, b int) int {
- if a <= b {
- return a
- }
- return b
-}
-
func longestCommonPrefix(a, b string) int {
i := 0
- max := min(len(a), len(b))
- for i < max && a[i] == b[i] {
+ max_ := min(len(a), len(b))
+ for i < max_ && a[i] == b[i] {
i++
}
return i
@@ -205,7 +198,7 @@ walk:
}
// Check if a child with the next path byte exists
- for i, max := 0, len(n.indices); i < max; i++ {
+ for i, max_ := 0, len(n.indices); i < max_; i++ {
if c == n.indices[i] {
parentFullPathIndex += len(n.path)
i = n.incrementChildPrio(i)
@@ -269,7 +262,19 @@ walk:
// Returns -1 as index, if no wildcard was found.
func findWildcard(path string) (wildcard string, i int, valid bool) {
// Find start
+ escapeColon := false
for start, c := range []byte(path) {
+ if escapeColon {
+ escapeColon = false
+ if c == ':' {
+ continue
+ }
+ panic("invalid escape string in path '" + path + "'")
+ }
+ if c == '\\' {
+ escapeColon = true
+ continue
+ }
// A wildcard starts with ':' (param) or '*' (catch-all)
if c != ':' && c != '*' {
continue
@@ -364,7 +369,7 @@ func (n *node) insertChild(path string, fullPath string, handlers HandlersChain)
// currently fixed width 1 for '/'
i--
- if path[i] != '/' {
+ if i < 0 || path[i] != '/' {
panic("no / before catch-all in path '" + fullPath + "'")
}
@@ -770,7 +775,7 @@ walk: // Outer loop for walking the tree
// Runes are up to 4 byte long,
// -4 would definitely be another rune.
var off int
- for max := min(npLen, 3); off < max; off++ {
+ for max_ := min(npLen, 3); off < max_; off++ {
if i := npLen - off; utf8.RuneStart(oldPath[i]) {
// read rune from cached path
rv, _ = utf8.DecodeRuneInString(oldPath[i:])
diff --git a/tree_test.go b/tree_test.go
index c9b0313..74eb610 100644
--- a/tree_test.go
+++ b/tree_test.go
@@ -192,6 +192,7 @@ func TestTreeWildcard(t *testing.T) {
"/get/abc/123abg/:param",
"/get/abc/123abf/:param",
"/get/abc/123abfff/:param",
+ "/get/abc/escaped_colon/test\\:param",
}
for _, route := range routes {
tree.addRoute(route, fakeHandler(route))
@@ -315,6 +316,7 @@ func TestTreeWildcard(t *testing.T) {
{"/get/abc/123abg/test", false, "/get/abc/123abg/:param", Params{Param{Key: "param", Value: "test"}}},
{"/get/abc/123abf/testss", false, "/get/abc/123abf/:param", Params{Param{Key: "param", Value: "testss"}}},
{"/get/abc/123abfff/te", false, "/get/abc/123abfff/:param", Params{Param{Key: "param", Value: "te"}}},
+ {"/get/abc/escaped_colon/test\\:param", false, "/get/abc/escaped_colon/test\\:param", nil},
})
checkPriorities(t, tree)
@@ -419,6 +421,9 @@ func TestTreeWildcardConflict(t *testing.T) {
{"/id/:id", false},
{"/static/*file", false},
{"/static/", true},
+ {"/escape/test\\:d1", false},
+ {"/escape/test\\:d2", false},
+ {"/escape/test:param", false},
}
testRoutes(t, routes)
}
@@ -971,3 +976,45 @@ func TestTreeWildcardConflictEx(t *testing.T) {
}
}
}
+
+func TestTreeInvalidEscape(t *testing.T) {
+ routes := map[string]bool{
+ "/r1/r": true,
+ "/r2/:r": true,
+ "/r3/\\:r": true,
+ }
+ tree := &node{}
+ for route, valid := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv == nil != valid {
+ t.Fatalf("%s should be %t but got %v", route, valid, recv)
+ }
+ }
+}
+
+func TestWildcardInvalidSlash(t *testing.T) {
+ const panicMsgPrefix = "no / before catch-all in path"
+
+ routes := map[string]bool{
+ "/foo/bar": true,
+ "/foo/x*zy": false,
+ "/foo/b*r": false,
+ }
+
+ for route, valid := range routes {
+ tree := &node{}
+ recv := catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+
+ if recv == nil != valid {
+ t.Fatalf("%s should be %t but got %v", route, valid, recv)
+ }
+
+ if rs, ok := recv.(string); recv != nil && (!ok || !strings.HasPrefix(rs, panicMsgPrefix)) {
+ t.Fatalf(`"Expected panic "%s" for route '%s', got "%v"`, panicMsgPrefix, route, recv)
+ }
+ }
+}
diff --git a/utils_test.go b/utils_test.go
index fc0e8b4..b5d57ad 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -145,6 +145,6 @@ func TestMarshalXMLforH(t *testing.T) {
}
func TestIsASCII(t *testing.T) {
- assert.Equal(t, isASCII("test"), true)
- assert.Equal(t, isASCII("🧡💛💚💙💜"), false)
+ assert.True(t, isASCII("test"))
+ assert.False(t, isASCII("🧡💛💚💙💜"))
}