pharnexbase
/
kratos
10
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 1 year 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
test-coverage:
@${TOOLS_SHELL} test_coverage
@echo "go test with coverage finished"
@echo "go test with coverage finished"
.PHONY: lint
lint: $(LINTER)

84
transport/http/client_test.go
Unescape View File

@ -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{})

136
transport/http/codec_test.go
Unescape View File

@ -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())
}
}

Write Preview
Loading…
Cancel
Save