Merge pull request #17 from lxzan/dev

添加WithBaseURL选项

Author: lxzan

README.md

@@ -132,4 +132,19 @@ after := hasaki.WithAfter(func(ctx context.Context, response *http.Response) (co
 var url = "https://api.github.com/search/repositories"
 cli, _ := hasaki.NewClient(before, after)
 cli.Get(url).Send(nil)
+```
+
+#### Base URL
+
+You can set a base URL for all requests made by the client.
+
+```go
+// Create a client with base URL
+cli, _ := hasaki.NewClient(hasaki.WithBaseURL("https://api.example.com"))
+
+// GET https://api.example.com/users
+resp := cli.Get("/users").Send(nil)
+
+// GET https://api.example.com/api/v1/products
+resp := cli.Get("/api/v1/products").Send(nil)
 ```

client.go

@@ -7,6 +7,8 @@ import (
 	"strings"
 )
 
+// Client HTTP客户端
+// HTTP client
 type Client struct {
 	config *config
 }
@@ -23,39 +25,60 @@ func NewClient(options ...Option) (*Client, error) {
 	return client, nil
 }
 
+// Get 发送GET请求
+// Send GET request
 func (c *Client) Get(url string, args ...any) *Request {
 	return c.Request(http.MethodGet, url, args...)
 }
 
+// Post 发送POST请求
+// Send POST request
 func (c *Client) Post(url string, args ...any) *Request {
 	return c.Request(http.MethodPost, url, args...)
 }
 
+// Put 发送PUT请求
+// Send PUT request
 func (c *Client) Put(url string, args ...any) *Request {
 	return c.Request(http.MethodPut, url, args...)
 }
 
+// Delete 发送DELETE请求
+// Send DELETE request
 func (c *Client) Delete(url string, args ...any) *Request {
 	return c.Request(http.MethodDelete, url, args...)
 }
 
+// Head 发送HEAD请求
+// Send HEAD request
 func (c *Client) Head(url string, args ...any) *Request {
 	return c.Request(http.MethodHead, url, args...)
 }
 
+// Options 发送OPTIONS请求
+// Send OPTIONS request
 func (c *Client) Options(url string, args ...any) *Request {
 	return c.Request(http.MethodOptions, url, args...)
 }
 
+// Patch 发送PATCH请求
+// Send PATCH request
 func (c *Client) Patch(url string, args ...any) *Request {
 	return c.Request(http.MethodPatch, url, args...)
 }
 
+// Request 创建HTTP请求
+// Create HTTP request
 func (c *Client) Request(method string, url string, args ...any) *Request {
 	if len(args) > 0 {
 		url = fmt.Sprintf(url, args...)
 	}
 
+	// 如果配置了 BaseURL，则合并 URL
+	if c.config.BaseURL != "" {
+		url = c.config.BaseURL + url
+	}
+
 	r := &Request{
 		ctx:              context.Background(),
 		client:           c.config.HTTPClient,

client_test.go

@@ -2,11 +2,13 @@ package hasaki
 
 import (
 	"context"
+	"encoding/xml"
 	"fmt"
 	"net"
 	"net/http"
 	"net/url"
 	"strconv"
+	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -263,6 +265,7 @@ func TestMiddleware(t *testing.T) {
 
 		after := WithAfter(func(ctx context.Context, response *http.Response) (context.Context, error) {
 			t0 := ctx.Value("t0").(time.Time)
+			time.Sleep(time.Millisecond)
 			return context.WithValue(ctx, "latency", time.Since(t0).Nanoseconds()), nil
 		})
 
@@ -410,3 +413,191 @@ func TestRequest_ReadBody(t *testing.T) {
 		assert.NoError(t, err)
 	})
 }
+
+func TestWithBaseURL(t *testing.T) {
+	addr := nextAddr()
+	srv := &http.Server{Addr: addr}
+	srv.Handler = http.Handler(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		switch request.URL.Path {
+		case "/api/users":
+			writer.WriteHeader(http.StatusOK)
+		case "/users":
+			writer.WriteHeader(http.StatusOK)
+		default:
+			writer.WriteHeader(http.StatusOK)
+		}
+	}))
+	go srv.ListenAndServe()
+	time.Sleep(100 * time.Millisecond)
+
+	t.Run("base url with relative path", func(t *testing.T) {
+		baseURL := "http://" + addr
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		req := cli.Get("/api/users")
+		expectedURL := baseURL + "/api/users"
+		assert.Equal(t, req.url, expectedURL)
+	})
+
+	t.Run("base url with absolute path", func(t *testing.T) {
+		baseURL := "http://" + addr
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		req := cli.Get("http://example.com/users")
+		// 当传入绝对 URL 时，应该直接使用该 URL（当前实现是字符串拼接）
+		expectedURL := baseURL + "http://example.com/users"
+		assert.Equal(t, req.url, expectedURL)
+	})
+
+	t.Run("base url with empty path", func(t *testing.T) {
+		baseURL := "http://" + addr
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		req := cli.Get("")
+		expectedURL := baseURL
+		assert.Equal(t, req.url, expectedURL)
+	})
+
+	t.Run("base url with formatted path", func(t *testing.T) {
+		baseURL := "http://" + addr
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		req := cli.Get("/api/%s", "users")
+		expectedURL := baseURL + "/api/users"
+		assert.Equal(t, req.url, expectedURL)
+	})
+
+	t.Run("base url actual request", func(t *testing.T) {
+		baseURL := "http://" + addr
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		resp := cli.Get("/api/users").Send(nil)
+		assert.NoError(t, resp.Err())
+		assert.Equal(t, resp.StatusCode, http.StatusOK)
+	})
+
+	t.Run("base url without trailing slash", func(t *testing.T) {
+		baseURL := "http://" + addr
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		req := cli.Get("/users")
+		expectedURL := baseURL + "/users"
+		assert.Equal(t, req.url, expectedURL)
+	})
+
+	t.Run("base url with trailing slash", func(t *testing.T) {
+		baseURL := "http://" + addr + "/"
+		cli, _ := NewClient(WithBaseURL(baseURL))
+		req := cli.Get("users")
+		expectedURL := baseURL + "users"
+		assert.Equal(t, req.url, expectedURL)
+	})
+}
+
+func TestResponse_BindJSON(t *testing.T) {
+	addr := nextAddr()
+	srv := &http.Server{Addr: addr}
+	srv.Handler = http.Handler(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		writer.WriteHeader(http.StatusOK)
+		writer.Write([]byte(`{"name":"test","age":18}`))
+	}))
+	go srv.ListenAndServe()
+	time.Sleep(100 * time.Millisecond)
+
+	t.Run("bind json success", func(t *testing.T) {
+		type User struct {
+			Name string `json:"name"`
+			Age  int    `json:"age"`
+		}
+		var user User
+		resp := Get("http://%s", addr).Send(nil)
+		err := resp.BindJSON(&user)
+		assert.NoError(t, err)
+		assert.Equal(t, user.Name, "test")
+		assert.Equal(t, user.Age, 18)
+	})
+
+	t.Run("bind json with error response", func(t *testing.T) {
+		type User struct {
+			Name string `json:"name"`
+		}
+		var user User
+		resp := Get("http://127.0.0.1:xx").Send(nil)
+		err := resp.BindJSON(&user)
+		assert.Error(t, err)
+	})
+}
+
+func TestResponse_BindXML(t *testing.T) {
+	addr := nextAddr()
+	srv := &http.Server{Addr: addr}
+	srv.Handler = http.Handler(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		writer.WriteHeader(http.StatusOK)
+		writer.Write([]byte(`<user><name>test</name><age>18</age></user>`))
+	}))
+	go srv.ListenAndServe()
+	time.Sleep(100 * time.Millisecond)
+
+	t.Run("bind xml success", func(t *testing.T) {
+		type User struct {
+			XMLName xml.Name `xml:"user"`
+			Name    string   `xml:"name"`
+			Age     int      `xml:"age"`
+		}
+		var user User
+		resp := Get("http://%s", addr).Send(nil)
+		err := resp.BindXML(&user)
+		assert.NoError(t, err)
+		assert.Equal(t, user.Name, "test")
+		assert.Equal(t, user.Age, 18)
+	})
+}
+
+func TestResponse_BindForm(t *testing.T) {
+	addr := nextAddr()
+	srv := &http.Server{Addr: addr}
+	srv.Handler = http.Handler(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		writer.WriteHeader(http.StatusOK)
+		writer.Write([]byte("name=test&age=18"))
+	}))
+	go srv.ListenAndServe()
+	time.Sleep(100 * time.Millisecond)
+
+	t.Run("bind form success", func(t *testing.T) {
+		var params url.Values
+		resp := Get("http://%s", addr).Send(nil)
+		err := resp.BindForm(&params)
+		assert.NoError(t, err)
+		assert.Equal(t, params.Get("name"), "test")
+		assert.Equal(t, params.Get("age"), "18")
+	})
+}
+
+func TestRequest_SetEncoder(t *testing.T) {
+	req := Get("https://api.example.com")
+	req.SetEncoder(FormCodec)
+	assert.Equal(t, req.headers.Get("Content-Type"), MimeForm)
+
+	req.SetEncoder(JsonCodec)
+	assert.Equal(t, req.headers.Get("Content-Type"), MimeJson)
+
+	req.SetEncoder(XmlCodec)
+	assert.Equal(t, req.headers.Get("Content-Type"), MimeXml)
+}
+
+func TestJsonCodec_Decode(t *testing.T) {
+	t.Run("decode success", func(t *testing.T) {
+		type User struct {
+			Name string `json:"name"`
+			Age  int    `json:"age"`
+		}
+		var user User
+		reader := strings.NewReader(`{"name":"test","age":18}`)
+		err := JsonCodec.Decode(reader, &user)
+		assert.NoError(t, err)
+		assert.Equal(t, user.Name, "test")
+		assert.Equal(t, user.Age, 18)
+	})
+
+	t.Run("decode map", func(t *testing.T) {
+		var result map[string]any
+		reader := strings.NewReader(`{"name":"test","age":18}`)
+		err := JsonCodec.Decode(reader, &result)
+		assert.NoError(t, err)
+		assert.Equal(t, result["name"], "test")
+	})
+}

codec.go

@@ -13,40 +13,74 @@ import (
 )
 
 const (
-	MimeJson     = "application/json;charset=utf-8"
-	MimeYaml     = "application/x-yaml;charset=utf-8"
-	MimeXml      = "application/xml;charset=utf-8"
+	// MimeJson JSON MIME类型
+	// JSON MIME type
+	MimeJson = "application/json;charset=utf-8"
+	// MimeYaml YAML MIME类型
+	// YAML MIME type
+	MimeYaml = "application/x-yaml;charset=utf-8"
+	// MimeXml XML MIME类型
+	// XML MIME type
+	MimeXml = "application/xml;charset=utf-8"
+	// MimeProtoBuf Protobuf MIME类型
+	// Protobuf MIME type
 	MimeProtoBuf = "application/x-protobuf"
-	MimeForm     = "application/x-www-form-urlencoded"
-	MimeStream   = "application/octet-stream"
-	MimeJpeg     = "image/jpeg"
-	MimeGif      = "image/gif"
-	MimePng      = "image/png"
-	MimeMp4      = "video/mpeg4"
+	// MimeForm 表单 MIME类型
+	// Form MIME type
+	MimeForm = "application/x-www-form-urlencoded"
+	// MimeStream 流式 MIME类型
+	// Stream MIME type
+	MimeStream = "application/octet-stream"
+	// MimeJpeg JPEG图片 MIME类型
+	// JPEG image MIME type
+	MimeJpeg = "image/jpeg"
+	// MimeGif GIF图片 MIME类型
+	// GIF image MIME type
+	MimeGif = "image/gif"
+	// MimePng PNG图片 MIME类型
+	// PNG image MIME type
+	MimePng = "image/png"
+	// MimeMp4 MP4视频 MIME类型
+	// MP4 video MIME type
+	MimeMp4 = "video/mpeg4"
 )
 
+// Any 通用类型映射
+// Generic type map
 type Any map[string]any
 
 type (
+	// Codec 编解码器接口，同时包含编码和解码功能
+	// Codec interface, includes both encoding and decoding functionality
 	Codec interface {
 		Encoder
 		Decoder
 	}
 
+	// Encoder 编码器接口
+	// Encoder interface
 	Encoder interface {
 		Encode(v any) (io.Reader, error)
 		ContentType() string
 	}
 
+	// Decoder 解码器接口
+	// Decoder interface
 	Decoder interface {
 		Decode(r io.Reader, v any) error
 	}
 )
 
 var (
+	// JsonCodec JSON编解码器
+	// JSON codec
 	JsonCodec = new(jsonCodec)
+	// FormCodec 表单编解码器
+	// Form codec
 	FormCodec = new(formCodec)
-	XmlCodec  = new(xmlCodec)
+	// XmlCodec XML编解码器
+	// XML codec
+	XmlCodec = new(xmlCodec)
 )
 
 type (
@@ -130,6 +164,8 @@ type streamEncoder struct {
 	contentType string
 }
 
+// NewStreamEncoder 创建流式编码器
+// Create a stream encoder
 func NewStreamEncoder(contentType string) Encoder {
 	return &streamEncoder{contentType: contentType}
 }