Merge tag 'v2.0.0' into develop

更高单元测试, 修改了大量的bug, 可以投入生产

.gitignore

@@ -1 +1,2 @@
 *.pyc
+*.vscode

base.go

@@ -7,33 +7,43 @@ import (
 	"reflect"
 )
 
-func buildBodyRequest(ver, rawurl string, body *Body) *http.Request {
+func buildBodyRequest(wf *Workflow) *http.Request {
 	var req *http.Request
 	var err error
+	contentType := ""
 
-	if body.IOBody == nil {
-		req, err = http.NewRequest(ver, rawurl, nil)
+	if wf.Body.GetIOBody() == nil {
+		req, err = http.NewRequest(wf.Method, wf.GetRawURL(), nil)
 	} else {
 		var bodybuf *bytes.Buffer
-		switch body.IOBody.(type) {
+		switch wf.Body.GetIOBody().(type) {
 		case []byte:
-			bodybuf = bytes.NewBuffer(body.IOBody.([]byte))
+			bodybuf = bytes.NewBuffer(wf.Body.GetIOBody().([]byte))
+		case string:
+			bodybuf = bytes.NewBuffer([]byte(wf.Body.GetIOBody().(string)))
 		case *bytes.Buffer:
-			bodybuf = bytes.NewBuffer(body.IOBody.(*bytes.Buffer).Bytes())
+			bodybuf = bytes.NewBuffer(wf.Body.GetIOBody().(*bytes.Buffer).Bytes())
 		default:
-			panic(errors.New("the type is not exist, type is" + reflect.TypeOf(body.IOBody).String()))
+			panic(errors.New("the type is not exist, type is " + reflect.TypeOf(wf.Body.GetIOBody()).String()))
 		}
-		req, err = http.NewRequest(ver, rawurl, bodybuf)
+		req, err = http.NewRequest(wf.Method, wf.GetRawURL(), bodybuf)
 	}
 
 	if err != nil {
 		panic(err)
 	}
 
-	if body.ContentType == "" {
-		req.Header.Set(HeaderKeyContentType, TypeURLENCODED)
+	if wf.Body.ContentType() != "" {
+		contentType = wf.Body.ContentType()
 	} else {
-		req.Header.Set(HeaderKeyContentType, body.ContentType)
+		contentType = ""
+		if wf.Method == "POST" || wf.Method == "PUT" || wf.Method == "PATCH" {
+			contentType = TypeURLENCODED
+		}
+	}
+
+	if contentType != "" {
+		req.Header.Set(HeaderKeyContentType, contentType)
 	}
 
 	return req

go.mod

@@ -0,0 +1,13 @@
+module requests
+
+go 1.12
+
+require (
+	github.com/474420502/gjson v1.1.3
+	github.com/elazarl/goproxy v0.0.0-20190711103511-473e67f1d7d2
+	github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2 // indirect
+	github.com/tidwall/match v1.0.1 // indirect
+	golang.org/x/net v0.0.0-00010101000000-000000000000
+)
+
+replace golang.org/x/net => github.com/golang/net v0.0.0-20190902185345-cdfb69ac37fc6fa907650654115ebebb3aae2087

go.sum

@@ -0,0 +1,11 @@
+github.com/474420502/gjson v1.1.3 h1:rQxKNSFS8bM5iVVKKb9EHY1SS2k+EhzVNUXe2xSGn8o=
+github.com/474420502/gjson v1.1.3/go.mod h1:mdAOevjPYIFWOE8CpejPHwoJCz96oNnuwhjhrAVeKaY=
+github.com/elazarl/goproxy v0.0.0-20190711103511-473e67f1d7d2 h1:aZtFdDNWY/yH86JPR2WX/PN63635VsE/f/nXNPAbYxY=
+github.com/elazarl/goproxy v0.0.0-20190711103511-473e67f1d7d2/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
+github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2 h1:dWB6v3RcOy03t/bUadywsbyrQwCqZeNIEX6M1OtSZOM=
+github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2/go.mod h1:gNh8nYJoAm43RfaxurUnxr+N1PwuFV3ZMl/efxlIlY8=
+github.com/golang/net v0.0.0-20190902185345-cdfb69ac37fc6fa907650654115ebebb3aae2087 h1:haK1T12C0CO79KUdu+ZzLL9+l9BwM9PRkd2/mQqdg8E=
+github.com/golang/net v0.0.0-20190902185345-cdfb69ac37fc6fa907650654115ebebb3aae2087/go.mod h1:98y8FxUyMjTdJ5eOj/8vzuiVO14/dkJ98NYhEPG8QGY=
+github.com/rogpeppe/go-charset v0.0.0-20180617210344-2471d30d28b4/go.mod h1:qgYeAmZ5ZIpBWTGllZSQnw97Dj+woV0toclVaRGI8pc=
+github.com/tidwall/match v1.0.1 h1:PnKP62LPNxHKTwvHHZZzdOAOCtsJTjo6dZLCwpKm5xc=
+github.com/tidwall/match v1.0.1/go.mod h1:LujAq0jyVjBy028G1WhWfIzbpQfMO8bBZ6Tyb0+pL9E=

init_test.go

@@ -0,0 +1,29 @@
+package requests
+
+import (
+	"log"
+	"net/http"
+	"os/exec"
+	"time"
+
+	"github.com/elazarl/goproxy"
+)
+
+const ProxyAddress = "localhost:58080"
+
+func init() {
+	log.SetFlags(log.Lshortfile | log.LstdFlags)
+	go func() {
+		proxy := goproxy.NewProxyHttpServer()
+		proxy.Verbose = true
+		http.ListenAndServe(ProxyAddress, proxy)
+	}()
+
+	cmd := exec.Command("/bin/bash", "-c", "docker ps | grep httpbin")
+	_, err := cmd.Output()
+	if err != nil {
+		log.Println("recommend 1. docker run -p 80:80 kennethreitz/httpbin  \n2. echo \"127.0.0.1	httpbin.org\" >> /etc/hosts")
+	}
+
+	time.Sleep(time.Millisecond * 100)
+}

multipart.go

@@ -15,16 +15,19 @@ func writeFormUploadFile(mwriter *multipart.Writer, ufile *UploadFile) {
 		log.Panic(err)
 	}
 	io.Copy(part, ufile.FileReaderCloser)
+
+	err = ufile.FileReaderCloser.Close()
+	if err != nil {
+		panic(err)
+	}
 }
 
-func createMultipart(postParams *Body, params []interface{}) {
+func createMultipart(postParams IBody, params []interface{}) {
 	plen := len(params)
 
 	body := &bytes.Buffer{}
 	mwriter := multipart.NewWriter(body)
 
-	defer mwriter.Close()
-
 	for _, iparam := range params[0 : plen-1] {
 		switch param := iparam.(type) {
 		case *UploadFile:
@@ -32,6 +35,11 @@ func createMultipart(postParams *Body, params []interface{}) {
 				param.FieldName = "file0"
 			}
 			writeFormUploadFile(mwriter, param)
+		case UploadFile:
+			if param.FieldName == "" {
+				param.FieldName = "file0"
+			}
+			writeFormUploadFile(mwriter, &param)
 		case []*UploadFile:
 			for i, p := range param {
 				if p.FieldName == "" {
@@ -39,6 +47,13 @@ func createMultipart(postParams *Body, params []interface{}) {
 				}
 				writeFormUploadFile(mwriter, p)
 			}
+		case []UploadFile:
+			for i, p := range param {
+				if p.FieldName == "" {
+					p.FieldName = "file" + strconv.Itoa(i)
+				}
+				writeFormUploadFile(mwriter, &p)
+			}
 		case string:
 			uploadFiles, err := UploadFileFromGlob(param)
 			if err != nil {
@@ -60,7 +75,7 @@ func createMultipart(postParams *Body, params []interface{}) {
 				} else {
 					for ii, p := range uploadFiles {
 						if p.FieldName == "" {
-							p.FieldName = "file" + strconv.Itoa(ii) + "_" + strconv.Itoa(i)
+							p.FieldName = "file" + strconv.Itoa(i) + "_" + strconv.Itoa(ii)
 						}
 						writeFormUploadFile(mwriter, p)
 					}
@@ -85,6 +100,11 @@ func createMultipart(postParams *Body, params []interface{}) {
 		}
 	}
 
-	postParams.ContentType = mwriter.FormDataContentType()
-	postParams.IOBody = body
+	postParams.AddContentType(mwriter.FormDataContentType())
+	postParams.SetIOBody(body)
+
+	err := mwriter.Close()
+	if err != nil {
+		panic(err)
+	}
 }

response.go

@@ -9,52 +9,78 @@ import (
 	"net/http"
 )
 
-// Response 响应内容包含http.Response
+// Response 响应内容包含http.Response 已读
 type Response struct {
-	DContent  string
-	GResponse *http.Response
+	readContent  string
+	readResponse *http.Response
 }
 
 // FromHTTPResponse 生成Response 从标准http.Response
-func FromHTTPResponse(resp *http.Response) (*Response, error) {
-
+func FromHTTPResponse(resp *http.Response, isDecompressNoAccept bool) (*Response, error) {
+	var err error
 	// 复制response 返回内容 并且测试是否有解压的需求
 	srcbuf, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
 	resp.Body.Close()
 
-	cbuf := bytes.NewBuffer([]byte{})
-	_, err = io.Copy(cbuf, bytes.NewReader(srcbuf))
+	content := ""
 
-	if err != nil {
-		panic(err)
+	if isDecompressNoAccept { // 在某个已经遗忘的网页测试过, 为了兼容 Python requests
+		srcReader := bytes.NewReader(srcbuf)
+		var reader io.ReadCloser
+		if reader, err = gzip.NewReader(srcReader); err == nil {
+			defer reader.Close()
+			buf, err := ioutil.ReadAll(reader)
+			if err != nil {
+				return nil, err
+			}
+			content = string(buf)
+		} else if reader, err = zlib.NewReader(srcReader); err == nil {
+			defer reader.Close()
+			buf, err := ioutil.ReadAll(reader)
+			if err != nil {
+				return nil, err
+			}
+			content = string(buf)
+		} else {
+			content = string(srcbuf)
+		}
+
+	} else {
+		content = string(srcbuf)
 	}
 
-	resp.Body = ioutil.NopCloser(cbuf)
-
-	content := string(srcbuf)
-	srcReader := bytes.NewReader(srcbuf)
-
-	if r, err := gzip.NewReader(srcReader); err == nil {
-		buf, err := ioutil.ReadAll(r)
-		if err != nil {
-			panic(err)
-		}
-		content = string(buf)
-	} else if r, err := zlib.NewReader(srcReader); err == nil {
-		buf, err := ioutil.ReadAll(r)
-		if err != nil {
-			panic(err)
-		}
-		content = string(buf)
-	}
-
-	return &Response{DContent: content, GResponse: resp}, nil
+	return &Response{readContent: content, readResponse: resp}, nil
 }
 
 // Content 返回解压后的内容
 func (gresp *Response) Content() string {
-	return gresp.DContent
+	return gresp.readContent
+}
+
+// GetSrcResponse  获取原生golang http.Response
+func (gresp *Response) GetSrcResponse() *http.Response {
+	return gresp.readResponse
+}
+
+// GetStatue 获取Statue String
+func (gresp *Response) GetStatue() string {
+	return gresp.readResponse.Status
+}
+
+// GetStatueCode 获取Statue int
+func (gresp *Response) GetStatueCode() int {
+	return gresp.readResponse.StatusCode
+}
+
+// GetHeader Header map[string][]string
+func (gresp *Response) GetHeader() http.Header {
+	return gresp.readResponse.Header
+}
+
+// GetContentLength 获取Content的内容长度, 如果存在 IsDecompressNoAccept 可能是压缩级别的长度, 非GetContent长度
+func (gresp *Response) GetContentLength() int64 {
+	return gresp.readResponse.ContentLength
 }

response_test.go

@@ -1,9 +1,62 @@
 package requests
 
 import (
+	"net/http"
 	"testing"
+
+	"github.com/474420502/gjson"
 )
 
-func TestTest(t *testing.T) {
+func TestFromHTTPResponse(t *testing.T) {
+
+	var gresp *http.Response
+	var err error
+	gresp, err = http.DefaultClient.Get("http://httpbin.org/get")
+	if err != nil {
+		t.Error(err)
+	}
+	resp, err := FromHTTPResponse(gresp, false)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if gjson.Get(resp.Content(), "headers.Host").String() != "httpbin.org" {
+		t.Error("headers.Host != httpbin.org ?")
+	}
+
+	if resp.GetSrcResponse().StatusCode != 200 {
+		t.Error("StatusCode != 200")
+	}
+
+	if len(resp.GetSrcResponse().Header) == 0 {
+		t.Error("esp.GetSrcResponse().Header == nil")
+	}
+
+	if resp.GetStatue() != "200 OK" || resp.GetStatueCode() != 200 {
+		t.Error(" resp.GetStatue() != 200 OK")
+	}
+
+	if len(resp.GetHeader()["Content-Length"]) != 1 {
+		t.Error("resp.GetHeader() is error ?")
+	}
+
+	if int64(len(resp.Content())) != resp.GetContentLength() {
+		t.Error("content len is not equal")
+	}
+}
+
+func TestResponseDeflate(t *testing.T) {
+	ses := NewSession()
+	if wf := ses.Get("http://httpbin.org/get"); wf != nil {
+		wf.AddHeader("accept-encoding", "deflate")
+		resp, err := wf.Execute()
+		if err != nil {
+			t.Error(err)
+		} else {
+			if gjson.Get(resp.Content(), "headers.Accept-Encoding").String() != "deflate" {
+				t.Error("Accept-Encoding != deflate ?")
+			}
+		}
+	}
 
 }

session.go

@@ -7,6 +7,8 @@ import (
 	"net/http/cookiejar"
 	"net/url"
 	"reflect"
+	"runtime"
+	"strings"
 	"time"
 
 	"golang.org/x/net/publicsuffix"
@@ -15,9 +17,69 @@ import (
 // Body 相关参数结构
 type Body struct {
 	// Query       map[string][]string
-	IOBody interface{}
+	ioBody interface{}
+	// prefix ContentType 前缀
+	prefix string
 	// Files       []UploadFile
-	ContentType string
+	contentTypes map[string]int
+}
+
+// NewBody new body pointer
+func NewBody() *Body {
+	b := &Body{}
+	b.contentTypes = make(map[string]int)
+	return b
+}
+
+// SetIOBody 设置IOBody的值
+func (body *Body) SetIOBody(iobody interface{}) {
+	body.ioBody = iobody
+}
+
+// GetIOBody 获取ioBody值
+func (body *Body) GetIOBody() interface{} {
+	return body.ioBody
+}
+
+// ContentType 获取ContentType
+func (body *Body) ContentType() string {
+	content := body.prefix
+	for kvalue := range body.contentTypes {
+		content += kvalue + ";"
+	}
+	return strings.TrimRight(content, ";")
+}
+
+// SetPrefix SetPrefix 和 AddContentType的顺序会影响到ContentType()的返回结果
+func (body *Body) SetPrefix(ct string) {
+	body.prefix = strings.TrimRight(ct, ";") + ";"
+}
+
+// AddContentType 添加 Add Type类型
+func (body *Body) AddContentType(ct string) {
+	for _, v := range strings.Split(ct, ";") {
+		v = strings.Trim(v, " ")
+		if v != "" {
+			if body.prefix != v {
+				body.contentTypes[v] = 1
+			}
+		}
+	}
+
+}
+
+// IBody 相关参数结构
+type IBody interface {
+	// GetIOBody  获取iobody data
+	GetIOBody() interface{}
+	// SetIOBody  设置iobody data
+	SetIOBody(iobody interface{})
+	// ContentType      返回包括 Prefix 所有的ContentType
+	ContentType() string
+	// AppendContent
+	AddContentType(ct string)
+	// SetPrefix 设置 Prefix;  唯一前缀; 就是ContentType的第一个, ContentType(Prefix);ContentType;ContentType
+	SetPrefix(ct string)
 }
 
 // BasicAuth 帐号认真结构
@@ -28,29 +90,62 @@ type BasicAuth struct {
 	Password string
 }
 
+// IsSetting 是否设置的一些情景
+type IsSetting struct {
+	isDecompressNoAccept bool
+}
+
 // Session 的基本方法
 type Session struct {
+	auth *BasicAuth
+
+	body IBody
+
 	client    *http.Client
-	transport *http.Transport
 	cookiejar http.CookieJar
-	params    *Body
-	Header    http.Header
-	auth      *BasicAuth
+
+	transport *http.Transport
+
+	Header http.Header
+	Query  url.Values
+
+	Is IsSetting
 }
 
 const (
 	// TypeJSON 类型
 	TypeJSON = "application/json"
+
 	// TypeXML 类型
 	TypeXML = "text/xml"
+
+	// TypePlain 类型
+	TypePlain = "text/plain"
+
+	// TypeHTML 类型
+	TypeHTML = "text/html"
+
 	// TypeURLENCODED 类型
 	TypeURLENCODED = "application/x-www-form-urlencoded"
-	// TypeFormData 类型
+
+	// TypeForm PostForm类型
+	TypeForm = TypeURLENCODED
+
+	// TypeStream application/octet-stream 只能提交一个二进制流, 很少用
+	TypeStream = "application/octet-stream"
+
+	// TypeFormData 类型 Upload File 支持path(string) 自动转换成UploadFile
 	TypeFormData = "multipart/form-data"
+
+	// TypeMixed Mixed类型
+	TypeMixed = "multipart/mixed"
+
 	// HeaderKeyHost Host
 	HeaderKeyHost = "Host"
+
 	// HeaderKeyUA User-Agent
 	HeaderKeyUA = "User-Agent"
+
 	// HeaderKeyContentType Content-Type
 	HeaderKeyContentType = "Content-Type"
 )
@@ -60,32 +155,41 @@ type TypeConfig int
 
 const (
 	_ TypeConfig = iota
-	// ConfigRequestTimeout request 包括 dial request redirect 总时间超时
-	ConfigRequestTimeout // 支持time.Duration 和 int(秒为单位)
+	// CRequestTimeout request 包括 dial request redirect 总时间超时
+	CRequestTimeout // 支持time.Duration 和 int(秒为单位)
 
-	// ConfigDialTimeout 一个Connect过程的Timeout
-	ConfigDialTimeout // 支持time.Duration 和 int(秒为单位)
+	// CDialTimeout 一个Connect过程的Timeout
+	CDialTimeout // 支持time.Duration 和 int(秒为单位)
 
-	// ConfigProxy 代理链接
-	ConfigProxy // http, https, socks5
+	// CKeepAlives 默认KeepAlives false, 如果默认为true容易被一直KeepAlives, 没关闭链接
+	CKeepAlives
 
-	// ConfigInsecure InsecureSkipVerify
-	ConfigInsecure // true, false
+	// CProxy 代理链接
+	CProxy // http, https, socks5
 
-	// ConfigBasicAuth 帐号认证
-	ConfigBasicAuth // user pwd
+	// CInsecure InsecureSkipVerify
+	CInsecure // true, false
 
-	// ConfigTLS 帐号认证
-	ConfigTLS // user pwd
+	// CBasicAuth 帐号认证
+	CBasicAuth // user pwd
 
-	// ConfigCookiejar 持久化 CookieJar
-	ConfigCookiejar // true or false ; default = true
+	// CTLS 帐号认证
+	CTLS // user pwd
+
+	// CIsWithCookiejar 持久化 CookieJar true or false ; default = true
+	CIsWithCookiejar
+
+	// CIsDecompressNoAccept 解压 当response header 不存在 Accept-Encoding
+	// 很多特殊情景会不返回Accept-Encoding: Gzip. 如 不按照标准的网站
+	CIsDecompressNoAccept
 )
 
 // NewSession 创建Session
 func NewSession() *Session {
 	client := &http.Client{}
-	transport := &http.Transport{DisableCompression: true}
+	transport := &http.Transport{DisableCompression: true, DisableKeepAlives: true}
+
+	EnsureTransporterFinalized(transport)
 
 	client.Transport = transport
 	cjar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
@@ -94,14 +198,14 @@ func NewSession() *Session {
 	}
 
 	client.Jar = cjar
-	return &Session{client: client, params: &Body{}, transport: transport, auth: nil, cookiejar: client.Jar, Header: make(http.Header)}
+	return &Session{client: client, body: NewBody(), transport: transport, auth: nil, cookiejar: client.Jar, Header: make(http.Header), Is: IsSetting{false}}
 }
 
 // SetConfig 设置配置
 func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 
 	switch typeConfig {
-	case ConfigRequestTimeout:
+	case CRequestTimeout:
 		switch v := values.(type) {
 		case time.Duration:
 			ses.client.Timeout = v
@@ -116,22 +220,23 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 		default:
 			panic(errors.New("error type " + reflect.TypeOf(v).String()))
 		}
-	case ConfigDialTimeout:
-		// 没时间实现这些小细节
-	case ConfigCookiejar:
+	case CDialTimeout:
+		// TODO: CDialTimeout CRequestTimeout 与 细节
+	case CIsDecompressNoAccept:
+		ses.Is.isDecompressNoAccept = values.(bool)
+	case CKeepAlives:
+		// println(ses.transport.DisableKeepAlives)
+		ses.transport.DisableKeepAlives = !values.(bool)
+	case CIsWithCookiejar:
 		v := values.(bool)
 		if v {
-			if ses.cookiejar == nil {
-				j, err := cookiejar.New(nil)
-				if err != nil {
-					panic(err)
-				}
-				ses.cookiejar = j
+			if ses.client.Jar == nil {
+				ses.client.Jar = ses.cookiejar
 			}
 		} else {
-			ses.cookiejar = nil
+			ses.client.Jar = nil
 		}
-	case ConfigProxy:
+	case CProxy:
 		switch v := values.(type) {
 		case string:
 			purl, err := (url.Parse(v))
@@ -141,12 +246,14 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 			ses.transport.Proxy = http.ProxyURL(purl)
 		case *url.URL:
 			ses.transport.Proxy = http.ProxyURL(v)
+		case nil:
+			ses.transport.Proxy = nil
 		}
-	case ConfigInsecure:
-		ses.transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: !values.(bool)}
-	case ConfigTLS:
+	case CInsecure:
+		ses.transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: values.(bool)}
+	case CTLS:
 		ses.transport.TLSClientConfig = values.(*tls.Config)
-	case ConfigBasicAuth:
+	case CBasicAuth:
 		if ses.auth == nil {
 			ses.auth = &BasicAuth{}
 		}
@@ -154,13 +261,13 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 		switch v := values.(type) {
 		case *BasicAuth:
 			ses.auth.User = v.User
-			ses.auth.User = v.Password
+			ses.auth.Password = v.Password
 		case BasicAuth:
 			ses.auth.User = v.User
-			ses.auth.User = v.Password
+			ses.auth.Password = v.Password
 		case []string:
 			ses.auth.User = v[0]
-			ses.auth.User = v[1]
+			ses.auth.Password = v[1]
 		case nil:
 			ses.auth = nil
 		}
@@ -170,13 +277,33 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 	return
 }
 
+// SetQuery 设置url query的持久参数的值
+func (ses *Session) SetQuery(values url.Values) {
+	ses.Query = values
+}
+
+// GetQuery 获取get query的值
+func (ses *Session) GetQuery() url.Values {
+	return ses.Query
+}
+
+// SetHeader 设置set Header的值, 必须符合规范 HaHa -> Haha 如果真要HaHa,只能这样 Ha-Ha
+func (ses *Session) SetHeader(header http.Header) {
+	ses.Header = header
+}
+
+// GetHeader 获取get Header的值
+func (ses *Session) GetHeader() http.Header {
+	return ses.Header
+}
+
 // SetCookies 设置Cookies 或者添加Cookies Del
 func (ses *Session) SetCookies(u *url.URL, cookies []*http.Cookie) {
 	ses.cookiejar.SetCookies(u, cookies)
 }
 
-// Cookies 返回 Cookies
-func (ses *Session) Cookies(u *url.URL) []*http.Cookie {
+// GetCookies 返回 Cookies
+func (ses *Session) GetCookies(u *url.URL) []*http.Cookie {
 	return ses.cookiejar.Cookies(u)
 }
 
@@ -186,63 +313,82 @@ func (ses *Session) DelCookies(u *url.URL, name string) {
 	for _, c := range cookies {
 		if c.Name == name {
 			c.MaxAge = -1
+			break
 		}
 	}
 	ses.SetCookies(u, cookies)
 }
 
+// ClearCookies 清楚所有cookiejar上的cookies
+func (ses *Session) ClearCookies() {
+	cjar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+	if err != nil {
+		panic(err)
+	}
+	ses.cookiejar = cjar
+	ses.client.Jar = ses.cookiejar
+}
+
+// Head 请求
+func (ses *Session) Head(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "HEAD"
+	return wf
+}
+
 // Get 请求
 func (ses *Session) Get(url string) *Workflow {
-	wf := NewWorkflow(ses)
+	wf := NewWorkflow(ses, url)
 	wf.Method = "GET"
-	wf.SetURL(url)
 	return wf
 }
 
 // Post 请求
 func (ses *Session) Post(url string) *Workflow {
-	wf := NewWorkflow(ses)
+	wf := NewWorkflow(ses, url)
 	wf.Method = "POST"
-	wf.SetURL(url)
 	return wf
 }
 
 // Put 请求
 func (ses *Session) Put(url string) *Workflow {
-	wf := NewWorkflow(ses)
+	wf := NewWorkflow(ses, url)
 	wf.Method = "PUT"
-	wf.SetURL(url)
 	return wf
 }
 
 // Patch 请求
 func (ses *Session) Patch(url string) *Workflow {
-	wf := NewWorkflow(ses)
+	wf := NewWorkflow(ses, url)
 	wf.Method = "PATCH"
-	wf.SetURL(url)
-	return wf
-}
-
-// Delete 请求
-func (ses *Session) Delete(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "DELETE"
-	wf.SetURL(url)
-	return wf
-}
-
-// Head 请求
-func (ses *Session) Head(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "HEAD"
-	wf.SetURL(url)
 	return wf
 }
 
 // Options 请求
 func (ses *Session) Options(url string) *Workflow {
-	wf := NewWorkflow(ses)
+	wf := NewWorkflow(ses, url)
 	wf.Method = "OPTIONS"
-	wf.SetURL(url)
 	return wf
 }
+
+// Delete 请求
+func (ses *Session) Delete(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "DELETE"
+	return wf
+}
+
+// // CloseIdleConnections  closes the idle connections that a session client may make use of
+// // 从levigross/grequests 借鉴
+// func (ses *Session) CloseIdleConnections() {
+// 	ses.client.Transport.(*http.Transport).CloseIdleConnections()
+// }
+
+// EnsureTransporterFinalized will ensure that when the HTTP client is GCed
+// the runtime will close the idle connections (so that they won't leak)
+// this function was adopted from Hashicorp's go-cleanhttp package
+func EnsureTransporterFinalized(httpTransport *http.Transport) {
+	runtime.SetFinalizer(&httpTransport, func(transportInt **http.Transport) {
+		(*transportInt).CloseIdleConnections()
+	})
+}

session_test.go

@@ -1,15 +1,15 @@
 package requests
 
 import (
-	"log"
 	"net/http"
+	"net/url"
 	"regexp"
+	"strings"
 	"testing"
-)
+	"time"
 
-func init() {
-	log.SetFlags(log.Lshortfile | log.LstdFlags)
-}
+	"github.com/474420502/gjson"
+)
 
 func TestNewSession(t *testing.T) {
 	ses := NewSession()
@@ -30,7 +30,6 @@ func TestSession_Get(t *testing.T) {
 		fields fields
 		args   args
 	}{
-		// TODO: Add test cases.
 		{
 			name:   "Get test",
 			fields: fields{client: &http.Client{}},
@@ -46,7 +45,7 @@ func TestSession_Get(t *testing.T) {
 			if err != nil {
 				t.Error(err)
 			}
-			if len(resp.Content()) <= 200 {
+			if len(resp.Content()) <= 150 {
 				t.Error(resp.Content())
 			}
 		})
@@ -77,14 +76,14 @@ func TestSession_Post(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Post("http://httpbin.org/post").SetBodyParams(tt.args.params...).Execute()
+			got, err := ses.Post("http://httpbin.org/post").SetBodyAuto(tt.args.params...).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -107,7 +106,6 @@ func TestSession_Setparams(t *testing.T) {
 		want    *regexp.Regexp
 		wantErr bool
 	}{
-		// TODO: Add test cases.
 		{
 			name: "test Setparams",
 			args: args{params: []interface{}{map[string]string{"a": "1", "b": "2"}}},
@@ -120,7 +118,7 @@ func TestSession_Setparams(t *testing.T) {
 		},
 		{
 			name:   "test xml",
-			fields: fields{client: &http.Client{}, params: &Body{}},
+			fields: fields{client: &http.Client{}, params: NewBody()},
 			args:   args{params: []interface{}{`<request><parameters><password>test</password></parameters></request>`, TypeXML}},
 			want:   regexp.MustCompile(`"data": "<request><parameters><password>test</password></parameters></request>"`),
 		},
@@ -129,13 +127,13 @@ func TestSession_Setparams(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
 
-			got, err := ses.Post("http://httpbin.org/post").SetBodyParams(tt.args.params...).Execute()
+			got, err := ses.Post("http://httpbin.org/post").SetBodyAuto(tt.args.params...).Execute()
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Metchod error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 		})
@@ -171,14 +169,14 @@ func TestSession_PostUploadFile(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Post("http://httpbin.org/post").SetBodyParams(tt.args.params, TypeFormData).Execute()
+			got, err := ses.Post("http://httpbin.org/post").SetBodyAuto(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -215,14 +213,14 @@ func TestSession_Put(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Put("http://httpbin.org/put").SetBodyParams(tt.args.params, TypeFormData).Execute()
+			got, err := ses.Put("http://httpbin.org/put").SetBodyAuto(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -259,14 +257,14 @@ func TestSession_Patch(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Patch("http://httpbin.org/patch").SetBodyParams(tt.args.params, TypeFormData).Execute()
+			got, err := ses.Patch("http://httpbin.org/patch").SetBodyAuto(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -285,22 +283,21 @@ func TestSession_SetConfig(t *testing.T) {
 		args    args
 		wantErr bool
 	}{
-		// TODO: Add test cases.
 		{
 			name:    "test timeout",
-			args:    args{typeConfig: ConfigRequestTimeout, values: 0.01},
+			args:    args{typeConfig: CRequestTimeout, values: 0.0001},
 			wantErr: true,
 		},
 
 		{
 			name:    "test not timeout",
-			args:    args{typeConfig: ConfigRequestTimeout, values: 5},
+			args:    args{typeConfig: CRequestTimeout, values: 5},
 			wantErr: false,
 		},
 
 		{
 			name:    "test proxy",
-			args:    args{typeConfig: ConfigProxy, values: "http://474420502.top:7070"},
+			args:    args{typeConfig: CProxy, values: "http://" + ProxyAddress},
 			wantErr: false,
 		},
 	}
@@ -308,7 +305,7 @@ func TestSession_SetConfig(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
 			ses.SetConfig(tt.args.typeConfig, tt.args.values)
-			_, err := ses.Get("https://httpbin.org/get").Execute()
+			_, err := ses.Get("http://httpbin.org/get").Execute()
 
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Metchod error = %v", err)
@@ -322,7 +319,7 @@ func TestSession_SetConfig(t *testing.T) {
 func TestSession_SetConfigInsecure(t *testing.T) {
 
 	ses := NewSession()
-	ses.SetConfig(ConfigInsecure, false)
+	ses.SetConfig(CInsecure, true)
 
 	for _, badSSL := range []string{
 		"https://self-signed.badssl.com/",
@@ -333,8 +330,8 @@ func TestSession_SetConfigInsecure(t *testing.T) {
 		if err != nil {
 			t.Error("Unable to make request", err)
 		}
-		if resp.GResponse.StatusCode != 200 {
-			t.Error("Request did not return OK, is ", resp.GResponse.StatusCode)
+		if resp.readResponse.StatusCode != 200 {
+			t.Error("Request did not return OK, is ", resp.readResponse.StatusCode)
 		}
 	}
 
@@ -343,37 +340,206 @@ func TestSession_SetConfigInsecure(t *testing.T) {
 func TestSession_Cookies(t *testing.T) {
 	ses := NewSession()
 
-	resp, err := ses.Get("http://httpbin.org/cookies/set").AddKVCookie("a", "1").Execute()
-	if err != nil {
-		t.Error("cookies set error", err)
-	}
-
-	if !regexp.MustCompile(`"a": "1"`).MatchString(resp.DContent) {
-		t.Error(resp.DContent)
-	}
+	t.Run("set cookie", func(t *testing.T) {
+		resp, err := ses.Get("http://httpbin.org/cookies/set").AddKVCookie("a", "1").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
 
+		if !regexp.MustCompile(`"a": "1"`).MatchString(resp.readContent) {
+			t.Error(resp.readContent)
+		}
+	})
 }
 
 func TestSession_Header(t *testing.T) {
 	chromeua := "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36"
 	ses := NewSession()
-	ses.Header.Add(HeaderKeyUA, chromeua)
-	resp, err := ses.Get("https://www.baidu.com").Execute()
+
+	t.Run("ua header test", func(t *testing.T) {
+
+		ses.Header.Add(HeaderKeyUA, chromeua)
+		resp, err := ses.Get("https://www.baidu.com").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		if len(resp.readContent) <= 5000 {
+			t.Error(resp.readContent, len(resp.readContent))
+		}
+
+		ses = NewSession()
+		resp, err = ses.Get("https://www.baidu.com").AddHeader(HeaderKeyUA, chromeua).Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		if len(resp.readContent) <= 5000 {
+			t.Error(resp.readContent, len(resp.readContent))
+		}
+	})
+}
+
+func TestSession_ConfigEx(t *testing.T) {
+	ses := NewSession()
+	ses.SetConfig(CRequestTimeout, time.Microsecond)
+	resp, err := ses.Get("http://httpbin.org/get").Execute()
+	if err == nil {
+		t.Error(resp)
+	} else {
+		if strings.LastIndex(err.Error(), "Client.Timeout exceeded while awaiting headers") < 0 {
+			t.Error(err)
+		}
+	}
+
+	ses.SetConfig(CRequestTimeout, float32(0.0000001))
+	resp, err = ses.Get("http://httpbin.org/get").Execute()
+	if err == nil {
+		t.Error(resp)
+	} else {
+		if strings.LastIndex(err.Error(), "Client.Timeout exceeded while awaiting headers") < 0 {
+			t.Error(err)
+		}
+	}
+
+	ses.SetConfig(CKeepAlives, true)
+	ses.SetConfig(CRequestTimeout, int64(5))
+	// jar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+	u, err := url.Parse("http://httpbin.org")
 	if err != nil {
-		t.Error("cookies set error", err)
+		t.Error(err)
+	} else {
+		// jar.SetCookies(u, []*http.Cookie{&http.Cookie{Name: "Request", Value: "Cookiejar"}})
+		ses.SetConfig(CIsWithCookiejar, false)
+		ses.SetConfig(CIsWithCookiejar, true)
+		ses.SetCookies(u, []*http.Cookie{&http.Cookie{Name: "Request", Value: "Cookiejar"}, &http.Cookie{Name: "eson", Value: "bad"}})
+		resp, err = ses.Get("http://httpbin.org/get").Execute()
+		if err != nil {
+			t.Error(err)
+		}
+
+		if gjson.Get(resp.Content(), "headers.Cookie").String() != "Request=Cookiejar; eson=bad" {
+			t.Error(resp.Content())
+		}
+
+		if resp.GetSrcResponse().Header["Connection"][0] != "keep-alive" {
+			t.Error("CKeepAlive is error")
+		}
 	}
 
-	if len(resp.DContent) <= 5000 {
-		t.Error(resp.DContent, len(resp.DContent))
+	ses.SetConfig(CProxy, nil)
+	if u, err := url.Parse("http://" + ProxyAddress); err != nil {
+		t.Error(err)
+	} else {
+		ses.SetConfig(CProxy, u)
 	}
 
-	ses = NewSession()
-	resp, err = ses.Get("https://www.baidu.com").AddHeader(HeaderKeyUA, chromeua).Execute()
+	resp, err = ses.Get("http://httpbin.org/get").Execute()
 	if err != nil {
-		t.Error("cookies set error", err)
+		t.Error(err)
 	}
 
-	if len(resp.DContent) <= 5000 {
-		t.Error(resp.DContent, len(resp.DContent))
+	ses.DelCookies(u, "eson")
+	resp, err = ses.Get("http://httpbin.org/cookies").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+	cookies := ses.GetCookies(u)
+	if len(cookies) != 1 && cookies[0].String() != "Request=Cookiejar" {
+		t.Error("cookies del get error please check it")
+	}
+
+	ses.ClearCookies()
+	resp, err = ses.Get("http://httpbin.org/cookies").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+	if gjson.Get(resp.Content(), "cookies").String() != "{}" {
+		t.Error(resp.Content())
+	}
+}
+
+func TestSession_SetQuery(t *testing.T) {
+	ses := NewSession()
+	ses.SetQuery(url.Values{"query": []string{"a", "b"}})
+	resp, err := ses.Get("http://httpbin.org/get").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+	query := gjson.Get(resp.Content(), "args.query").Array()
+	for _, q := range query {
+		if !(q.String() == "a" || q.String() == "b") {
+			t.Error("query error, ", resp.Content())
+		}
+	}
+}
+
+func TestSession_SetHeader(t *testing.T) {
+	ses := NewSession()
+	var header http.Header
+	header = make(http.Header)
+	header["xx-xx"] = []string{"Header"}
+	ses.SetHeader(header)
+
+	resp, err := ses.Get("http://httpbin.org/headers").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+
+	if gjson.Get(resp.Content(), "headers.Xx-Xx").String() != "Header" {
+		t.Error("Xx-Xx is not exists", resp.Content())
+	}
+
+	if ses.GetHeader()["xx-xx"][0] != "Header" {
+		t.Error("header error")
+	}
+}
+
+func TestSession_SetBasicAuth(t *testing.T) {
+	ses := NewSession()
+	ses.SetConfig(CBasicAuth, &BasicAuth{User: "eson", Password: "123456"})
+	resp, err := ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+	if resp.GetSrcResponse().StatusCode != 200 {
+		t.Error("code != 200, code = ", resp.GetStatue())
+	}
+
+	ses.SetConfig(CBasicAuth, BasicAuth{User: "eson", Password: "12345"})
+	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+
+	if resp.GetSrcResponse().StatusCode != 401 {
+		t.Error("code != 401, code = ", resp.GetStatue())
+	}
+
+	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+
+	if resp.GetSrcResponse().StatusCode != 401 {
+		t.Error("code != 401, code = ", resp.GetStatue())
+	}
+
+	ses.SetConfig(CBasicAuth, []string{"son", "123456"})
+	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+	if resp.GetSrcResponse().StatusCode != 401 {
+		t.Error("code != 401, code = ", resp.GetStatue())
+	}
+
+	ses.SetConfig(CBasicAuth, nil)
+	resp, err = ses.Get("http://httpbin.org/basic-auth/eson/123456").Execute()
+	if err != nil {
+		t.Error(err)
+	}
+	if resp.GetSrcResponse().StatusCode != 401 {
+		t.Error("code != 401, code = ", resp.GetStatue())
 	}
 }

upload_file.go

@@ -14,16 +14,59 @@ type UploadFile struct {
 	FileReaderCloser io.ReadCloser
 }
 
+// SetFileName 设置FileName属性
+func (ufile *UploadFile) SetFileName(filename string) {
+	ufile.FileName = filename
+}
+
+// GetFileName 设置FileName属性
+func (ufile *UploadFile) GetFileName() string {
+	return ufile.FileName
+}
+
+// SetFileReaderCloser 设置FileName属性
+func (ufile *UploadFile) SetFileReaderCloser(readerCloser io.ReadCloser) {
+	ufile.FileReaderCloser = readerCloser
+}
+
+// SetFileReaderCloserFromFile 设置FileName属性
+func (ufile *UploadFile) SetFileReaderCloserFromFile(filename string) error {
+	fd, err := os.Open(filename)
+	if err != nil {
+		return err
+	}
+	ufile.SetFileReaderCloser(fd)
+	return nil
+}
+
+// GetFileReaderCloser 设置FileName属性
+func (ufile *UploadFile) GetFileReaderCloser() io.ReadCloser {
+	return ufile.FileReaderCloser
+}
+
+// SetFieldName 设置FileName属性
+func (ufile *UploadFile) SetFieldName(fieldname string) {
+	ufile.FieldName = fieldname
+}
+
+// GetFieldName 设置FileName属性
+func (ufile *UploadFile) GetFieldName() string {
+	return ufile.FieldName
+}
+
+// NewUploadFile 创建一个空的UploadFile, 必须设置 FileName FieldName FileReaderCloser 三个属性
+func NewUploadFile() *UploadFile {
+	return &UploadFile{}
+}
+
 // UploadFileFromPath 从本地文件获取上传文件
 func UploadFileFromPath(fileName string) (*UploadFile, error) {
 	fd, err := os.Open(fileName)
-
 	if err != nil {
 		return nil, err
 	}
 
 	return &UploadFile{FileReaderCloser: fd, FileName: fileName}, nil
-
 }
 
 // UploadFileFromGlob 根据Glob从本地文件获取上传文件

upload_file_test.go

@@ -0,0 +1,107 @@
+package requests
+
+import (
+	"testing"
+
+	"github.com/474420502/gjson"
+)
+
+func TestUploadFile(t *testing.T) {
+
+	for i := 0; i < 1; i++ {
+
+		ses := NewSession()
+		wf := ses.Put("http://httpbin.org/put")
+
+		ufile, err := UploadFileFromPath("tests/json.file")
+		if err != nil {
+			t.Error(err)
+		}
+		wf.SetBodyAuto(ufile, TypeFormData)
+		resp, _ := wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file0"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		ses = NewSession()
+		wf = ses.Patch("http://httpbin.org/patch")
+
+		wf.SetBodyAuto("tests/json.file", TypeFormData)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file0"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		ses = NewSession()
+		wf = ses.Delete("http://httpbin.org/delete")
+		ufile = NewUploadFile()
+		ufile.SetFileName("MyFile")
+		ufile.SetFieldName("MyField")
+		ufile.SetFileReaderCloserFromFile("tests/json.file")
+		wf.SetBodyAuto(ufile)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["MyField"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		// ses = NewSession()
+		// wf = ses.Put("http://httpbin.org/put")
+
+		ufile.SetFileReaderCloserFromFile("tests/json.file")
+		wf.SetBodyAuto(*ufile)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["MyField"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		// ses = NewSession()
+		// wf = ses.Put("http://httpbin.org/put")
+
+		ufile = NewUploadFile()
+		ufile.SetFileName("MyFile")
+		ufile.SetFileReaderCloserFromFile("tests/json.file")
+		wf.SetBodyAuto(ufile)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file0"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		ufile.SetFileReaderCloserFromFile("tests/json.file")
+		wf.SetBodyAuto(*ufile)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file0"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		var ufileList []*UploadFile
+		ufile, err = UploadFileFromPath("tests/json.file")
+		if err != nil {
+			t.Error(err)
+		}
+		ufileList = append(ufileList, ufile)
+		ufile, err = UploadFileFromPath("tests/learn.js")
+		if err != nil {
+			t.Error(err)
+		}
+		ufileList = append(ufileList, ufile)
+		wf.SetBodyAuto(ufileList)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file1"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+
+		if wf.GetBody().ContentType() != "" {
+			t.Error("Body is not Clear")
+		}
+
+		wf.SetBodyAuto([]string{"tests/learn.js", "tests/json.file"}, TypeFormData)
+		resp, _ = wf.Execute()
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file1_0"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+		if _, ok := gjson.Get(resp.Content(), "files").Map()["file0_0"]; !ok {
+			t.Error("file error", resp.Content())
+		}
+	}
+
+}

workflow.go

@@ -4,24 +4,26 @@ import (
 	"net/http"
 	"net/url"
 	"regexp"
+	"strings"
 )
 
-// Workflow 工作流
+// Workflow 工作流 设计点: 这个并不影响Session的属性变化 如 NewWorkflow(ses, url).AddHeader() 对ses没影响
 type Workflow struct {
 	session   *Session
 	ParsedURL *url.URL
 	Method    string
-	Body      *Body
+	Body      IBody
 	Header    http.Header
 	Cookies   map[string]*http.Cookie
 }
 
 // NewWorkflow new and init workflow
-func NewWorkflow(ses *Session) *Workflow {
+func NewWorkflow(ses *Session, urlstr string) *Workflow {
 	wf := &Workflow{}
 	wf.SwitchSession(ses)
+	wf.SetRawURL(urlstr)
 
-	wf.Body = &Body{}
+	wf.Body = NewBody()
 	wf.Header = make(http.Header)
 	wf.Cookies = make(map[string]*http.Cookie)
 	return wf
@@ -32,18 +34,35 @@ func (wf *Workflow) SwitchSession(ses *Session) {
 	wf.session = ses
 }
 
-// AddHeader 添加头信息  Get方法从Header参数上获取
+// AddHeader 添加头信息  Get方法从Header参数上获取 必须符合规范 HaHa -> Haha 如果真要HaHa,只能这样 Ha-Ha
 func (wf *Workflow) AddHeader(key, value string) *Workflow {
-	wf.Header.Add(key, value)
+	wf.Header[key] = append(wf.Header[key], value)
 	return wf
 }
 
-// SetHeader 设置头信息 这样构造 []string{value} Get方法从Header参数上获取
-func (wf *Workflow) SetHeader(key, value string) *Workflow {
-	wf.Header.Set(key, value)
+// SetHeader 设置完全替换原有Header 必须符合规范 HaHa -> Haha 如果真要HaHa,只能这样 Ha-Ha
+func (wf *Workflow) SetHeader(header http.Header) *Workflow {
+	wf.Header = make(http.Header)
+	for k, HValues := range header {
+		var newHValues []string
+		for _, value := range HValues {
+			newHValues = append(newHValues, value)
+		}
+		wf.Header[k] = newHValues
+	}
 	return wf
 }
 
+// GetHeader 获取Workflow Header
+func (wf *Workflow) GetHeader() http.Header {
+	return wf.Header
+}
+
+// GetCombineHeader 获取后的Header信息
+func (wf *Workflow) GetCombineHeader() http.Header {
+	return mergeMapList(wf.session.Header, wf.Header)
+}
+
 // DelHeader 添加头信息 Get方法从Header参数上获取
 func (wf *Workflow) DelHeader(key string) *Workflow {
 	wf.Header.Del(key)
@@ -56,6 +75,14 @@ func (wf *Workflow) AddCookie(c *http.Cookie) *Workflow {
 	return wf
 }
 
+// AddCookies 添加[]*http.Cookie
+func (wf *Workflow) AddCookies(cookies []*http.Cookie) *Workflow {
+	for _, c := range cookies {
+		wf.AddCookie(c)
+	}
+	return wf
+}
+
 // AddKVCookie 添加 以 key value 的 Cookie
 func (wf *Workflow) AddKVCookie(name, value string) *Workflow {
 	wf.Cookies[name] = &http.Cookie{Name: name, Value: value}
@@ -81,13 +108,25 @@ func (wf *Workflow) DelCookie(name interface{}) *Workflow {
 	return nil
 }
 
-// GetStringURL 获取url的string形式
-func (wf *Workflow) GetStringURL() string {
-	return wf.ParsedURL.String()
+// GetParsedURL 获取url的string形式
+func (wf *Workflow) GetParsedURL() *url.URL {
+	return wf.ParsedURL
 }
 
-// SetURL 设置 url
-func (wf *Workflow) SetURL(srcURL string) *Workflow {
+// SetParsedURL 获取url的string形式
+func (wf *Workflow) SetParsedURL(u *url.URL) *Workflow {
+	wf.ParsedURL = u
+	return wf
+}
+
+// GetRawURL 获取url的string形式
+func (wf *Workflow) GetRawURL() string {
+	u := strings.Split(wf.ParsedURL.String(), "?")[0] + "?" + wf.GetCombineQuery().Encode()
+	return u
+}
+
+// SetRawURL 设置 url
+func (wf *Workflow) SetRawURL(srcURL string) *Workflow {
 	purl, err := url.ParseRequestURI(srcURL)
 	if err != nil {
 		panic(err)
@@ -96,27 +135,33 @@ func (wf *Workflow) SetURL(srcURL string) *Workflow {
 	return wf
 }
 
-// GetURLQuery 获取Query参数
-func (wf *Workflow) GetURLQuery() url.Values {
-	if wf.ParsedURL != nil {
-		return wf.ParsedURL.Query()
-	}
+// GetQuery 获取Query参数
+func (wf *Workflow) GetQuery() url.Values {
+	return wf.ParsedURL.Query()
+}
 
+// GetCombineQuery 获取Query参数
+func (wf *Workflow) GetCombineQuery() url.Values {
+	if wf.ParsedURL != nil {
+		vs := wf.ParsedURL.Query()
+		return mergeMapList(wf.session.GetQuery(), vs)
+	}
 	return nil
 }
 
-// SetURLQuery 设置Query参数
-func (wf *Workflow) SetURLQuery(query url.Values) *Workflow {
+// SetQuery 设置Query参数
+func (wf *Workflow) SetQuery(query url.Values) *Workflow {
 	if query == nil {
 		return wf
 	}
+	query = (url.Values)(mergeMapList(wf.session.Query, query))
 	wf.ParsedURL.RawQuery = query.Encode()
 	return wf
 }
 
 var regexGetPath = regexp.MustCompile("/[^/]*")
 
-// GetURLPath 获取Path参数
+// GetURLPath 获取Path参数 http://localhost/anything/user/pwd return [/anything /user /pwd]
 func (wf *Workflow) GetURLPath() []string {
 	return regexGetPath.FindAllString(wf.ParsedURL.Path, -1)
 }
@@ -138,7 +183,7 @@ func encodePath(path []string) string {
 	return rawpath
 }
 
-// SetURLPath 设置Path参数
+// SetURLPath 设置Path参数 对应 GetURLPath
 func (wf *Workflow) SetURLPath(path []string) *Workflow {
 	if path == nil {
 		return wf
@@ -147,83 +192,119 @@ func (wf *Workflow) SetURLPath(path []string) *Workflow {
 	return wf
 }
 
-// SetURLRawPath 设置Path参数
+// SetURLRawPath 设置 参数 eg. /get = http:// hostname + /get
 func (wf *Workflow) SetURLRawPath(path string) *Workflow {
-	wf.ParsedURL.Path = path
+	if path[0] != '/' {
+		wf.ParsedURL.Path = "/" + path
+	} else {
+		wf.ParsedURL.Path = path
+	}
 	return wf
 }
 
-// SetBodyParams 参数设置
-func (wf *Workflow) SetBodyParams(params ...interface{}) *Workflow {
-	if params == nil {
-		return wf
-	}
+// SetBody 参数设置
+func (wf *Workflow) SetBody(body IBody) *Workflow {
+	wf.Body = body
+	return wf
+}
 
-	plen := len(params)
-	defaultContentType := TypeURLENCODED
+// GetBody 参数设置
+func (wf *Workflow) GetBody() IBody {
+	return wf.Body
+}
 
-	if plen >= 2 {
-		t := params[plen-1]
-		defaultContentType = t.(string)
-		wf.Body.ContentType = defaultContentType
-	} else {
-		wf.Body.ContentType = defaultContentType
-	}
+// SetBodyAuto 参数设置
+func (wf *Workflow) SetBodyAuto(params ...interface{}) *Workflow {
 
-	if defaultContentType == TypeFormData {
-		// TODO: form-data
-		createMultipart(wf.Body, params)
-	} else {
-		var values url.Values
-		switch param := params[0].(type) {
-		case map[string]string:
-			values := make(url.Values)
-			for k, v := range param {
-				values.Set(k, v)
-			}
-			wf.Body.IOBody = []byte(values.Encode())
-		case map[string][]string:
-			values = param
-			wf.Body.IOBody = []byte(values.Encode())
-		case string:
-			wf.Body.IOBody = []byte(param)
-		case []byte:
-			wf.Body.IOBody = param
+	if params != nil {
+		plen := len(params)
+		defaultContentType := TypeURLENCODED
+
+		if plen >= 2 {
+			t := params[plen-1]
+			defaultContentType = t.(string)
 		}
+
+		wf.Body.SetPrefix(defaultContentType)
+
+		switch defaultContentType {
+		case TypeFormData:
+			createMultipart(wf.Body, params) // 还存在 Mixed的可能
+		default:
+			var values url.Values
+			switch param := params[0].(type) {
+			case map[string]string:
+				values := make(url.Values)
+				for k, v := range param {
+					values.Set(k, v)
+				}
+				wf.Body.SetIOBody([]byte(values.Encode()))
+			case map[string][]string:
+				values = param
+				wf.Body.SetIOBody([]byte(values.Encode()))
+			case string:
+				wf.Body.SetIOBody([]byte(param))
+			case []byte:
+				wf.Body.SetIOBody(param)
+
+			case *UploadFile:
+				params = append(params, TypeFormData)
+				wf.Body.SetPrefix(TypeFormData)
+				createMultipart(wf.Body, params)
+			case UploadFile:
+				params = append(params, TypeFormData)
+				wf.Body.SetPrefix(TypeFormData)
+				createMultipart(wf.Body, params)
+			case []*UploadFile:
+				params = append(params, TypeFormData)
+				wf.Body.SetPrefix(TypeFormData)
+				createMultipart(wf.Body, params)
+			case []UploadFile:
+				params = append(params, TypeFormData)
+				wf.Body.SetPrefix(TypeFormData)
+				createMultipart(wf.Body, params)
+			}
+		}
+
 	}
 	return wf
 }
 
-// setHeaderRequest 设置request的头
-func setHeaderRequest(req *http.Request, wf *Workflow) {
+func mergeMapList(headers ...map[string][]string) map[string][]string {
+
 	set := make(map[string]map[string]int)
-	for key, values := range wf.session.Header {
-		for _, v := range values {
-			if vs, ok := set[key]; ok {
-				vs[v] = 1
-			} else {
-				set[key] = make(map[string]int)
-				set[key][v] = 1
-			}
-		}
-	}
-	for key, values := range wf.Header {
-		for _, v := range values {
-			if vs, ok := set[key]; ok {
-				vs[v] = 1
-			} else {
-				set[key] = make(map[string]int)
-				set[key][v] = 1
+	merged := make(map[string][]string)
+
+	for _, header := range headers {
+		for key, values := range header {
+			for _, v := range values {
+				if vs, ok := set[key]; ok {
+					vs[v] = 1
+				} else {
+					set[key] = make(map[string]int)
+					set[key][v] = 1
+				}
 			}
 		}
 	}
 
 	for key, mvalue := range set {
 		for v := range mvalue {
-			req.Header.Add(key, v)
+			// merged.Add(key, v)
+			if mergeValue, ok := merged[key]; ok {
+				merged[key] = append(mergeValue, v)
+			} else {
+				merged[key] = []string{v}
+			}
 		}
 	}
 
+	return merged
+}
+
+// setHeaderRequest 设置request的头
+func setHeaderRequest(req *http.Request, wf *Workflow) {
+	req.Header = mergeMapList(req.Header, wf.session.Header, wf.Header)
 }
 
 // setHeaderRequest 设置request的临时Cookie, 永久需要在session上设置cookie
@@ -238,14 +319,20 @@ func setTempCookieRequest(req *http.Request, wf *Workflow) {
 // Execute 执行
 func (wf *Workflow) Execute() (*Response, error) {
 
-	req := buildBodyRequest(wf.Method, wf.GetStringURL(), wf.Body)
+	req := buildBodyRequest(wf)
 
 	setHeaderRequest(req, wf)
 	setTempCookieRequest(req, wf)
 
+	if wf.session.auth != nil {
+		req.SetBasicAuth(wf.session.auth.User, wf.session.auth.Password)
+	}
+
 	resp, err := wf.session.client.Do(req)
 	if err != nil {
 		return nil, err
 	}
-	return FromHTTPResponse(resp)
+
+	wf.Body = NewBody()
+	return FromHTTPResponse(resp, wf.session.Is.isDecompressNoAccept)
 }

workflow_test.go

@@ -0,0 +1,306 @@
+package requests
+
+import (
+	"net/http"
+	"net/url"
+	"regexp"
+	"sort"
+	"testing"
+
+	"github.com/474420502/gjson"
+)
+
+func TestWorkflow(t *testing.T) {
+	ses := NewSession()
+
+	t.Run("set cookie", func(t *testing.T) {
+		resp, err := ses.Get("http://httpbin.org/cookies/set").AddKVCookie("a", "1").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		if !regexp.MustCompile(`"a": "1"`).MatchString(resp.readContent) {
+			t.Error(resp.readContent)
+		}
+
+		wf := ses.Get("http://httpbin.org/cookies/set")
+		resp, err = wf.AddKVCookie("b", "2").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		result := gjson.Get(resp.readContent, "cookies.a")
+		if result.Exists() {
+			t.Error(resp.readContent)
+		}
+
+		result = gjson.Get(resp.readContent, "cookies.b")
+		if result.Int() != 2 {
+			t.Error(resp.readContent)
+		}
+
+		resp, err = wf.AddKVCookie("a", "3").Execute()
+		results := gjson.GetMany(resp.readContent, "cookies.a", "cookies.b")
+		if results[0].Int() != 3 {
+			t.Error(resp.readContent)
+		}
+
+		if results[1].Int() != 2 {
+			t.Error(resp.readContent)
+		}
+
+		resp, err = wf.AddHeader("XX", "123").SetRawURL("http://httpbin.org/headers").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		// headers 只能是String 表示
+		result = gjson.Get(resp.readContent, "headers.Xx")
+		if result.String() != "123" {
+			t.Error(resp.readContent)
+		}
+	})
+
+}
+
+func TestWorkflow_SetHeader(t *testing.T) {
+	ses := NewSession()
+	wf := ses.Get("http://httpbin.org/headers")
+	var header http.Header
+	header = make(http.Header)
+	header["Eson"] = []string{"Bad"}
+	header["HaHa"] = []string{"xixi"}
+	wf.SetHeader(header)
+
+	resp, err := wf.Execute()
+	if err == nil && gjson.Get(resp.Content(), "headers.Eson").String() != "Bad" {
+		t.Error("wf header error", resp.Content())
+	}
+
+	if err == nil && gjson.Get(resp.Content(), "headers.Haha").String() != "xixi" {
+		t.Error("wf header error", resp.Content())
+	}
+
+	// 输入不符合规范不 会自动转换
+	if wf.GetHeader()["HaHa"][0] != "xixi" {
+		t.Error("Header 错误")
+	}
+
+	if len(ses.GetHeader()) != 0 {
+		t.Error("session header should be zero")
+	}
+
+	delete(header, "HaHa")
+	ses.SetHeader(header)
+	wf = ses.Get("http://httpbin.org/headers")
+	wf.AddHeader("Hello", "Hehe")
+
+	resp, err = wf.Execute()
+	if err != nil || gjson.Get(resp.Content(), "headers.Eson").String() != "Bad" {
+		t.Error("wf header error", resp.Content())
+	}
+
+	if err != nil || gjson.Get(resp.Content(), "headers.Hello").String() != "Hehe" {
+		t.Error("wf header error", resp.Content())
+	}
+
+	if len(wf.GetHeader()) != 1 || wf.GetHeader()["Hello"][0] != "Hehe" {
+		t.Error("session header should be 1")
+	}
+
+	cheader := wf.GetCombineHeader()
+	if len(cheader) != 2 || cheader["Eson"][0] != "Bad" {
+		t.Error("GetCombineHeader error")
+	}
+
+	resp, err = wf.DelHeader("Hello").Execute()
+	if err != nil {
+		t.Error(err, resp.Content())
+	}
+
+	if gjson.Get(resp.Content(), "headers.Hello").Exists() {
+		t.Error(" wf.DelHeader error")
+	}
+}
+
+func TestWorkflow_Cookies(t *testing.T) {
+	ses := NewSession()
+	u, err := url.Parse("http://httpbin.org")
+	if err != nil {
+		t.Error(err)
+	}
+	ses.SetCookies(u, []*http.Cookie{&http.Cookie{Name: "Request", Value: "Cookiejar"}})
+	wf := ses.Get("http://httpbin.org/cookies")
+	wf.AddCookie(&http.Cookie{Name: "eson", Value: "Bad"})
+
+	resp, _ := wf.Execute()
+	if gjson.Get(resp.Content(), "cookies.Request").String() != "Cookiejar" {
+		t.Error(" wf.AddCookie error")
+	}
+
+	if gjson.Get(resp.Content(), "cookies.eson").String() != "Bad" {
+		t.Error(" wf.AddCookie error")
+	}
+
+	wf.DelCookie("eson")
+	resp, _ = wf.Execute()
+	if gjson.Get(resp.Content(), "cookies.Request").String() != "Cookiejar" {
+		t.Error(" wf.AddCookie error")
+	}
+	if gjson.Get(resp.Content(), "cookies.eson").Exists() {
+		t.Error(" wf.DelCookie error")
+	}
+
+	wf.AddCookies([]*http.Cookie{&http.Cookie{Name: "A", Value: "AA"}, &http.Cookie{Name: "B", Value: "BB"}})
+
+	resp, _ = wf.Execute()
+	if gjson.Get(resp.Content(), "cookies.Request").String() != "Cookiejar" {
+		t.Error(" wf.AddCookie error")
+	}
+	if gjson.Get(resp.Content(), "cookies.A").String() != "AA" {
+		t.Error(" wf.AddCookies error")
+	}
+
+	if gjson.Get(resp.Content(), "cookies.B").String() != "BB" {
+		t.Error(" wf.AddCookies error")
+	}
+
+	wf.DelCookie(&http.Cookie{Name: "A", Value: "AA"})
+	resp, _ = wf.Execute()
+	if gjson.Get(resp.Content(), "cookies.A").Exists() {
+		t.Error(" wf.AddCookies error")
+	}
+
+	if gjson.Get(resp.Content(), "cookies.B").String() != "BB" {
+		t.Error(" wf.AddCookies error")
+	}
+}
+
+func TestWorkflow_URL(t *testing.T) {
+	ses := NewSession()
+	wf := ses.Get("http://httpbin.org/")
+	u, err := url.Parse("http://httpbin.org/get")
+	if err != nil {
+		t.Error(err)
+	}
+	wf.SetParsedURL(u)
+	resp, _ := wf.Execute()
+	if gjson.Get(resp.Content(), "url").String() != "http://httpbin.org/get" {
+		t.Error("SetParsedURL ", resp.Content())
+	}
+
+	if wf.GetParsedURL().String() != "http://httpbin.org/get" {
+		t.Error("SetParsedURL ", resp.Content())
+	}
+
+	wf = ses.Get("http://httpbin.org/")
+
+	resp, _ = wf.SetURLRawPath("/get").Execute()
+	if gjson.Get(resp.Content(), "url").String() != "http://httpbin.org/get" {
+		t.Error("SetParsedURL ", resp.Content())
+	}
+
+	if wf.GetURLRawPath() != "/get" {
+		t.Error("SetParsedURL ", resp.Content())
+	}
+
+	resp, _ = wf.SetURLRawPath("anything/user/password").Execute()
+	if gjson.Get(resp.Content(), "url").String() != "http://httpbin.org/anything/user/password" {
+		t.Error("SetParsedURL ", resp.Content())
+	}
+	paths := wf.GetURLPath()
+	if paths[0] != "/anything" || paths[1] != "/user" || paths[2] != "/password" {
+		t.Error("wf.GetURLPath()", paths)
+	}
+
+	wf = ses.Get("http://httpbin.org/")
+	wf.SetURLPath(paths)
+	if gjson.Get(resp.Content(), "url").String() != "http://httpbin.org/anything/user/password" {
+		t.Error("SetParsedURL ", resp.Content())
+	}
+}
+
+func TestWorkflow_Query(t *testing.T) {
+	ses := NewSession()
+	query := make(url.Values)
+	query["session"] = []string{"true"}
+	ses.SetQuery(query)
+	wf := ses.Get("http://httpbin.org/get")
+	wfquery := make(url.Values)
+	wfquery["workflow"] = []string{"do", "to"}
+	wf.SetQuery(wfquery)
+
+	resp, _ := wf.Execute()
+	result := gjson.Get(resp.Content(), "args.workflow")
+
+	for _, r := range result.Array() {
+		if !(r.String() == "to" || r.String() == "do") {
+			t.Error("workflow SetQuery error")
+		}
+	}
+
+	if gjson.Get(resp.Content(), "args.session").String() != "true" {
+		t.Error("session SetQuery error")
+	}
+
+	if v, ok := wf.GetQuery()["workflow"]; ok {
+		sort.Slice(v, func(i, j int) bool {
+			if v[i] > v[j] {
+				return true
+			}
+			return false
+		})
+		if !(v[0] == "to" && v[1] == "do") && len(v) != 2 {
+			t.Error("workflow GetQuery", v)
+		}
+	}
+
+	if v, ok := wf.GetQuery()["session"]; ok {
+		if v[0] != "true" && len(v) != 1 {
+			t.Error("workflow error")
+		}
+	}
+}
+
+func TestWorkflow_Body(t *testing.T) {
+	ses := NewSession()
+	wf := ses.Post("http://httpbin.org/post")
+	body := NewBody()
+	body.SetIOBody("a=1&b=2")
+	wf.SetBody(body)
+	resp, _ := wf.Execute()
+	form := gjson.Get(resp.Content(), "form").Map()
+	if v, ok := form["a"]; ok {
+		if v.String() != "1" {
+			t.Error(v)
+		}
+	}
+
+	if v, ok := form["b"]; ok {
+		if v.String() != "2" {
+			t.Error(v)
+		}
+	}
+
+	body.SetPrefix(TypeJSON)
+	body.SetIOBody(`{"a": "1",   "b":  "2"}`)
+	wf.SetBody(body)
+	resp, _ = wf.Execute()
+	json := gjson.Get(resp.Content(), "json").Map()
+	if v, ok := json["a"]; ok {
+		if v.String() != "1" {
+			t.Error(v)
+		}
+	}
+
+	if v, ok := json["b"]; ok {
+		if v.String() != "2" {
+			t.Error(v)
+		}
+	}
+
+	// body.SetPrefix(TypeXML)
+	// body.SetIOBody(`<root><a>1</a><b>2</b></root>`)
+	// wf.SetBody(body)
+	// resp, _ = wf.Execute()
+}