This repository has been archived by the owner on Mar 28, 2022. It is now read-only.
/
response.go
130 lines (111 loc) · 3.23 KB
/
response.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package httpboomer
import (
"encoding/json"
"log"
"strings"
"testing"
"github.com/imroc/req"
"github.com/jmespath/go-jmespath"
"github.com/httprunner/httpboomer/builtin"
)
func NewResponseObject(t *testing.T, resp *req.Resp) (*ResponseObject, error) {
// prepare response headers
headers := make(map[string]string)
for k, v := range resp.Response().Header {
if len(v) > 0 {
headers[k] = v[0]
}
}
// prepare response cookies
cookies := make(map[string]string)
for _, cookie := range resp.Response().Cookies() {
cookies[cookie.Name] = cookie.Value
}
// parse response body
var body interface{}
if err := json.Unmarshal(resp.Bytes(), &body); err != nil {
// response body is not json, use raw body
body = string(resp.Bytes())
}
respObjMeta := respObjMeta{
StatusCode: resp.Response().StatusCode,
Headers: headers,
Cookies: cookies,
Body: body,
}
// convert respObjMeta to interface{}
respObjMetaBytes, _ := json.Marshal(respObjMeta)
var data interface{}
if err := json.Unmarshal(respObjMetaBytes, &data); err != nil {
log.Printf("[NewResponseObject] convert respObjMeta to interface{} error: %v, respObjMeta: %v",
err, string(respObjMetaBytes))
return nil, err
}
return &ResponseObject{
t: t,
respObjMeta: data,
}, nil
}
type respObjMeta struct {
StatusCode int `json:"status_code"`
Headers map[string]string `json:"headers"`
Cookies map[string]string `json:"cookies"`
Body interface{} `json:"body"`
}
type ResponseObject struct {
t *testing.T
respObjMeta interface{}
validationResults map[string]interface{}
}
func (v *ResponseObject) Extract(extractors map[string]string) map[string]interface{} {
if extractors == nil {
return nil
}
extractMapping := make(map[string]interface{})
for key, value := range extractors {
extractedValue := v.searchJmespath(value)
log.Printf("[extract] %s => %v", value, extractedValue)
log.Printf("[setVariable] %s = %v", key, extractedValue)
extractMapping[key] = extractedValue
}
return extractMapping
}
func (v *ResponseObject) Validate(validators []TValidator, variablesMapping map[string]interface{}) (err error) {
for _, validator := range validators {
// parse check value
checkItem := validator.Check
var checkValue interface{}
if strings.Contains(checkItem, "$") {
// reference variable
checkValue, err = parseData(checkItem, variablesMapping)
if err != nil {
return err
}
} else {
checkValue = v.searchJmespath(checkItem)
}
// get assert method
assertMethod := validator.Assert
assertFunc := builtin.Assertions[assertMethod]
// parse expected value
expectValue, err := parseData(validator.Expect, variablesMapping)
if err != nil {
return err
}
// do assertion
result := assertFunc(v.t, expectValue, checkValue)
log.Printf("[assert] %s <%s> %v => %v", checkItem, assertMethod, expectValue, result)
if !result {
v.t.Fail()
}
}
return nil
}
func (v *ResponseObject) searchJmespath(expr string) interface{} {
checkValue, err := jmespath.Search(expr, v.respObjMeta)
if err != nil {
log.Printf("[searchJmespath] jmespath.Search error: %v", err)
return expr // jmespath not found, return the expression
}
return checkValue
}