lintering && fix call hook (#122)

Reviewed-on: #122
Co-authored-by: Evstigneev Denis <danteevstigneev@yandex.ru>
Co-committed-by: Evstigneev Denis <danteevstigneev@yandex.ru>

.gitea/workflows/job_lint.yml

@@ -0,0 +1,29 @@
+name: lint
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+    - master
+    - v3
+    - v4
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable' 
+    - name: setup deps
+      run: go get -v ./...
+    - name: run lint
+      uses: https://github.com/golangci/golangci-lint-action@v6
+      with:
+        version: 'latest'

.gitea/workflows/job_test.yml

@@ -0,0 +1,34 @@
+name: test
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+    - master
+    - v3
+    - v4
+  push:
+    branches:
+    - master
+    - v3
+    - v4
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable'
+    - name: setup deps
+      run: go get -v ./...
+    - name: run test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...

.gitea/workflows/job_tests.yml

@@ -0,0 +1,53 @@
+name: test
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+    - master
+    - v3
+    - v4
+  push:
+    branches:
+    - master
+    - v3
+    - v4
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout code
+      uses: actions/checkout@v4
+      with:
+        filter: 'blob:none'
+    - name: checkout tests
+      uses: actions/checkout@v4
+      with:
+        ref: master
+        filter: 'blob:none'
+        repository: unistack-org/micro-tests
+        path: micro-tests
+    - name: setup go
+      uses: actions/setup-go@v5
+      with:
+        cache-dependency-path: "**/*.sum"
+        go-version: 'stable'
+    - name: setup go work
+      env:
+        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+      run: |
+        go work init
+        go work use .
+        go work use micro-tests        
+    - name: setup deps
+      env:
+        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+      run: go get -v ./...
+    - name: run tests
+      env:
+        INTEGRATION_TESTS: yes
+        GOWORK: /workspace/${{ github.repository_owner }}/go.work
+      run: |
+        cd micro-tests
+        go test -mod readonly -v ./... || true        

.github/renovate.json

@@ -1,20 +0,0 @@
-{
-  "extends": [
-    "config:base"
-  ],
-  "postUpdateOptions": ["gomodTidy"],
-  "packageRules": [
-    {
-      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
-      "automerge": true
-    },
-    {
-      "groupName": "all deps",
-      "separateMajorMinor": true,
-      "groupSlug": "all",
-      "packagePatterns": [
-        "*"
-      ]
-    }
-  ]
-}

.github/stale.sh

@@ -1,13 +0,0 @@
-#!/bin/bash -ex
-
-export PATH=$PATH:$(pwd)/bin
-export GO111MODULE=on
-export GOBIN=$(pwd)/bin
-
-#go get github.com/rvflash/goup@v0.4.1
-
-#goup -v ./...
-#go get github.com/psampaz/go-mod-outdated@v0.6.0
-go list -u -m -mod=mod -json all | go-mod-outdated -update -direct -ci || true
-
-#go list -u -m -json all | go-mod-outdated -update

.github/workflows/build.yml

@@ -1,46 +0,0 @@
-name: build
-on:
- push:
-    branches:
-    - master
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.16
-    - name: checkout
-      uses: actions/checkout@v2
-    - name: cache
-      uses: actions/cache@v2
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: ${{ runner.os }}-go-
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: lint
-        uses: golangci/golangci-lint-action@v2
-        continue-on-error: true
-        with:
-          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.30
-          # Optional: working directory, useful for monorepos
-          # working-directory: somedir
-          # Optional: golangci-lint command line arguments.
-          # args: --issues-exit-code=0
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true

.github/workflows/pr.yml

@@ -1,46 +0,0 @@
-name: prbuild
-on:
-  pull_request:
-    branches:
-    - master
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.16
-    - name: checkout
-      uses: actions/checkout@v2
-    - name: cache
-      uses: actions/cache@v2
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: ${{ runner.os }}-go-
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: lint
-        uses: golangci/golangci-lint-action@v2
-        continue-on-error: true
-        with:
-          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.30
-          # Optional: working directory, useful for monorepos
-          # working-directory: somedir
-          # Optional: golangci-lint command line arguments.
-          # args: --issues-exit-code=0
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true

.gitignore

@@ -0,0 +1,39 @@
+# Develop tools
+/.vscode/
+/.idea/
+.idea
+.vscode
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Folders
+_obj
+_test
+_build
+.DS_Store
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# vim temp files
+*~
+*.swp
+*.swo

.golangci.yml

@@ -0,0 +1,5 @@
+run:
+  concurrency: 8
+  deadline: 5m
+  issues-exit-code: 1
+  tests: true

README.md

@@ -5,14 +5,14 @@ This plugin is a http client for micro.
 ## Overview
 
 The http client wraps `net/http` to provide a robust micro client with service discovery, load balancing and streaming. 
-It complies with the [micro.Client](https://godoc.org/github.com/unistack-org/micro-client-http#Client) interface.
+It complies with the [micro.Client](https://godoc.org/go.unistack.org/micro-client-http/v3#Client) interface.
 
 ## Usage
 
 ### Use directly
 
 ```go
-import "github.com/unistack-org/micro-client-http"
+import "go.unistack.org/micro-client-http/v3"
 
 service := micro.NewService(
 	micro.Name("my.service"),

go.mod

@@ -1,5 +1,15 @@
-module github.com/unistack-org/micro-client-http/v3
+module go.unistack.org/micro-client-http/v3
 
-go 1.16
+go 1.22
 
-require github.com/unistack-org/micro/v3 v3.3.11
+toolchain go1.23.1
+
+require go.unistack.org/micro/v3 v3.10.97
+
+require (
+	go.unistack.org/micro-proto/v3 v3.4.1 // indirect
+	golang.org/x/sys v0.26.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 // indirect
+	google.golang.org/grpc v1.67.1 // indirect
+	google.golang.org/protobuf v1.35.1 // indirect
+)

go.sum

@@ -1,17 +1,39 @@
-github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/ef-ds/deque v1.0.4/go.mod h1:gXDnTC3yqvBcHbq2lcExjtAcVrOnJCbMcZXmuj8Z4tg=
-github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
-github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
-github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
-github.com/silas/dag v0.0.0-20210121180416-41cf55125c34/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-github.com/unistack-org/micro/v3 v3.3.11 h1:Jr0gAw5lLqgddiHKQeWUOUeP6ZqgRhz52EA9zJ5MJ3U=
-github.com/unistack-org/micro/v3 v3.3.11/go.mod h1:PPCt675o3HPcODFbJ4iRWPmQFAk1WQ+asQSOb/syq6U=
-golang.org/x/net v0.0.0-20210331212208-0fccb6fa2b5c/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+go.unistack.org/micro-proto/v3 v3.4.1 h1:UTjLSRz2YZuaHk9iSlVqqsA50JQNAEK2ZFboGqtEa9Q=
+go.unistack.org/micro-proto/v3 v3.4.1/go.mod h1:okx/cnOhzuCX0ggl/vToatbCupi0O44diiiLLsZ93Zo=
+go.unistack.org/micro/v3 v3.10.69 h1:V4g9LqUhzGab73U2aevnjtffCdJqGTuMfWY7fy4qGwI=
+go.unistack.org/micro/v3 v3.10.69/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
+go.unistack.org/micro/v3 v3.10.88 h1:MxlzP+77Y6Kphb3lzHxROL4XfE/WdCQMQpnPv4D9Z8U=
+go.unistack.org/micro/v3 v3.10.88/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
+go.unistack.org/micro/v3 v3.10.91 h1:vuJY4tXwpqimwIkEJ3TozMYNVQQs+C5QMlQWPgSY/YM=
+go.unistack.org/micro/v3 v3.10.91/go.mod h1:erMgt3Bl7vQQ0e9UpQyR5NlLiZ9pKeEJ9+1tfYFaqUg=
+go.unistack.org/micro/v3 v3.10.97 h1:8l7fv+i06/PjPrBBhRC/ZQkWGIOuHPg3jJN0vktYE78=
+go.unistack.org/micro/v3 v3.10.97/go.mod h1:YzMldzHN9Ei+zy5t/Psu7RUWDZwUfrNYiStSQtTz90g=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240415180920-8c6c420018be h1:LG9vZxsWGOmUKieR8wPAUR3u3MpnYFQZROPIMaXh7/A=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240415180920-8c6c420018be/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9 h1:QCqS/PdaHTSWGvupk2F/ehwHtGc0/GYkT+3GAcR1CCc=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
+google.golang.org/grpc v1.63.2 h1:MUeiw1B2maTVZthpU5xvASfTh3LDbxHd6IJ6QQVU+xM=
+google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA=
+google.golang.org/grpc v1.66.2 h1:3QdXkuq3Bkh7w+ywLdLvM56cmGvQHUMZpiCzt6Rqaoo=
+google.golang.org/grpc v1.66.2/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y=
+google.golang.org/grpc v1.67.0 h1:IdH9y6PF5MPSdAntIcpjQ+tXO41pcQsfZV2RxtQgVcw=
+google.golang.org/grpc v1.67.0/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
+google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
+google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=

http_test.go

@@ -1,21 +1,102 @@
 package http
 
 import (
+	"encoding/json"
+	"fmt"
 	"net/url"
 	"strings"
 	"testing"
 )
 
-type Request struct {
-	Name   string `json:"name"`
-	Field1 string
-	Field2 string
-	Field3 int64
+func TestNestedPathPost(t *testing.T) {
+	req := &request{Name: "first", Field1: "fieldval"}
+	p, m, err := newPathRequest("/api/v1/xxxx", "POST", "*", req, []string{"json", "protobuf"}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	u, err := url.Parse(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if s := u.String(); s != "/api/v1/xxxx" {
+		t.Fatalf("nested path error %s", s)
+	}
+	_ = m
+}
+
+type request struct {
+	NestedTest *request `json:"nested_test,omitempty"`
+	Name       string   `json:"name,omitempty"`
+	Field1     string   `json:"field1,omitempty"`
+	ClientID   string   `json:",omitempty"`
+	Field2     string   `json:",omitempty"`
+	Field3     int64    `json:",omitempty"`
+}
+
+func TestNestedPath(t *testing.T) {
+	req := &request{Name: "first", NestedTest: &request{Name: "second"}, Field1: "fieldval"}
+	p, m, err := newPathRequest("/api/v1/{name}/{nested_test.name}", "PUT", "*", req, []string{"json", "protobuf"}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	u, err := url.Parse(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if s := u.String(); s != "/api/v1/first/second" {
+		t.Fatalf("nested path error %s", s)
+	}
+	b, err := json.Marshal(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fmt.Printf("m %#+v %s\n", m, b)
+}
+
+func TestPathWithHeader(t *testing.T) {
+	req := &request{Name: "vtolstov", Field1: "field1", ClientID: "1234567890"}
+	p, m, err := newPathRequest(
+		"/api/v1/test?Name={name}&Field1={field1}",
+		"POST",
+		"*",
+		req,
+		nil,
+		map[string]map[string]string{"header": {"ClientID": "true"}},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	u, err := url.Parse(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if m != nil {
+		t.Fatal("new struct must be nil")
+	}
+	if u.Query().Get("Name") != "vtolstov" || u.Query().Get("Field1") != "field1" {
+		t.Fatalf("invalid values %v", u.Query())
+	}
+}
+
+func TestPathValues(t *testing.T) {
+	req := &request{Name: "vtolstov", Field1: "field1"}
+	p, m, err := newPathRequest("/api/v1/test?Name={name}&Field1={field1}", "POST", "*", req, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	u, err := url.Parse(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = m
+	if u.Query().Get("Name") != "vtolstov" || u.Query().Get("Field1") != "field1" {
+		t.Fatalf("invalid values %v", u.Query())
+	}
 }
 
 func TestValidPath(t *testing.T) {
-	req := &Request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10}
-	p, m, err := newPathRequest("/api/v1/{name}/list", "GET", "", req, nil)
+	req := &request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10}
+	p, m, err := newPathRequest("/api/v1/{name}/list", "GET", "", req, nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -31,10 +112,9 @@ func TestValidPath(t *testing.T) {
 }
 
 func TestInvalidPath(t *testing.T) {
-	req := &Request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10}
-	p, m, err := newPathRequest("/api/v1/{xname}/list", "GET", "", req, nil)
+	req := &request{Name: "vtolstov", Field1: "field1", Field2: "field2", Field3: 10}
+	s, _, err := newPathRequest("/api/v1/{xname}/list", "GET", "", req, nil, nil)
 	if err == nil {
-		t.Fatalf("path param must not be filled")
+		t.Fatalf("path param must not be filled: %s", s)
 	}
-	_, _ = p, m
 }

message.go

@@ -1,25 +1,29 @@
 package http
 
 import (
-	"github.com/unistack-org/micro/v3/client"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/metadata"
 )
 
 type httpMessage struct {
+	payload     interface{}
 	topic       string
 	contentType string
-	payload     interface{}
+	opts        client.MessageOptions
 }
 
 func newHTTPMessage(topic string, payload interface{}, contentType string, opts ...client.MessageOption) client.Message {
 	options := client.NewMessageOptions(opts...)
-	if len(options.ContentType) == 0 {
-		options.ContentType = contentType
+
+	if len(options.ContentType) > 0 {
+		contentType = options.ContentType
 	}
 
 	return &httpMessage{
 		payload:     payload,
 		topic:       topic,
-		contentType: options.ContentType,
+		contentType: contentType,
+		opts:        options,
 	}
 }
 
@@ -34,3 +38,7 @@ func (h *httpMessage) Topic() string {
 func (h *httpMessage) Payload() interface{} {
 	return h.payload
 }
+
+func (h *httpMessage) Metadata() metadata.Metadata {
+	return h.opts.Metadata
+}

options.go

@@ -4,7 +4,8 @@ import (
 	"net"
 	"net/http"
 
-	"github.com/unistack-org/micro/v3/client"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/metadata"
 )
 
 var (
@@ -26,27 +27,28 @@ var (
 )
 
 type poolMaxStreams struct{}
-type poolMaxIdle struct{}
-type codecsKey struct{}
-type tlsAuth struct{}
-type maxRecvMsgSizeKey struct{}
-type maxSendMsgSizeKey struct{}
 
 // PoolMaxStreams maximum streams on a connectioin
 func PoolMaxStreams(n int) client.Option {
 	return client.SetOption(poolMaxStreams{}, n)
 }
 
+type poolMaxIdle struct{}
+
 // PoolMaxIdle maximum idle conns of a pool
 func PoolMaxIdle(d int) client.Option {
 	return client.SetOption(poolMaxIdle{}, d)
 }
 
+type maxRecvMsgSizeKey struct{}
+
 // MaxRecvMsgSize set the maximum size of message that client can receive.
 func MaxRecvMsgSize(s int) client.Option {
 	return client.SetOption(maxRecvMsgSizeKey{}, s)
 }
 
+type maxSendMsgSizeKey struct{}
+
 // MaxSendMsgSize set the maximum size of message that client can send.
 func MaxSendMsgSize(s int) client.Option {
 	return client.SetOption(maxSendMsgSizeKey{}, s)
@@ -54,30 +56,37 @@ func MaxSendMsgSize(s int) client.Option {
 
 type httpClientKey struct{}
 
+// nolint: golint
+// HTTPClient pass http.Client option to client Call
 func HTTPClient(c *http.Client) client.Option {
 	return client.SetOption(httpClientKey{}, c)
 }
 
 type httpDialerKey struct{}
 
+// nolint: golint
+// HTTPDialer pass net.Dialer option to client
 func HTTPDialer(d *net.Dialer) client.Option {
 	return client.SetOption(httpDialerKey{}, d)
 }
 
 type methodKey struct{}
 
+// Method pass method option to client Call
 func Method(m string) client.CallOption {
 	return client.SetCallOption(methodKey{}, m)
 }
 
 type pathKey struct{}
 
+// Path spcecifies path option to client Call
 func Path(p string) client.CallOption {
 	return client.SetCallOption(pathKey{}, p)
 }
 
 type bodyKey struct{}
 
+// Body specifies body option to client Call
 func Body(b string) client.CallOption {
 	return client.SetCallOption(bodyKey{}, b)
 }
@@ -90,6 +99,28 @@ func ErrorMap(m map[string]interface{}) client.CallOption {
 
 type structTagsKey struct{}
 
+// StructTags pass tags slice option to client Call
 func StructTags(tags []string) client.CallOption {
 	return client.SetCallOption(structTagsKey{}, tags)
 }
+
+type metadataKey struct{}
+
+// Metadata pass metadata to client Call
+func Metadata(md metadata.Metadata) client.CallOption {
+	return client.SetCallOption(metadataKey{}, md)
+}
+
+type cookieKey struct{}
+
+// Cookie pass cookie to client Call
+func Cookie(cookies ...string) client.CallOption {
+	return client.SetCallOption(cookieKey{}, cookies)
+}
+
+type headerKey struct{}
+
+// Header pass cookie to client Call
+func Header(headers ...string) client.CallOption {
+	return client.SetCallOption(headerKey{}, headers)
+}

request.go

@@ -1,8 +1,8 @@
 package http
 
 import (
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/codec"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/codec"
 )
 
 type httpRequest struct {
@@ -15,7 +15,6 @@ type httpRequest struct {
 
 func newHTTPRequest(service, method string, request interface{}, contentType string, opts ...client.RequestOption) client.Request {
 	options := client.NewRequestOptions(opts...)
-
 	if len(options.ContentType) == 0 {
 		options.ContentType = contentType
 	}

stream.go

@@ -4,35 +4,34 @@ import (
 	"bufio"
 	"context"
 	"fmt"
+	"io"
 	"net"
 	"net/http"
 	"sync"
 
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/errors"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/logger"
 )
 
 // Implements the streamer interface
 type httpStream struct {
-	sync.RWMutex
-	address string
-	opts    client.CallOptions
-	ct      string
-	cf      codec.Codec
-	context context.Context
-	header  http.Header
-	seq     uint64
-	closed  chan bool
 	err     error
 	conn    net.Conn
-	reader  *bufio.Reader
+	cf      codec.Codec
+	context context.Context
+	logger  logger.Logger
 	request client.Request
+	closed  chan bool
+	reader  *bufio.Reader
+	address string
+	ct      string
+	opts    client.CallOptions
+	sync.RWMutex
 }
 
-var (
-	errShutdown = fmt.Errorf("connection is shut down")
-)
+var errShutdown = fmt.Errorf("connection is shut down")
 
 func (h *httpStream) isClosed() bool {
 	select {
@@ -55,6 +54,10 @@ func (h *httpStream) Response() client.Response {
 	return nil
 }
 
+func (h *httpStream) SendMsg(msg interface{}) error {
+	return h.Send(msg)
+}
+
 func (h *httpStream) Send(msg interface{}) error {
 	h.Lock()
 	defer h.Unlock()
@@ -64,16 +67,18 @@ func (h *httpStream) Send(msg interface{}) error {
 		return errShutdown
 	}
 
-	hreq, err := newRequest(h.address, h.request, h.ct, h.cf, msg, h.opts)
+	hreq, err := newRequest(h.context, h.logger, h.address, h.request, h.ct, h.cf, msg, h.opts)
 	if err != nil {
 		return err
 	}
 
-	hreq.Header = h.header
-
 	return hreq.Write(h.conn)
 }
 
+func (h *httpStream) RecvMsg(msg interface{}) error {
+	return h.Recv(msg)
+}
+
 func (h *httpStream) Recv(msg interface{}) error {
 	h.Lock()
 	defer h.Unlock()
@@ -85,11 +90,11 @@ func (h *httpStream) Recv(msg interface{}) error {
 
 	hrsp, err := http.ReadResponse(h.reader, new(http.Request))
 	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
+		return errors.InternalServerError("go.micro.client", "%+v", err)
 	}
 	defer hrsp.Body.Close()
 
-	return parseRsp(h.context, hrsp, h.cf, msg, h.opts)
+	return h.parseRsp(h.context, h.logger, hrsp, h.cf, msg, h.opts)
 }
 
 func (h *httpStream) Error() error {
@@ -98,6 +103,10 @@ func (h *httpStream) Error() error {
 	return h.err
 }
 
+func (h *httpStream) CloseSend() error {
+	return h.Close()
+}
+
 func (h *httpStream) Close() error {
 	select {
 	case <-h.closed:
@@ -107,3 +116,60 @@ func (h *httpStream) Close() error {
 		return h.conn.Close()
 	}
 }
+
+func (h *httpStream) parseRsp(ctx context.Context, log logger.Logger, hrsp *http.Response, cf codec.Codec, rsp interface{}, opts client.CallOptions) error {
+	var err error
+	var buf []byte
+
+	// fast path return
+	if hrsp.StatusCode == http.StatusNoContent {
+		return nil
+	}
+
+	select {
+	case <-ctx.Done():
+		err = ctx.Err()
+	default:
+		if hrsp.Body != nil {
+			buf, err = io.ReadAll(hrsp.Body)
+			if err != nil {
+				if log.V(logger.ErrorLevel) {
+					log.Error(ctx, "failed to read body", err)
+				}
+				return errors.InternalServerError("go.micro.client", "%s", buf)
+			}
+		}
+
+		if log.V(logger.DebugLevel) {
+			log.Debug(ctx, fmt.Sprintf("response %s with %v", buf, hrsp.Header))
+		}
+
+		if hrsp.StatusCode < 400 {
+			if err = cf.Unmarshal(buf, rsp); err != nil {
+				return errors.InternalServerError("go.micro.client", "%+v", err)
+			}
+			return nil
+		}
+
+		var rerr interface{}
+		errmap, ok := opts.Context.Value(errorMapKey{}).(map[string]interface{})
+		if ok && errmap != nil {
+			if rerr, ok = errmap[fmt.Sprintf("%d", hrsp.StatusCode)].(error); !ok {
+				rerr, ok = errmap["default"].(error)
+			}
+		}
+		if !ok || rerr == nil {
+			return errors.New("go.micro.client", string(buf), int32(hrsp.StatusCode))
+		}
+
+		if cerr := cf.Unmarshal(buf, rerr); cerr != nil {
+			return errors.InternalServerError("go.micro.client", "%+v", cerr)
+		}
+
+		if err, ok = rerr.(error); !ok {
+			err = &Error{rerr}
+		}
+	}
+
+	return err
+}

util.go

@@ -3,38 +3,70 @@ package http
 import (
 	"context"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
+	"net/url"
 	"reflect"
 	"strings"
 	"sync"
 
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/errors"
-	rutil "github.com/unistack-org/micro/v3/util/reflect"
-	util "github.com/unistack-org/micro/v3/util/router"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+	rutil "go.unistack.org/micro/v3/util/reflect"
 )
 
 var (
-	templateCache = make(map[string]util.Template)
+	templateCache = make(map[string][]string)
 	mu            sync.RWMutex
 )
 
-func newPathRequest(path string, method string, body string, msg interface{}, tags []string) (string, interface{}, error) {
+// Error struct holds error
+type Error struct {
+	err interface{}
+}
+
+// Error func for error interface
+func (err *Error) Error() string {
+	return fmt.Sprintf("%v", err.err)
+}
+
+func GetError(err error) interface{} {
+	if rerr, ok := err.(*Error); ok {
+		return rerr.err
+	}
+	return err
+}
+
+func newPathRequest(path string, method string, body string, msg interface{}, tags []string, parameters map[string]map[string]string) (string, interface{}, error) {
 	// parse via https://github.com/googleapis/googleapis/blob/master/google/api/http.proto definition
 	tpl, err := newTemplate(path)
 	if err != nil {
 		return "", nil, err
 	}
 
-	if len(tpl.Fields) > 0 && msg == nil {
+	if len(tpl) > 0 && msg == nil {
 		return "", nil, fmt.Errorf("nil message but path params requested: %v", path)
 	}
 
-	fieldsmap := make(map[string]string, len(tpl.Fields))
-	for _, v := range tpl.Fields {
-		fieldsmap[v] = ""
+	fieldsmapskip := make(map[string]struct{})
+	fieldsmap := make(map[string]string, len(tpl))
+	for _, v := range tpl {
+		var vs, ve int
+		for i := 0; i < len(v); i++ {
+			switch v[i] {
+			case '{':
+				vs = i + 1
+			case '}':
+				ve = i
+			}
+			if ve != 0 {
+				fieldsmap[v[vs:ve]] = ""
+				vs = 0
+				ve = 0
+			}
+		}
 	}
 
 	nmsg, err := rutil.Zero(msg)
@@ -53,15 +85,25 @@ func newPathRequest(path string, method string, body string, msg interface{}, ta
 		tnmsg = tnmsg.Elem()
 	}
 
-	values := make(map[string]string)
+	values := url.Values{}
 	// copy cycle
+
+	cleanPath := make(map[string]bool)
 	for i := 0; i < tmsg.NumField(); i++ {
 		val := tmsg.Field(i)
 		if val.IsZero() {
 			continue
 		}
 		fld := tmsg.Type().Field(i)
-
+		// Skip unexported fields.
+		if fld.PkgPath != "" {
+			continue
+		}
+		/* check for empty PkgPath can be replaced with new method IsExported
+		if !fld.IsExported() {
+			continue
+		}
+		*/
 		t := &tag{}
 		for _, tn := range tags {
 			ts, ok := fld.Tag.Lookup(tn)
@@ -73,71 +115,177 @@ func newPathRequest(path string, method string, body string, msg interface{}, ta
 			// special
 			switch tn {
 			case "protobuf": // special
-				t = &tag{key: tn, name: tp[3][5:], opts: append(tp[:3], tp[4:]...)}
+				for _, p := range tp {
+					if idx := strings.Index(p, "name="); idx > 0 {
+						t = &tag{key: tn, name: p[idx:]}
+					}
+				}
 			default:
-				t = &tag{key: tn, name: tp[0], opts: tp[1:]}
+				t = &tag{key: tn, name: tp[0]}
 			}
+
 			if t.name != "" {
 				break
 			}
 		}
 
-		if t.name == "" {
+		cname := t.name
+		if cname == "" {
+			cname = fld.Name
 			// fallback to lowercase
 			t.name = strings.ToLower(fld.Name)
 		}
+		if _, ok := parameters["header"][cname]; ok {
+			continue
+		}
+		if _, ok := parameters["cookie"][cname]; ok {
+			continue
+		}
 
 		if !val.IsValid() || val.IsZero() {
 			continue
 		}
 
+		// nolint: gocritic, nestif
 		if _, ok := fieldsmap[t.name]; ok {
-			fieldsmap[t.name] = fmt.Sprintf("%v", val.Interface())
-		} else if (body == "*" || body == t.name) && method != http.MethodGet {
-			tnmsg.Field(i).Set(val)
+			switch val.Type().Kind() {
+			case reflect.Slice:
+				for idx := 0; idx < val.Len(); idx++ {
+					values.Add(t.name, getParam(val.Index(idx)))
+				}
+				fieldsmapskip[t.name] = struct{}{}
+			default:
+				fieldsmap[t.name] = getParam(val)
+			}
 		} else {
-			values[t.name] = fmt.Sprintf("%v", val.Interface())
+			for k, v := range fieldsmap {
+				isSet := false
+				if v != "" {
+					continue
+				}
+				var clean []string
+				fld := msg
+
+				parts := strings.Split(k, ".")
+
+				for idx := 0; idx < len(parts); idx++ {
+					var nfld interface{}
+					var name string
+					if tags == nil {
+						tags = []string{"json"}
+					}
+				tagsloop:
+					for ti := 0; ti < len(tags); ti++ {
+						name, nfld, err = rutil.StructFieldNameByTag(fld, tags[ti], parts[idx])
+						if err == nil {
+							clean = append(clean, name)
+							break tagsloop
+						}
+					}
+					if err == nil {
+						fld = nfld
+						if len(parts)-1 == idx {
+							isSet = true
+							fieldsmap[k] = fmt.Sprintf("%v", fld)
+
+						}
+					}
+				}
+				if isSet {
+					cleanPath[strings.Join(clean, ".")] = true
+				}
+			}
+			for k := range cleanPath {
+				if err = rutil.ZeroFieldByPath(nmsg, k); err != nil {
+					return "", nil, err
+				}
+			}
+			if (body == "*" || body == t.name) && method != http.MethodGet {
+				if tnmsg.Field(i).CanSet() {
+					tnmsg.Field(i).Set(val)
+				}
+			} else if method == http.MethodGet {
+				if val.Type().Kind() == reflect.Slice {
+					for idx := 0; idx < val.Len(); idx++ {
+						values.Add(t.name, getParam(val.Index(idx)))
+					}
+				} else if !rutil.IsEmpty(val) {
+					values.Add(t.name, getParam(val))
+				}
+			}
+
 		}
 	}
 
 	// check not filled stuff
 	for k, v := range fieldsmap {
-		if v == "" {
+		_, ok := fieldsmapskip[k]
+		if !ok && v == "" {
 			return "", nil, fmt.Errorf("path param %s not filled", k)
 		}
 	}
 
 	var b strings.Builder
-	for _, fld := range tpl.Pool {
+
+	for _, fld := range tpl {
 		_, _ = b.WriteRune('/')
-		if v, ok := fieldsmap[fld]; ok {
-			_, _ = b.WriteString(v)
-		} else {
+		// nolint: nestif
+		var vs, ve, vf int
+		var pholder bool
+		for i := 0; i < len(fld); i++ {
+			switch fld[i] {
+			case '{':
+				vs = i + 1
+			case '}':
+				ve = i
+			}
+			// nolint: nestif
+			if vs > 0 && ve != 0 {
+				if vm, ok := fieldsmap[fld[vs:ve]]; ok {
+					if vm != "" {
+						_, _ = b.WriteString(fld[vf : vs-1])
+						_, _ = b.WriteString(vm)
+						vf = ve + 1
+					}
+				} else {
+					_, _ = b.WriteString(fld)
+				}
+				vs = 0
+				ve = 0
+				pholder = true
+			}
+		}
+		if !pholder {
 			_, _ = b.WriteString(fld)
 		}
 	}
 
-	idx := 0
-	for k, v := range values {
-		if idx == 0 {
-			_, _ = b.WriteRune('?')
-		} else {
-			_, _ = b.WriteRune('&')
-		}
-		_, _ = b.WriteString(k)
-		_, _ = b.WriteRune('=')
-		_, _ = b.WriteString(v)
-		idx++
+	if len(values) > 0 {
+		_, _ = b.WriteRune('?')
+		_, _ = b.WriteString(values.Encode())
 	}
 
-	if rutil.IsZero(nmsg) {
+	// rutil.ZeroEmpty(tnmsg.Interface())
+
+	if rutil.IsZero(nmsg) && !isEmptyStruct(nmsg) {
 		return b.String(), nil, nil
 	}
 
 	return b.String(), nmsg, nil
 }
 
-func newTemplate(path string) (util.Template, error) {
+func isEmptyStruct(v interface{}) bool {
+	val := reflect.ValueOf(v)
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+	return val.Kind() == reflect.Struct && val.NumField() == 0
+}
+
+func newTemplate(path string) ([]string, error) {
+	if len(path) == 0 || path[0] != '/' {
+		return nil, fmt.Errorf("path must starts with /")
+	}
 	mu.RLock()
 	tpl, ok := templateCache[path]
 	if ok {
@@ -146,12 +294,7 @@ func newTemplate(path string) (util.Template, error) {
 	}
 	mu.RUnlock()
 
-	rule, err := util.Parse(path)
-	if err != nil {
-		return tpl, err
-	}
-
-	tpl = rule.Compile()
+	tpl = strings.Split(path[1:], "/")
 	mu.Lock()
 	templateCache[path] = tpl
 	mu.Unlock()
@@ -159,36 +302,84 @@ func newTemplate(path string) (util.Template, error) {
 	return tpl, nil
 }
 
-func parseRsp(ctx context.Context, hrsp *http.Response, cf codec.Codec, rsp interface{}, opts client.CallOptions) error {
-	b, err := ioutil.ReadAll(hrsp.Body)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
+func (h *httpClient) parseRsp(ctx context.Context, hrsp *http.Response, rsp interface{}, opts client.CallOptions) error {
+	var err error
+	var buf []byte
 
-	if hrsp.StatusCode < 400 {
-		// unmarshal
-		if err := cf.Unmarshal(b, rsp); err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
+	// fast path return
+	if hrsp.StatusCode == http.StatusNoContent {
 		return nil
 	}
 
-	errmap, ok := opts.Context.Value(errorMapKey{}).(map[string]interface{})
-	if !ok || errmap == nil {
-		// user not provide map of errors
-		// id: req.Service() ??
-		return errors.New("go.micro.client", string(b), int32(hrsp.StatusCode))
+	if opts.ResponseMetadata != nil {
+		*opts.ResponseMetadata = metadata.New(len(hrsp.Header))
+		for k, v := range hrsp.Header {
+			opts.ResponseMetadata.Set(k, strings.Join(v, ","))
+		}
 	}
 
-	if err, ok = errmap[fmt.Sprintf("%d", hrsp.StatusCode)].(error); !ok {
-		err, ok = errmap["default"].(error)
-	}
-	if !ok {
-		return errors.New("go.micro.client", string(b), int32(hrsp.StatusCode))
-	}
+	select {
+	case <-ctx.Done():
+		err = ctx.Err()
+	default:
+		ct := DefaultContentType
+
+		if htype := hrsp.Header.Get("Content-Type"); htype != "" {
+			ct = htype
+		}
+
+		if hrsp.Body != nil {
+			buf, err = io.ReadAll(hrsp.Body)
+			if err != nil {
+				if h.opts.Logger.V(logger.ErrorLevel) {
+					h.opts.Logger.Error(ctx, "failed to read body", err)
+				}
+				return errors.InternalServerError("go.micro.client", "%s", buf)
+			}
+		}
+
+		cf, cerr := h.newCodec(ct)
+		if cerr != nil {
+			if h.opts.Logger.V(logger.DebugLevel) {
+				h.opts.Logger.Debug(ctx, fmt.Sprintf("response with %v unknown content-type %s %s", hrsp.Header, ct, buf))
+			}
+			return errors.InternalServerError("go.micro.client", "%+v", cerr)
+		}
+
+		if h.opts.Logger.V(logger.DebugLevel) {
+			h.opts.Logger.Debug(ctx, fmt.Sprintf("response %s with %v", buf, hrsp.Header))
+		}
+
+		// succeseful response
+		if hrsp.StatusCode < 400 {
+			if err = cf.Unmarshal(buf, rsp); err != nil {
+				return errors.InternalServerError("go.micro.client", "%+v", err)
+			}
+			return nil
+		}
+
+		// response with error
+		var rerr interface{}
+		errmap, ok := opts.Context.Value(errorMapKey{}).(map[string]interface{})
+		if ok && errmap != nil {
+			rerr, ok = errmap[fmt.Sprintf("%d", hrsp.StatusCode)]
+			if !ok {
+				rerr, ok = errmap["default"]
+			}
+		}
+
+		if !ok || rerr == nil {
+			return errors.New("go.micro.client", string(buf), int32(hrsp.StatusCode))
+		}
+
+		if cerr := cf.Unmarshal(buf, rerr); cerr != nil {
+			return errors.InternalServerError("go.micro.client", "%+v", cerr)
+		}
+
+		if err, ok = rerr.(error); !ok {
+			err = &Error{rerr}
+		}
 
-	if cerr := cf.Unmarshal(b, err); cerr != nil {
-		return errors.InternalServerError("go.micro.client", cerr.Error())
 	}
 
 	return err
@@ -197,5 +388,27 @@ func parseRsp(ctx context.Context, hrsp *http.Response, cf codec.Codec, rsp inte
 type tag struct {
 	key  string
 	name string
-	opts []string
+}
+
+func getParam(val reflect.Value) string {
+	var v string
+	switch val.Kind() {
+	case reflect.Ptr:
+		switch reflect.Indirect(val).Type().String() {
+		case
+			"wrapperspb.BoolValue",
+			"wrapperspb.BytesValue",
+			"wrapperspb.DoubleValue",
+			"wrapperspb.FloatValue",
+			"wrapperspb.Int32Value", "wrapperspb.Int64Value",
+			"wrapperspb.StringValue",
+			"wrapperspb.UInt32Value", "wrapperspb.UInt64Value":
+			if eva := reflect.Indirect(val).FieldByName("Value"); eva.IsValid() {
+				v = getParam(eva)
+			}
+		}
+	default:
+		v = fmt.Sprintf("%v", val.Interface())
+	}
+	return v
 }

util_test.go

@@ -1,32 +1,21 @@
 package http
 
 import (
+	"net/http"
 	"net/url"
 	"testing"
 )
 
-func TestTemplate(t *testing.T) {
-	tpl, err := newTemplate("/v1/{ClientID}/list")
-	if err != nil {
-		t.Fatal(err)
-	}
-	_ = tpl
-	//	fmt.Printf("%#+v\n", tpl.Pool)
-}
-
-func TestNewPathRequest(t *testing.T) {
+func TestParsing(t *testing.T) {
 	type Message struct {
-		Name string `json:"name"`
-		Val1 string `protobuf:"bytes,1,opt,name=val1,proto3" json:"val1"`
-		Val2 int64
-		Val3 []string
+		IIN string `protobuf:"bytes,1,opt,name=iin,proto3" json:"iin"`
 	}
 
-	omsg := &Message{Name: "test_name", Val1: "test_val1", Val2: 100, Val3: []string{"slice"}}
+	omsg := &Message{IIN: "5555"}
 
-	for _, m := range []string{"POST", "PUT", "PATCH", "GET", "DELETE"} {
+	for _, m := range []string{"POST"} {
 		body := ""
-		path, nmsg, err := newPathRequest("/v1/test", m, body, omsg, []string{"protobuf", "json"})
+		path, nmsg, err := newPathRequest("/users/iin/{iin}/push-notifications", m, body, omsg, []string{"protobuf", "json"}, nil)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -34,9 +23,77 @@ func TestNewPathRequest(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		vals := u.Query()
-		if v, ok := vals["name"]; !ok || v[0] != "test_name" {
-			t.Fatalf("invalid path: %v nmsg: %v", path, nmsg)
+		_ = nmsg
+		if u.Path != "/users/iin/5555/push-notifications" {
+			t.Fatalf("newPathRequest invalid path %s", u.Path)
+		}
+		if nmsg != nil {
+			t.Fatalf("new message must be nil: %v\n", nmsg)
+		}
+	}
+}
+
+func TestNewPathRequest(t *testing.T) {
+	type Message struct {
+		Name string `json:"name"`
+		Val1 string `protobuf:"bytes,1,opt,name=val1,proto3" json:"val1"`
+		Val3 []string
+		Val2 int64
+	}
+
+	omsg := &Message{Name: "test_name", Val1: "test_val1", Val2: 100, Val3: []string{"slice"}}
+
+	for _, m := range []string{"POST", "PUT", "PATCH", "GET", "DELETE"} {
+		body := ""
+		path, nmsg, err := newPathRequest("/v1/test", m, body, omsg, []string{"protobuf", "json"}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		u, err := url.Parse(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		switch m {
+		case http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete:
+			break
+		case http.MethodGet:
+			vals := u.Query()
+			if v, ok := vals["name"]; !ok || v[0] != "test_name" {
+				t.Fatalf("%s invalid path: %v nmsg: %v", m, path, nmsg)
+			}
+		}
+
+	}
+}
+
+func TestNewPathRequestWithEmptyBody(t *testing.T) {
+	val := struct{}{}
+	cases := []string{
+		"",
+		"*",
+		"{}",
+		"nil",
+		`{"type": "invalid"}`,
+	}
+
+	for _, body := range cases {
+		for _, m := range []string{"POST", "PUT", "PATCH", "GET", "DELETE"} {
+			path, nmsg, err := newPathRequest("/v1/test", m, body, val, []string{"protobuf", "json"}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if nmsg == nil {
+				t.Fatalf("invalid path: nil nmsg")
+			}
+
+			u, err := url.Parse(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			vals := u.Query()
+			if len(vals) != 0 {
+				t.Fatalf("invalid path: %v nmsg: %v", path, nmsg)
+			}
 		}
 	}
 }
@@ -45,8 +102,8 @@ func TestNewPathVarRequest(t *testing.T) {
 	type Message struct {
 		Name string `json:"name"`
 		Val1 string `protobuf:"bytes,1,opt,name=val1,proto3" json:"val1"`
-		Val2 int64
 		Val3 []string
+		Val2 int64
 	}
 
 	omsg := &Message{Name: "test_name", Val1: "test_val1", Val2: 100, Val3: []string{"slice"}}
@@ -56,7 +113,7 @@ func TestNewPathVarRequest(t *testing.T) {
 		if m != "GET" {
 			body = "*"
 		}
-		path, nmsg, err := newPathRequest("/v1/test/{val1}", m, body, omsg, []string{"protobuf", "json"})
+		path, nmsg, err := newPathRequest("/v1/test/{val1}", m, body, omsg, []string{"protobuf", "json"}, nil)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -69,7 +126,7 @@ func TestNewPathVarRequest(t *testing.T) {
 				t.Fatalf("invalid nmsg: %#+v\n", nmsg)
 			}
 			if nmsg.(*Message).Name != "test_name" {
-				t.Fatalf("invalid nmsg: %v nmsg: %v", path, nmsg)
+				t.Fatalf("invalid path: %v nmsg: %#+v", path, nmsg)
 			}
 		} else {
 			vals := u.Query()