GithubBackup/httprunner
1
0
Fork 0
mirror of https://github.com/httprunner/httprunner.git synced 2026-05-06 20:32:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: unittests

Browse Source
This commit is contained in:
lilong.129
2025-03-05 22:08:03 +08:00
parent 1e1f8d215d
commit f5dff25d26
6 changed files with 125 additions and 328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
cmd/doc_test.go
View File

@@ -4,12 +4,11 @@ import (
"testing"
"github.com/spf13/cobra/doc"
"github.com/stretchr/testify/assert"
)
// run this test to generate markdown docs for hrp command
func TestGenMarkdownTree(t *testing.T) {
err := doc.GenMarkdownTree(rootCmd, "../../docs/cmd")
if err != nil {
t.Fatal(err)
}
assert.Nil(t, err)
}

11
cmd/ios/ios_test.go
View File

@@ -2,13 +2,14 @@
package ios
import "testing"
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestGetDevice(t *testing.T) {
device, err := getDevice(udid)
if err != nil {
t.Fatal(err)
}
require.Nil(t, err)
t.Logf("device: %v", device)
}

2
convert/from_curl_test.go
View File

@@ -6,7 +6,7 @@ import (
"github.com/stretchr/testify/assert"
)
var curlPath = "../../../examples/data/curl/curl_examples.txt"
var curlPath = "../examples/data/curl/curl_examples.txt"
func TestLoadCurlCase(t *testing.T) {
tCase, err := LoadCurlCase(curlPath)

2
internal/version/VERSION
View File

@@ -1 +1 @@
v5.0.0-beta-2503052140
v5.0.0-beta-2503052208

281
parser_test.go
View File

@@ -10,77 +10,52 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestBuildURL(t *testing.T) {
var preparedURL *url.URL
preparedURL = buildURL("https://postman-echo.com", "/get", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
preparedURL = buildURL("https://postman-echo.com", "get", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
preparedURL = buildURL("https://postman-echo.com/", "/get", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
preparedURL = buildURL("https://postman-echo.com/abc/", "/get?a=1&b=2", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2")
preparedURL = buildURL("https://postman-echo.com/abc", "get?a=1&b=2", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2")
// omit query string in base url
preparedURL = buildURL("https://postman-echo.com/abc?x=6&y=9", "/get?a=1&b=2", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2")
preparedURL = buildURL("", "https://postman-echo.com/get", nil)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get/")
// notice: step request url > config base url
preparedURL = buildURL("https://postman-echo.com", "https://httpbin.org/get", nil)
if !assert.Equal(t, preparedURL.String(), "https://httpbin.org/get/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://httpbin.org/get/")
// websocket url
preparedURL = buildURL("wss://ws.postman-echo.com/raw", "", nil)
if !assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/")
preparedURL = buildURL("wss://ws.postman-echo.com", "/raw", nil)
if !assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "wss://ws.postman-echo.com/raw/")
preparedURL = buildURL("wss://ws.postman-echo.com/raw", "ws://echo.websocket.events", nil)
if !assert.Equal(t, preparedURL.String(), "ws://echo.websocket.events/") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "ws://echo.websocket.events/")
queryParams := url.Values{}
queryParams.Add("c", "3")
queryParams.Add("d", "4")
preparedURL = buildURL("https://postman-echo.com/", "/get/", queryParams)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get?c=3&d=4") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/get?c=3&d=4")
preparedURL = buildURL("https://postman-echo.com/abc", "get?a=1&b=2", queryParams)
if !assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2&c=3&d=4") {
t.Fatal()
}
assert.Equal(t, preparedURL.String(), "https://postman-echo.com/abc/get?a=1&b=2&c=3&d=4")
}
func TestRegexCompileVariable(t *testing.T) {
@@ -95,9 +70,7 @@ func TestRegexCompileVariable(t *testing.T) {
for _, expr := range testData {
varMatched := regexCompileVariable.FindStringSubmatch(expr)
if !assert.Len(t, varMatched, 3) {
t.Fatal()
}
assert.Len(t, varMatched, 3)
}
}
@@ -112,9 +85,7 @@ func TestRegexCompileAbnormalVariable(t *testing.T) {
for _, expr := range testData {
varMatched := regexCompileVariable.FindStringSubmatch(expr)
if !assert.Len(t, varMatched, 0) {
t.Fatal()
}
assert.Len(t, varMatched, 0)
}
}
@@ -130,9 +101,7 @@ func TestRegexCompileFunction(t *testing.T) {
for _, expr := range testData {
varMatched := regexCompileFunction.FindStringSubmatch(expr)
if !assert.Len(t, varMatched, 3) {
t.Fatal()
}
assert.Len(t, varMatched, 3)
}
}
@@ -152,9 +121,7 @@ func TestRegexCompileAbnormalFunction(t *testing.T) {
for _, expr := range testData {
varMatched := regexCompileFunction.FindStringSubmatch(expr)
if !assert.Len(t, varMatched, 0) {
t.Fatal()
}
assert.Len(t, varMatched, 0)
}
}
@@ -214,12 +181,8 @@ func TestParseDataStringWithVariables(t *testing.T) {
parser := NewParser()
for _, data := range testData {
parsedData, err := parser.Parse(data.expr, variablesMapping)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, parsedData) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, parsedData)
}
}
@@ -239,12 +202,8 @@ func TestParseDataStringWithUndefinedVariables(t *testing.T) {
parser := NewParser()
for _, data := range testData {
parsedData, err := parser.Parse(data.expr, variablesMapping)
if !assert.Error(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, parsedData) {
t.Fatal()
}
assert.Error(t, err)
assert.Equal(t, data.expect, parsedData)
}
}
@@ -284,12 +243,8 @@ func TestParseDataStringWithVariablesAbnormal(t *testing.T) {
parser := NewParser()
for _, data := range testData {
parsedData, err := parser.Parse(data.expr, variablesMapping)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, parsedData) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, parsedData)
}
}
@@ -315,12 +270,8 @@ func TestParseDataMapWithVariables(t *testing.T) {
parser := NewParser()
for _, data := range testData {
parsedData, err := parser.Parse(data.expr, variablesMapping)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, parsedData) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, parsedData)
}
}
@@ -349,12 +300,8 @@ func TestParseHeaders(t *testing.T) {
parser := NewParser()
for _, data := range testData {
parsedHeaders, err := parser.ParseHeaders(data.rawHeaders, variablesMapping)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expectHeaders, parsedHeaders) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expectHeaders, parsedHeaders)
}
}
@@ -378,9 +325,7 @@ func TestMergeVariables(t *testing.T) {
for _, data := range testData {
mergedVariables := mergeVariables(data.stepVariables, data.configVariables)
if !assert.Equal(t, data.expectVariables, mergedVariables) {
t.Fatal()
}
assert.Equal(t, data.expectVariables, mergedVariables)
}
}
@@ -414,9 +359,7 @@ func TestMergeMap(t *testing.T) {
for _, data := range testData {
mergedMap := mergeMap(data.m, data.overriddenMap)
if !assert.Equal(t, data.expectMap, mergedMap) {
t.Fatal()
}
assert.Equal(t, data.expectMap, mergedMap)
}
}
@@ -445,9 +388,7 @@ func TestMergeSlices(t *testing.T) {
for _, data := range testData {
mergedSlice := mergeSlices(data.slice, data.overriddenSlice)
if !assert.Equal(t, data.expectSlice, mergedSlice) {
t.Fatal()
}
assert.Equal(t, data.expectSlice, mergedSlice)
}
}
@@ -484,9 +425,7 @@ func TestMergeValidators(t *testing.T) {
for _, data := range testData {
mergedValidators := mergeValidators(data.validators, data.overriddenValidators)
if !assert.Equal(t, data.expectValidators, mergedValidators) {
t.Fatal()
}
assert.Equal(t, data.expectValidators, mergedValidators)
}
}
@@ -495,37 +434,23 @@ func TestCallBuiltinFunction(t *testing.T) {
// call function without arguments
_, err := parser.callFunc("get_timestamp")
if !assert.NoError(t, err) {
t.Fatal()
}
assert.Nil(t, err)
// call function with one argument
timeStart := time.Now()
_, err = parser.callFunc("sleep", 1)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Greater(t, time.Since(timeStart), time.Duration(1)*time.Second) {
t.Fatal()
}
assert.Nil(t, err)
assert.Greater(t, time.Since(timeStart), time.Duration(1)*time.Second)
// call function with one argument
result, err := parser.callFunc("gen_random_string", 10)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, 10, len(result.(string))) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, 10, len(result.(string)))
// call function with two argument
result, err = parser.callFunc("max", float64(10), 9.99)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, float64(10), result.(float64)) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, float64(10), result.(float64))
}
func TestLiteralEval(t *testing.T) {
@@ -548,12 +473,8 @@ func TestLiteralEval(t *testing.T) {
for _, data := range testData {
value, err := literalEval(data.expr)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, value) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, value)
}
}
@@ -578,12 +499,8 @@ func TestParseFunctionArguments(t *testing.T) {
for _, data := range testData {
value, err := parseFunctionArguments(data.expr)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, value) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, value)
}
}
@@ -607,12 +524,8 @@ func TestParseDataStringWithFunctions(t *testing.T) {
parser := NewParser()
for _, data := range testData1 {
value, err := parser.Parse(data.expr, variablesMapping)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, len(value.(string))) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, len(value.(string)))
}
testData2 := []struct {
@@ -626,12 +539,8 @@ func TestParseDataStringWithFunctions(t *testing.T) {
for _, data := range testData2 {
value, err := parser.Parse(data.expr, variablesMapping)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expect, value) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expect, value)
}
}
@@ -652,9 +561,7 @@ func TestConvertString(t *testing.T) {
for _, data := range testData {
value := convertString(data.raw)
if !assert.Equal(t, data.expect, value) {
t.Fatal()
}
assert.Equal(t, data.expect, value)
}
}
@@ -676,12 +583,8 @@ func TestParseVariables(t *testing.T) {
parser := NewParser()
for _, data := range testData {
value, err := parser.ParseVariables(data.rawVars)
if !assert.NoError(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expectVars, value) {
t.Fatal()
}
assert.Nil(t, err)
assert.Equal(t, data.expectVars, value)
}
}
@@ -707,12 +610,8 @@ func TestParseVariablesAbnormal(t *testing.T) {
parser := NewParser()
for _, data := range testData {
value, err := parser.ParseVariables(data.rawVars)
if !assert.Error(t, err) {
t.Fatal()
}
if !assert.Equal(t, data.expectVars, value) {
t.Fatal()
}
assert.Error(t, err)
assert.Equal(t, data.expectVars, value)
}
}
@@ -743,9 +642,7 @@ func TestExtractVariables(t *testing.T) {
varList = append(varList, varName)
}
sort.Strings(varList)
if !assert.Equal(t, data.expectVars, varList) {
t.Fatal()
}
assert.Equal(t, data.expectVars, varList)
}
}
@@ -782,9 +679,7 @@ func TestFindallVariables(t *testing.T) {
varList = append(varList, varName)
}
sort.Strings(varList)
if !assert.Equal(t, data.expectVars, varList) {
t.Fatal()
}
assert.Equal(t, data.expectVars, varList)
}
}
@@ -802,13 +697,9 @@ func TestSearchJmespath(t *testing.T) {
resp := http.Response{}
resp.Body = io.NopCloser(strings.NewReader(testText))
respObj, err := newHttpResponseObject(t, NewParser(), &resp)
if err != nil {
t.Fatal()
}
require.Nil(t, err)
for _, data := range testData {
if !assert.Equal(t, data.expected, respObj.searchJmespath(data.raw)) {
t.Fatal()
}
assert.Equal(t, data.expected, respObj.searchJmespath(data.raw))
}
}
@@ -845,13 +736,9 @@ func TestSearchRegexp(t *testing.T) {
resp := http.Response{}
resp.Body = io.NopCloser(strings.NewReader(testText))
respObj, err := newHttpResponseObject(t, NewParser(), &resp)
if err != nil {
t.Fatal()
}
require.Nil(t, err)
for _, data := range testData {
if !assert.Equal(t, data.expected, respObj.searchRegexp(data.raw)) {
t.Fatal()
}
assert.Equal(t, data.expected, respObj.searchRegexp(data.raw))
}
}
@@ -897,25 +784,13 @@ def Test5(): # exported function
pass
`
names, err := regexPyFunctionName.findAllFunctionNames(content)
if !assert.Nil(t, err) {
t.FailNow()
}
if !assert.Contains(t, names, "test_1") {
t.FailNow()
}
if !assert.Contains(t, names, "Test5") {
t.FailNow()
}
if !assert.Contains(t, names, "_test_2") {
t.FailNow()
}
if !assert.NotContains(t, names, "__test_3") {
t.FailNow()
}
assert.Nil(t, err)
assert.Contains(t, names, "test_1")
assert.Contains(t, names, "Test5")
assert.Contains(t, names, "_test_2")
assert.NotContains(t, names, "__test_3")
// commented out function
if !assert.NotContains(t, names, "test_4") {
t.FailNow()
}
assert.NotContains(t, names, "test_4")
}
func TestFindAllGoFunctionNames(t *testing.T) {
@@ -941,25 +816,13 @@ func _Test3() { // exported function
// }
`
names, err := regexGoFunctionName.findAllFunctionNames(content)
if !assert.Nil(t, err) {
t.FailNow()
}
if !assert.Contains(t, names, "Test1") {
t.FailNow()
}
if !assert.Contains(t, names, "testFunc2") {
t.FailNow()
}
if !assert.NotContains(t, names, "init") {
t.FailNow()
}
if !assert.Contains(t, names, "_Test3") {
t.FailNow()
}
assert.Nil(t, err)
assert.Contains(t, names, "Test1")
assert.Contains(t, names, "testFunc2")
assert.NotContains(t, names, "init")
assert.Contains(t, names, "_Test3")
// commented out function
if !assert.NotContains(t, names, "Test4") {
t.FailNow()
}
assert.NotContains(t, names, "Test4")
}
func TestFindAllGoFunctionNamesAbnormal(t *testing.T) {
@@ -973,7 +836,5 @@ func main() { // should not define main() function
}
`
_, err := regexGoFunctionName.findAllFunctionNames(content)
if !assert.NotNil(t, err) {
t.FailNow()
}
assert.Error(t, err)
}

152
tests/step_request_test.go
View File

@@ -31,21 +31,15 @@ var (
func TestRunRequestGetToStruct(t *testing.T) {
tStep := stepGET
if tStep.Request.Method != hrp.HTTP_GET {
t.Fatalf("tStep.Request.Method != GET")
}
if tStep.Request.URL != "/get" {
t.Fatalf("tStep.Request.URL != '/get'")
}
if tStep.Request.Params["foo1"] != "bar1" || tStep.Request.Params["foo2"] != "bar2" {
t.Fatalf("tStep.Request.Params mismatch")
}
if tStep.Request.Headers["User-Agent"] != "HttpRunnerPlus" {
t.Fatalf("tStep.Request.Headers mismatch")
}
if tStep.Request.Cookies["user"] != "debugtalk" {
t.Fatalf("tStep.Request.Cookies mismatch")
}
assert.Equal(t, tStep.Request.Method, hrp.HTTP_GET)
assert.Equal(t, tStep.Request.URL, "/get")
assert.Equal(t, tStep.Request.Params["foo1"], "bar1")
assert.Equal(t, tStep.Request.Params["foo2"], "bar2")
assert.Equal(t, tStep.Request.Headers["User-Agent"], "HttpRunnerPlus")
assert.Equal(t, tStep.Request.Cookies["user"], "debugtalk")
validator, ok := tStep.Validators[0].(hrp.Validator)
if !ok || validator.Check != "status_code" || validator.Expect != 200 {
t.Fatalf("tStep.Validators mismatch")
@@ -54,24 +48,16 @@ func TestRunRequestGetToStruct(t *testing.T) {
func TestRunRequestPostDataToStruct(t *testing.T) {
tStep := stepPOSTData
if tStep.Request.Method != hrp.HTTP_POST {
t.Fatalf("tStep.Request.Method != POST")
}
if tStep.Request.URL != "/post" {
t.Fatalf("tStep.Request.URL != '/post'")
}
if tStep.Request.Params["foo1"] != "bar1" || tStep.Request.Params["foo2"] != "bar2" {
t.Fatalf("tStep.Request.Params mismatch")
}
if tStep.Request.Headers["User-Agent"] != "HttpRunnerPlus" {
t.Fatalf("tStep.Request.Headers mismatch")
}
if tStep.Request.Cookies["user"] != "debugtalk" {
t.Fatalf("tStep.Request.Cookies mismatch")
}
if tStep.Request.Body != "a=1&b=2" {
t.Fatalf("tStep.Request.Data mismatch")
}
assert.Equal(t, tStep.Request.Method, hrp.HTTP_POST)
assert.Equal(t, tStep.Request.URL, "/post")
assert.Equal(t, tStep.Request.Params["foo1"], "bar1")
assert.Equal(t, tStep.Request.Params["foo2"], "bar2")
assert.Equal(t, tStep.Request.Headers["User-Agent"], "HttpRunnerPlus")
assert.Equal(t, tStep.Request.Cookies["user"], "debugtalk")
assert.Equal(t, tStep.Request.Body, "a=1&b=2")
validator, ok := tStep.Validators[0].(hrp.Validator)
if !ok || validator.Check != "status_code" || validator.Expect != 200 {
t.Fatalf("tStep.Validators mismatch")
@@ -86,77 +72,33 @@ func TestRunRequestStatOn(t *testing.T) {
caseRunner, _ := hrp.NewRunner(t).SetHTTPStatOn().NewCaseRunner(testcase)
sessionRunner := caseRunner.NewSession()
summary, err := sessionRunner.Start(nil)
if err != nil {
t.Fatal()
}
assert.Nil(t, err)
stat := summary.Records[0].HttpStat
if !assert.GreaterOrEqual(t, stat["DNSLookup"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["TCPConnection"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["TLSHandshake"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["ServerProcessing"], int64(0)) {
t.Fatal()
}
if !assert.GreaterOrEqual(t, stat["ContentTransfer"], int64(0)) {
t.Fatal()
}
if !assert.GreaterOrEqual(t, stat["NameLookup"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["Connect"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["Pretransfer"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["StartTransfer"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["Total"], int64(5)) {
t.Fatal()
}
if !assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(3)) {
t.Fatal()
}
assert.GreaterOrEqual(t, stat["DNSLookup"], int64(0))
assert.Greater(t, stat["TCPConnection"], int64(0))
assert.Greater(t, stat["TLSHandshake"], int64(0))
assert.Greater(t, stat["ServerProcessing"], int64(0))
assert.GreaterOrEqual(t, stat["ContentTransfer"], int64(0))
assert.GreaterOrEqual(t, stat["NameLookup"], int64(0))
assert.Greater(t, stat["Connect"], int64(0))
assert.Greater(t, stat["Pretransfer"], int64(0))
assert.Greater(t, stat["StartTransfer"], int64(0))
assert.Greater(t, stat["Total"], int64(5))
assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(3))
// reuse connection
stat = summary.Records[1].HttpStat
if !assert.Equal(t, int64(0), stat["DNSLookup"]) {
t.Fatal()
}
if !assert.Equal(t, int64(0), stat["TCPConnection"]) {
t.Fatal()
}
if !assert.Equal(t, int64(0), stat["TLSHandshake"]) {
t.Fatal()
}
if !assert.Greater(t, stat["ServerProcessing"], int64(1)) {
t.Fatal()
}
if !assert.Equal(t, int64(0), stat["NameLookup"]) {
t.Fatal()
}
if !assert.Equal(t, int64(0), stat["Connect"]) {
t.Fatal()
}
if !assert.Equal(t, int64(0), stat["Pretransfer"]) {
t.Fatal()
}
if !assert.Greater(t, stat["StartTransfer"], int64(0)) {
t.Fatal()
}
if !assert.Greater(t, stat["Total"], int64(1)) {
t.Fatal()
}
if !assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(100)) {
t.Fatal()
}
assert.Equal(t, int64(0), stat["DNSLookup"])
assert.Equal(t, int64(0), stat["TCPConnection"])
assert.Equal(t, int64(0), stat["TLSHandshake"])
assert.Greater(t, stat["ServerProcessing"], int64(1))
assert.Equal(t, int64(0), stat["NameLookup"])
assert.Equal(t, int64(0), stat["Connect"])
assert.Equal(t, int64(0), stat["Pretransfer"])
assert.Greater(t, stat["StartTransfer"], int64(0))
assert.Greater(t, stat["Total"], int64(1))
assert.Less(t, stat["Total"]-summary.Records[0].Elapsed, int64(100))
}
func TestRunCaseWithTimeout(t *testing.T) {
@@ -175,9 +117,7 @@ func TestRunCaseWithTimeout(t *testing.T) {
},
}
err := r.Run(testcase1)
if !assert.NoError(t, err) { // assert no error
t.FailNow()
}
assert.Nil(t, err)
testcase2 := &hrp.TestCase{
Config: hrp.NewConfig("TestCase2").
@@ -191,9 +131,7 @@ func TestRunCaseWithTimeout(t *testing.T) {
},
}
err = r.Run(testcase2)
if !assert.Error(t, err) { // assert error
t.FailNow()
}
assert.Error(t, err)
// step timeout
testcase3 := &hrp.TestCase{
@@ -209,7 +147,5 @@ func TestRunCaseWithTimeout(t *testing.T) {
},
}
err = r.Run(testcase3)
if !assert.NoError(t, err) {
t.FailNow()
}
assert.Nil(t, err)
}