pharnexbase
/
kratos
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
3 changed files with 104 additions and 118 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      Makefile
  2. 84
      transport/http/client_test.go
  3. 136
      transport/http/codec_test.go

2
Makefile
Unescape View File

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

84
transport/http/client_test.go
Unescape View File

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

136
transport/http/codec_test.go
Unescape View File

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

Write Preview
Loading…
Cancel
Save