fix: remove repeat `net/http` package (#2708)

* fix: remove repeat package

* fix

* fix

* fix
pull/2708/merge
jessetang 2 years ago committed by GitHub
parent ae2dcb04c0
commit 9ee4fcb48a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 2
      Makefile
  2. 84
      transport/http/client_test.go
  3. 136
      transport/http/codec_test.go

@ -89,7 +89,7 @@ test:
.PHONY: test-coverage
test-coverage:
@${TOOLS_SHELL} test_coverage
@echo "go test with coverage finished"
@echo "go test with coverage finished"
.PHONY: lint
lint: $(LINTER)

@ -10,13 +10,12 @@ import (
"io"
"log"
"net/http"
nethttp "net/http"
"reflect"
"strconv"
"testing"
"time"
kratosErrors "github.com/go-kratos/kratos/v2/errors"
kratoserrors "github.com/go-kratos/kratos/v2/errors"
"github.com/go-kratos/kratos/v2/middleware"
"github.com/go-kratos/kratos/v2/registry"
"github.com/go-kratos/kratos/v2/selector"
@ -24,7 +23,7 @@ import (
type mockRoundTripper struct{}
func (rt *mockRoundTripper) RoundTrip(req *nethttp.Request) (resp *nethttp.Response, err error) {
func (rt *mockRoundTripper) RoundTrip(req *http.Request) (resp *http.Response, err error) {
return
}
@ -129,7 +128,7 @@ func TestWithRequestEncoder(t *testing.T) {
func TestWithResponseDecoder(t *testing.T) {
o := &clientOptions{}
v := func(ctx context.Context, res *nethttp.Response, out interface{}) error { return nil }
v := func(ctx context.Context, res *http.Response, out interface{}) error { return nil }
WithResponseDecoder(v)(o)
if o.decoder == nil {
t.Errorf("expected encoder to be not nil")
@ -138,7 +137,7 @@ func TestWithResponseDecoder(t *testing.T) {
func TestWithErrorDecoder(t *testing.T) {
o := &clientOptions{}
v := func(ctx context.Context, res *nethttp.Response) error { return nil }
v := func(ctx context.Context, res *http.Response) error { return nil }
WithErrorDecoder(v)(o)
if o.errorDecoder == nil {
t.Errorf("expected encoder to be not nil")
@ -199,27 +198,24 @@ func TestWithNodeFilter(t *testing.T) {
}
func TestDefaultRequestEncoder(t *testing.T) {
req1 := &nethttp.Request{
Header: make(nethttp.Header),
Body: io.NopCloser(bytes.NewBufferString("{\"a\":\"1\", \"b\": 2}")),
}
req1.Header.Set("Content-Type", "application/xml")
r, _ := http.NewRequest(http.MethodPost, "", io.NopCloser(bytes.NewBufferString(`{"a":"1", "b": 2}`)))
r.Header.Set("Content-Type", "application/xml")
v1 := &struct {
A string `json:"a"`
B int64 `json:"b"`
}{"a", 1}
b, err1 := DefaultRequestEncoder(context.TODO(), "application/json", v1)
if err1 != nil {
t.Errorf("expected no error, got %v", err1)
b, err := DefaultRequestEncoder(context.TODO(), "application/json", v1)
if err != nil {
t.Fatal(err)
}
v1b := &struct {
A string `json:"a"`
B int64 `json:"b"`
}{}
err1 = json.Unmarshal(b, v1b)
if err1 != nil {
t.Errorf("expected no error, got %v", err1)
err = json.Unmarshal(b, v1b)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(v1b, v1) {
t.Errorf("expected %v, got %v", v1, v1b)
@ -227,8 +223,8 @@ func TestDefaultRequestEncoder(t *testing.T) {
}
func TestDefaultResponseDecoder(t *testing.T) {
resp1 := &nethttp.Response{
Header: make(nethttp.Header),
resp1 := &http.Response{
Header: make(http.Header),
StatusCode: 200,
Body: io.NopCloser(bytes.NewBufferString("{\"a\":\"1\", \"b\": 2}")),
}
@ -236,19 +232,19 @@ func TestDefaultResponseDecoder(t *testing.T) {
A string `json:"a"`
B int64 `json:"b"`
}{}
err1 := DefaultResponseDecoder(context.TODO(), resp1, &v1)
if err1 != nil {
t.Errorf("expected no error, got %v", err1)
err := DefaultResponseDecoder(context.TODO(), resp1, &v1)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual("1", v1.A) {
if v1.A != "1" {
t.Errorf("expected %v, got %v", "1", v1.A)
}
if !reflect.DeepEqual(int64(2), v1.B) {
if v1.B != int64(2) {
t.Errorf("expected %v, got %v", 2, v1.B)
}
resp2 := &nethttp.Response{
Header: make(nethttp.Header),
resp2 := &http.Response{
Header: make(http.Header),
StatusCode: 200,
Body: io.NopCloser(bytes.NewBufferString("{badjson}")),
}
@ -256,22 +252,22 @@ func TestDefaultResponseDecoder(t *testing.T) {
A string `json:"a"`
B int64 `json:"b"`
}{}
err2 := DefaultResponseDecoder(context.TODO(), resp2, &v2)
terr1 := &json.SyntaxError{}
if !errors.As(err2, &terr1) {
t.Errorf("expected %v, got %v", terr1, err2)
err = DefaultResponseDecoder(context.TODO(), resp2, &v2)
syntaxErr := &json.SyntaxError{}
if !errors.As(err, &syntaxErr) {
t.Errorf("expected %v, got %v", syntaxErr, err)
}
}
func TestDefaultErrorDecoder(t *testing.T) {
for i := 200; i < 300; i++ {
resp := &nethttp.Response{Header: make(nethttp.Header), StatusCode: i}
resp := &http.Response{Header: make(http.Header), StatusCode: i}
if DefaultErrorDecoder(context.TODO(), resp) != nil {
t.Errorf("expected no error, got %v", DefaultErrorDecoder(context.TODO(), resp))
}
}
resp1 := &nethttp.Response{
Header: make(nethttp.Header),
resp1 := &http.Response{
Header: make(http.Header),
StatusCode: 300,
Body: io.NopCloser(bytes.NewBufferString("{\"foo\":\"bar\"}")),
}
@ -279,28 +275,28 @@ func TestDefaultErrorDecoder(t *testing.T) {
t.Errorf("expected error, got nil")
}
resp2 := &nethttp.Response{
Header: make(nethttp.Header),
resp2 := &http.Response{
Header: make(http.Header),
StatusCode: 500,
Body: io.NopCloser(bytes.NewBufferString("{\"code\":54321, \"message\": \"hi\", \"reason\": \"FOO\"}")),
}
err2 := DefaultErrorDecoder(context.TODO(), resp2)
if err2 == nil {
err := DefaultErrorDecoder(context.TODO(), resp2)
if err == nil {
t.Errorf("expected error, got nil")
}
if !reflect.DeepEqual(int32(500), err2.(*kratosErrors.Error).Code) {
t.Errorf("expected %v, got %v", 500, err2.(*kratosErrors.Error).Code)
if err.(*kratoserrors.Error).Code != int32(500) {
t.Errorf("expected %v, got %v", 500, err.(*kratoserrors.Error).Code)
}
if !reflect.DeepEqual("hi", err2.(*kratosErrors.Error).Message) {
t.Errorf("expected %v, got %v", "hi", err2.(*kratosErrors.Error).Message)
if err.(*kratoserrors.Error).Message != "hi" {
t.Errorf("expected %v, got %v", "hi", err.(*kratoserrors.Error).Message)
}
if !reflect.DeepEqual("FOO", err2.(*kratosErrors.Error).Reason) {
t.Errorf("expected %v, got %v", "FOO", err2.(*kratosErrors.Error).Reason)
if err.(*kratoserrors.Error).Reason != "FOO" {
t.Errorf("expected %v, got %v", "FOO", err.(*kratoserrors.Error).Reason)
}
}
func TestCodecForResponse(t *testing.T) {
resp := &nethttp.Response{Header: make(nethttp.Header)}
resp := &http.Response{Header: make(http.Header)}
resp.Header.Set("Content-Type", "application/xml")
c := CodecForResponse(resp)
if !reflect.DeepEqual("xml", c.Name()) {
@ -346,7 +342,7 @@ func TestNewClient(t *testing.T) {
}),
)
if err != nil {
t.Error(err)
t.Fatal(err)
}
err = client.Invoke(context.Background(), http.MethodPost, "/go", map[string]string{"name": "kratos"}, nil, EmptyCallOption{}, &mockCallOption{})

@ -3,53 +3,50 @@ package http
import (
"bytes"
"io"
nethttp "net/http"
"reflect"
"net/http"
"testing"
"github.com/go-kratos/kratos/v2/errors"
)
func TestDefaultRequestDecoder(t *testing.T) {
bodyString := "{\"a\":\"1\", \"b\": 2}"
req1 := &nethttp.Request{
Header: make(nethttp.Header),
Body: io.NopCloser(bytes.NewBufferString(bodyString)),
}
req1.Header.Set("Content-Type", "application/json")
var (
bodyStr = `{"a":"1", "b": 2}`
r, _ = http.NewRequest(http.MethodPost, "", io.NopCloser(bytes.NewBufferString(bodyStr)))
)
r.Header.Set("Content-Type", "application/json")
v1 := &struct {
A string `json:"a"`
B int64 `json:"b"`
}{}
err1 := DefaultRequestDecoder(req1, &v1)
if err1 != nil {
t.Errorf("expected no error, got %v", err1)
err := DefaultRequestDecoder(r, &v1)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual("1", v1.A) {
if v1.A != "1" {
t.Errorf("expected %v, got %v", "1", v1.A)
}
if !reflect.DeepEqual(int64(2), v1.B) {
if v1.B != int64(2) {
t.Errorf("expected %v, got %v", 2, v1.B)
}
data, err := io.ReadAll(req1.Body)
data, err := io.ReadAll(r.Body)
if err != nil {
t.Errorf("expected no error, got %v", err1)
t.Fatal(err)
}
if !reflect.DeepEqual([]byte(bodyString), data) {
t.Errorf("expected %v, got %v", bodyString, data)
if bodyStr != string(data) {
t.Errorf("expected %v, got %v", bodyStr, string(data))
}
}
type mockResponseWriter struct {
StatusCode int
Data []byte
header nethttp.Header
header http.Header
}
func (w *mockResponseWriter) Header() nethttp.Header {
func (w *mockResponseWriter) Header() http.Header {
return w.header
}
@ -62,27 +59,28 @@ func (w *mockResponseWriter) WriteHeader(statusCode int) {
w.StatusCode = statusCode
}
type dataWithStatusCode struct {
A string `json:"a"`
B int64 `json:"b"`
}
func TestDefaultResponseEncoder(t *testing.T) {
w := &mockResponseWriter{StatusCode: 200, header: make(nethttp.Header)}
req1 := &nethttp.Request{
Header: make(nethttp.Header),
}
req1.Header.Set("Content-Type", "application/json")
v1 := &dataWithStatusCode{A: "1", B: 2}
err := DefaultResponseEncoder(w, req1, v1)
var (
w = &mockResponseWriter{StatusCode: 200, header: make(http.Header)}
r, _ = http.NewRequest(http.MethodPost, "", nil)
v = &struct {
A string `json:"a"`
B int64 `json:"b"`
}{
A: "1",
B: 2,
}
)
r.Header.Set("Content-Type", "application/json")
err := DefaultResponseEncoder(w, r, v)
if err != nil {
t.Errorf("expected no error, got %v", err)
t.Fatal(err)
}
if !reflect.DeepEqual("application/json", w.Header().Get("Content-Type")) {
if w.Header().Get("Content-Type") != "application/json" {
t.Errorf("expected %v, got %v", "application/json", w.Header().Get("Content-Type"))
}
if !reflect.DeepEqual(200, w.StatusCode) {
if w.StatusCode != 200 {
t.Errorf("expected %v, got %v", 200, w.StatusCode)
}
if w.Data == nil {
@ -90,19 +88,19 @@ func TestDefaultResponseEncoder(t *testing.T) {
}
}
func TestDefaultResponseEncoderWithError(t *testing.T) {
w := &mockResponseWriter{header: make(nethttp.Header)}
req := &nethttp.Request{
Header: make(nethttp.Header),
}
req.Header.Set("Content-Type", "application/json")
func TestDefaultErrorEncoder(t *testing.T) {
var (
w = &mockResponseWriter{header: make(http.Header)}
r, _ = http.NewRequest(http.MethodPost, "", nil)
err = errors.New(511, "", "")
)
r.Header.Set("Content-Type", "application/json")
se := errors.New(511, "", "")
DefaultErrorEncoder(w, req, se)
if !reflect.DeepEqual("application/json", w.Header().Get("Content-Type")) {
DefaultErrorEncoder(w, r, err)
if w.Header().Get("Content-Type") != "application/json" {
t.Errorf("expected %v, got %v", "application/json", w.Header().Get("Content-Type"))
}
if !reflect.DeepEqual(511, w.StatusCode) {
if w.StatusCode != 511 {
t.Errorf("expected %v, got %v", 511, w.StatusCode)
}
if w.Data == nil {
@ -111,20 +109,20 @@ func TestDefaultResponseEncoderWithError(t *testing.T) {
}
func TestDefaultResponseEncoderEncodeNil(t *testing.T) {
w := &mockResponseWriter{StatusCode: 204, header: make(nethttp.Header)}
req1 := &nethttp.Request{
Header: make(nethttp.Header),
}
req1.Header.Set("Content-Type", "application/json")
var (
w = &mockResponseWriter{StatusCode: 204, header: make(http.Header)}
r, _ = http.NewRequest(http.MethodPost, "", io.NopCloser(bytes.NewBufferString("<xml></xml>")))
)
r.Header.Set("Content-Type", "application/json")
err := DefaultResponseEncoder(w, req1, nil)
err := DefaultResponseEncoder(w, r, nil)
if err != nil {
t.Errorf("expected no error, got %v", err)
t.Fatal(err)
}
if !reflect.DeepEqual("", w.Header().Get("Content-Type")) {
if w.Header().Get("Content-Type") != "" {
t.Errorf("expected empty string, got %v", w.Header().Get("Content-Type"))
}
if !reflect.DeepEqual(204, w.StatusCode) {
if w.StatusCode != 204 {
t.Errorf("expected %v, got %v", 204, w.StatusCode)
}
if w.Data != nil {
@ -133,31 +131,23 @@ func TestDefaultResponseEncoderEncodeNil(t *testing.T) {
}
func TestCodecForRequest(t *testing.T) {
req1 := &nethttp.Request{
Header: make(nethttp.Header),
Body: io.NopCloser(bytes.NewBufferString("<xml></xml>")),
}
req1.Header.Set("Content-Type", "application/xml")
c, ok := CodecForRequest(req1, "Content-Type")
r, _ := http.NewRequest(http.MethodPost, "", io.NopCloser(bytes.NewBufferString("<xml></xml>")))
r.Header.Set("Content-Type", "application/xml")
c, ok := CodecForRequest(r, "Content-Type")
if !ok {
t.Errorf("expected true, got %v", ok)
t.Fatalf("expected true, got %v", ok)
}
if !reflect.DeepEqual("xml", c.Name()) {
if c.Name() != "xml" {
t.Errorf("expected %v, got %v", "xml", c.Name())
}
req2 := &nethttp.Request{
Header: make(nethttp.Header),
Body: io.NopCloser(bytes.NewBufferString("{\"a\":\"1\", \"b\": 2}")),
}
req2.Header.Set("Content-Type", "blablablabla")
c, ok = CodecForRequest(req2, "Content-Type")
r, _ = http.NewRequest(http.MethodPost, "", io.NopCloser(bytes.NewBufferString(`{"a":"1", "b": 2}`)))
r.Header.Set("Content-Type", "blablablabla")
c, ok = CodecForRequest(r, "Content-Type")
if ok {
t.Errorf("expected false, got %v", ok)
t.Fatalf("expected false, got %v", ok)
}
if !reflect.DeepEqual("json", c.Name()) {
if c.Name() != "json" {
t.Errorf("expected %v, got %v", "json", c.Name())
}
}

Loading…
Cancel
Save