Merge pull request #11 from lxzan/dev

Add ProtoBuf/Yaml Codec

.gitignore

@@ -16,4 +16,5 @@ test/
 debug
 vendor/
 examples/
-bin/
+bin/
+go.work*

Makefile

@@ -1,8 +1,17 @@
 test:
- go test -count 1 -timeout 30s -run ^Test ./...
+ go test -timeout 30s -run ^Test ./...
+ go test -timeout 30s -run ^Test ./contrib/pb/...
+ go test -timeout 30s -run ^Test ./contrib/yaml/...
 
 bench:
  go test -benchmem -run=^$$ -bench . github.com/lxzan/hasaki
 
 cover:
  go test -coverprofile=bin/cover.out --cover ./...
+ go test -coverprofile=bin/pb.out --cover ./contrib/pb/...
+ go test -coverprofile=bin/yaml.out --cover ./contrib/yaml/...
+
+install:
+ go mod tidy
+ go generate ./contrib/pb/codec.go
+ go generate ./contrib/yaml/codec.go

README.md

@@ -1,35 +1,33 @@
 # Hasaki
 
-http request library for golang
+Http Request Library for Go
 
 [![Build Status][1]][2] [![codecov][3]][4]
 
 [1]: https://github.com/lxzan/hasaki/workflows/Go%20Test/badge.svg?branch=master
-
 [2]: https://github.com/lxzan/hasaki/actions?query=branch%3Amaster
-
 [3]: https://codecov.io/gh/lxzan/hasaki/graph/badge.svg?token=0VY55RLS3G
-
 [4]: https://codecov.io/gh/lxzan/hasaki
 
-- [Hasaki](#hasaki)
- - [Features](#features)
- - [Install](#install)
- - [Usage](#usage)
- - [Get](#get)
- - [Post](#post)
- - [Stream](#stream)
- - [Error Stack](#error-stack)
- - [Middleware](#middleware)
-  - [Debug](#debug)
+-  [Hasaki](#hasaki)
+ -  [Features](#features)
+ -  [Install](#install)
+ -  [Usage](#usage)
+  -  [Get](#get)
+  -  [Post](#post)
+  -  [Stream](#stream)
+  -  [Error Stack](#error-stack)
+  -  [Middleware](#middleware)
+ - [How to get request latency in simple way](#how-to-get-request-latency-in-simple-way)
 
 ### Features
 
-- [x] Buffer Pool
-- [x] Trace the Error Stack
-- [x] JSON / WWWForm Encoder
-- [x] Request Before and After Middleware
-- [x] Export CURL Command
+- [x] Buffer Pool
+- [x] Trace the Error Stack
+- [x] Request Encoder Bind: JSON, YAML, Form, Stream
+- [x] Response Decoder Bind: JSON, YAML, XML
+- [x] Request Before and After Middleware
+- [x] Export CURL Command in Debug Mode
 
 ### Install
 
@@ -63,23 +61,6 @@ resp := hasaki.
  Send(nil)
 ```
 
-```go
-// GET https://api.example.com/search?q=hasaki&page=1
-// Send get request, with Query parameter, encoded with struct
-
-type Req struct {
- Q string `form:"q"`
- Page int `form:"page"`
-}
-resp := hasaki.
- Get("https://api.example.com/search").
- SetQuery(Req{
- Q: "hasaki",
- Page: 1,
- }).
- Send(nil)
-```
-
 #### Post
 
 ```go
@@ -102,16 +83,12 @@ resp := hasaki.
 // POST https://api.example.com/search
 // Send post request, encoded with www-form
 
-type Req struct {
- Q string `form:"q"`
- Page int `form:"page"`
-}
 resp := hasaki.
  Post("https://api.example.com/search").
  SetEncoder(hasaki.FormEncoder).
- Send(Req{
- Q: "hasaki",
- Page: 1,
+ Send(url.Values{
+ "q": []string{"hasaki"},
+ "page": []string{"1"},
  })
 ```
 
@@ -145,14 +122,20 @@ if err != nil {
 
 #### Middleware
 
+Very useful middleware, you can use it to do something before and after the request is sent.
+
+The middleware is a function, it receives a context and a request or response object, and returns a context and an error.
+
+Under code is a simple middleware example , record the request latency.
+
 ```go
-// Statistics on time spent on requests
+// You can use the before and after middleware to do something before and after the request is sent
 
-before := hasaki.WithBefore(func (ctx context.Context, request *http.Request) (context.Context, error) {
+before := hasaki.WithBefore(func(ctx context.Context, request *http.Request) (context.Context, error) {
  return context.WithValue(ctx, "t0", time.Now()), nil
 })
 
-after := hasaki.WithAfter(func (ctx context.Context, response *http.Response) (context.Context, error) {
+after := hasaki.WithAfter(func(ctx context.Context, response *http.Response) (context.Context, error) {
  t0 := ctx.Value("t0").(time.Time)
  log.Printf("latency=%s", time.Since(t0).String())
  return ctx, nil
@@ -161,27 +144,4 @@ after := hasaki.WithAfter(func (ctx context.Context, response *http.Response) (c
 var url = "https://api.github.com/search/repositories"
 cli, _ := hasaki.NewClient(before, after)
 cli.Get(url).Send(nil)
-```
-
-#### Debug
-
-```go
-hasaki.
- Post("http://127.0.0.1:3000").
- Debug().
- SetHeader("x-username", "123").
- SetHeader("user-agent", "hasaki").
- SetEncoder(hasaki.FormEncoder).
- Send(url.Values{
- "name": []string{"洪荒"},
- "age": []string{"456"},
- })
-```
-
-```bash
-curl -X POST 'http://127.0.0.1:3000' \
- --header 'User-Agent: hasaki' \
- --header 'Content-Type: application/x-www-form-urlencoded' \
- --header 'X-Username: 123' \
- --data-raw 'age=456&name=%E6%B4%AA%E8%8D%92'
 ```

client.go

@@ -14,12 +14,12 @@ type Client struct {
 // NewClient 新建一个客户端
 // Create a new client
 func NewClient(options ...Option) (*Client, error) {
- var c = new(config)
- options = append(options, withInitialize())
+ var conf = new(config)
  for _, f := range options {
- f(c)
+ f(conf)
  }
- var client = &Client{config: c}
+ withInitialize()(conf)
+ var client = &Client{config: conf}
  return client, nil
 }
 
@@ -39,17 +39,34 @@ func (c *Client) Delete(url string, args ...any) *Request {
  return c.Request(http.MethodDelete, url, args...)
 }
 
+func (c *Client) Head(url string, args ...any) *Request {
+ return c.Request(http.MethodHead, url, args...)
+}
+
+func (c *Client) Options(url string, args ...any) *Request {
+ return c.Request(http.MethodOptions, url, args...)
+}
+
+func (c *Client) Patch(url string, args ...any) *Request {
+ return c.Request(http.MethodPatch, url, args...)
+}
+
 func (c *Client) Request(method string, url string, args ...any) *Request {
  if len(args) > 0 {
  url = fmt.Sprintf(url, args...)
  }
- return (&Request{
+
+ r := &Request{
  ctx: context.Background(),
  client: c.config.HTTPClient,
  method: strings.ToUpper(method),
  url: url,
  before: c.config.BeforeFunc,
  after: c.config.AfterFunc,
  headers: http.Header{},
- }).SetEncoder(JsonEncoder)
+ }
+
+ r.SetEncoder(JsonEncoder)
+
+ return r
 }

client_test.go

@@ -59,8 +59,7 @@ func TestClient(t *testing.T) {
  Name string `form:"name"`
  }
  req := c.Get("http://%s", addr).SetQuery(Req{Name: "xxx"})
- exp := fmt.Sprintf("http://%s?name=xxx", addr)
- assert.Equal(t, req.url, exp)
+ assert.True(t, errors.Is(req.err, errUnsupportedData))
  }
 }
 
@@ -96,6 +95,18 @@ func TestRequest(t *testing.T) {
  resp := Delete("http://%s", addr).Send(nil)
  assert.NoError(t, resp.Err())
  }
+ {
+ resp := Patch("http://%s", addr).Send(nil)
+ assert.NoError(t, resp.Err())
+ }
+ {
+ resp := Head("http://%s", addr).Send(nil)
+ assert.NoError(t, resp.Err())
+ }
+ {
+ resp := Options("http://%s", addr).Send(nil)
+ assert.NoError(t, resp.Err())
+ }
  {
  resp := NewRequest(http.MethodDelete, "http://%s", addr).Send(nil)
  assert.NoError(t, resp.Err())
@@ -109,19 +120,6 @@ func TestRequest(t *testing.T) {
  }
 }
 
-func TestRequest_Header(t *testing.T) {
- {
- var req = Post("http://%s", nextAddr()).SetEncoder(FormEncoder)
- var typ = req.Header().Get("Content-Type")
- assert.Equal(t, typ, MimeForm)
- }
- {
- var req = Get("http://%s", nextAddr())
- var typ = req.Header().Get("Content-Type")
- assert.Equal(t, typ, MimeJson)
- }
-}
-
 func TestRequest_SetContext(t *testing.T) {
  addr := nextAddr()
  srv := &http.Server{Addr: addr}
@@ -166,14 +164,6 @@ func TestRequest_SetQuery(t *testing.T) {
  })
  assert.Equal(t, req.url, "http://"+addr+"?name=xxx")
  })
-
- t.Run("", func(t *testing.T) {
- type Req struct {
- Name string `form:"name"`
- }
- req := Get("http://%s", addr).SetQuery(Req{Name: "xxx"})
- assert.Equal(t, req.url, "http://"+addr+"?name=xxx")
- })
 }
 
 func TestRequest_Send(t *testing.T) {
@@ -290,9 +280,18 @@ func TestResponse(t *testing.T) {
  case "/greet":
  writer.WriteHeader(http.StatusOK)
  writer.Write([]byte("hello"))
- case "/test":
+ case "/json":
  writer.WriteHeader(http.StatusOK)
  writer.Write([]byte(`{"name":"caster"}`))
+ case "/yaml":
+ writer.WriteHeader(http.StatusOK)
+ writer.Write([]byte(`name: caster`))
+ case "/xml":
+ writer.WriteHeader(http.StatusOK)
+ writer.Write([]byte(`<A><name>caster</name></A>`))
+ case "/proto":
+ writer.WriteHeader(http.StatusOK)
+ writer.Write([]byte{10, 6, 99, 97, 115, 116, 101, 114})
  case "/204":
  writer.WriteHeader(http.StatusNoContent)
  default:
@@ -311,35 +310,35 @@ func TestResponse(t *testing.T) {
  })
 
  t.Run("read body error 1", func(t *testing.T) {
- resp := Post("http://%s/test", nextAddr()).Send(nil)
+ resp := Post("http://%s/json", nextAddr()).Send(nil)
  _, err := resp.ReadBody()
  assert.Error(t, err)
  })
 
  t.Run("read body error 2", func(t *testing.T) {
- resp := Post("http://%s/test", addr).Send(nil)
+ resp := Post("http://%s/json", addr).Send(nil)
  resp.Body = nil
  _, err := resp.ReadBody()
  assert.Error(t, err)
  })
 
  t.Run("bind json ok", func(t *testing.T) {
- resp := Post("http://%s/test", addr).Send(nil)
+ resp := Post("http://%s/json", addr).Send(nil)
  input := struct{ Name string }{}
  err := resp.BindJSON(&input)
  assert.NoError(t, err)
  assert.Equal(t, input.Name, "caster")
  })
 
  t.Run("bind json error 1", func(t *testing.T) {
- resp := Post("http://%s/test", nextAddr()).Send(nil)
+ resp := Post("http://%s/json", nextAddr()).Send(nil)
  inputs := struct{ Name string }{}
  err := resp.BindJSON(&inputs)
  assert.Error(t, err)
  })
 
  t.Run("bind json error 2", func(t *testing.T) {
- resp := Post("http://%s/test", addr).Send(map[string]any{
+ resp := Post("http://%s/json", addr).Send(map[string]any{
  "name": "xxx",
  })
  resp.Body = nil
@@ -373,3 +372,15 @@ func TestResponse(t *testing.T) {
  assert.Error(t, resp.Err())
  })
 }
+
+func TestRequest_SetHeaders(t *testing.T) {
+ var h = http.Header{}
+ h.Set("Content-Type", MimeJson)
+ h.Set("cookie", "123")
+ var req = Get("https://api.github.com").
+ SetHeader("Cookie", "456").
+ SetHeader("encoding", "none").
+ SetHeaders(h)
+ assert.Equal(t, req.headers.Get("cookie"), "123")
+ assert.Equal(t, req.headers.Get("encoding"), "none")
+}