wstestlib

package
v4.38.21 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 11, 2024 License: Apache-2.0 Imports: 30 Imported by: 0

Documentation

Overview

Example (CompareBool) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compare(true, "hello", ctx))
fmt.Println(compare(174, true, ctx))
fmt.Println(compare(true, false, ctx))
fmt.Println(compare(true, true, ctx))

Output:

expected "hello", received "true"
expected "true", received "174"
expected "false", received "true"
<nil>
Example (CompareExpectedString) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compareExpectedString("hello", "hello", ctx))
fmt.Println(compareExpectedString("hello${}", "hello", ctx))
fmt.Println(compareExpectedString("hello${USERID}", "hello", ctx))
fmt.Println(compareExpectedString("${USERID}post", "hello", ctx))
fmt.Println(compareExpectedString("${Chazwozza=2}", "hello", ctx))
fmt.Println(compareExpectedString("${USERID}", "hello", ctx))
fmt.Println(compareExpectedString("${USERID=7}", "hello", ctx))
fmt.Println(compareExpectedString("${IGNORE}", "hello", ctx))
fmt.Println(compareExpectedString("${IGNORE=9}", "hello", ctx))
fmt.Println(compareExpectedString("${IDCHK=unknown}", "hello", ctx))
fmt.Println(compareExpectedString("${IDCHK=name2}", "hello", ctx))
fmt.Println(compareExpectedString("${IDSAVE=saveme}", "id119922", ctx))
fmt.Println(ctx.savedItems)
// Don't allow overwrite
fmt.Println(compareExpectedString("${IDSAVE=saveme}", "998877", ctx))
fmt.Println(compareExpectedString("${IDCHK=saveme}", "hello", ctx))
ctx.allowSaveItemOverwrite = true
fmt.Println(compareExpectedString("${IDSAVE=saveme}", "10000", ctx))
fmt.Println(compareExpectedString("${IDCHK=saveme}", "hello", ctx))
fmt.Println(compareExpectedString("${IDSAVE=shouldfail}", "", ctx))
fmt.Println(compareExpectedString("${REGEXMATCH=hel+o}", "helllllo", ctx))
fmt.Println(compareExpectedString("${REGEXMATCH=hel+o}", "hell_llo", ctx))
fmt.Println(compareExpectedString("${SECAGO=7}", "hello", ctx))
fmt.Println(compareExpectedString("${SECAGO=-7}", "1234", ctx))
fmt.Println(compareExpectedString("${SECAGO=Yellow}", "1234", ctx))
nowUnix := time.Now().Unix()
recv, err := compareExpectedString("${SECAGO=7}", "123", ctx)
fmt.Printf("%v, %v\n", recv, err.Error() == fmt.Sprintf("received time stamp 123 is %v seconds too old", nowUnix-123-7))
nowStr := fmt.Sprintf("%v", nowUnix)
recv, err = compareExpectedString("${SECAGO=7}", nowStr, ctx)
fmt.Printf("%v, %v\n", nowStr == recv, err)

fmt.Println(compareExpectedString("${SECAFTER=123}", "hello", ctx))
fmt.Println(compareExpectedString("${SECAFTER=green}", "123", ctx))
fmt.Println(compareExpectedString("${SECAFTER=123}", "122", ctx))
fmt.Println(compareExpectedString("${SECAFTER=123}", "123", ctx))
fmt.Println(compareExpectedString("${SECAFTER=123}", "124", ctx))

Output:

hello <nil>
hello <nil>
 Unexpected text around definition: hello${USERID}
 Unexpected text around definition: ${USERID}post
 Unknown matching cmd/param combination: ${Chazwozza=2}
user123 <nil>
 Unknown matching cmd/param combination: ${USERID=7}
hello <nil>
 Unknown matching cmd/param combination: ${IGNORE=9}
 failed to find defined id name to compare: ${IDCHK=unknown}
value2 <nil>
id119922 <nil>
map[name:value name2:value2 saveme:id119922]
saved id for saveme already exists: id119922, doesn't match save attempt: 998877
 saved id for saveme already exists: id119922, doesn't match save attempt: 998877
id119922 <nil>
10000 <nil>
10000 <nil>
 received empty string when trying to save id as "shouldfail"
helllllo <nil>
 received "hell_llo" did not match regex "hel+o"
 failed to parse received "hello" for "SECAGO" comparison as int: strconv.Atoi: parsing "hello": invalid syntax
 invalid value for SECAGO: "${SECAGO=-7}"
 failed to parse param "Yellow" for "SECAGO" as int: strconv.Atoi: parsing "Yellow": invalid syntax
, true
true, <nil>
 failed to parse received "hello" for "SECAFTER" comparison as int: strconv.Atoi: parsing "hello": invalid syntax
 failed to parse param "green" for "SECAFTER" as int: strconv.Atoi: parsing "green": invalid syntax
 received time stamp 122 is before expected 123
123 <nil>
124 <nil>
Example (CompareFloat) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compare(1.2, 1.7, ctx))
fmt.Println(compare(1.2, nil, ctx))
fmt.Println(compare(1.2, 1.2, ctx))

Output:

expected "1.7", received "1.2"
expected "<nil>", received "1.2"
<nil>
Example (CompareListSimple) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compare([]string{"hello", "world"}, nil, ctx))
// NOTE: doesn't work with strings, needs to be interface...
fmt.Println(compare(72, []string{"hello", "world"}, ctx))
fmt.Println(compare(72, []interface{}{"hello", "world"}, ctx))
fmt.Println(compare([]string{"hello", "world"}, []interface{}{"hello", "world"}, ctx))
fmt.Println(compare([]interface{}{"hello", "world"}, []interface{}{"hello", "world"}, ctx))
fmt.Println(compare([]interface{}{"world", "hello"}, []interface{}{"hello", "world"}, ctx))

Output:

expected "<nil>", received "[hello world]"
unexpected type: []string for defined expected data
expected "[hello world]", received "72"
expected "[hello world]", received "[hello world]"
<nil>
"hello": expected "hello", received "world"
Example (CompareMapWithKeyDef) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compare(map[string]interface{}{"zztop": []bool{true, false}, "user123": "world"}, map[string]interface{}{"${USERID}": "world", "zztop": "${IGNORE}"}, ctx))

Output:

<nil>
Example (CompareMaps) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compare(72, map[string]interface{}{"hello": "world", "zztop": "band"}, ctx))
fmt.Println(compare(map[string]interface{}{"hello": "world", "zztop": "band"}, map[string]interface{}{"hello": "world", "zztop": "band"}, ctx))
fmt.Println(compare(map[string]interface{}{"hello": "world", "acdc": "band"}, map[string]interface{}{"hello": "world", "zztop": "band"}, ctx))
fmt.Println(compare(map[string]interface{}{"zztop": "band", "hello": "world"}, map[string]interface{}{"hello": "${IGNORE}", "zztop": "band"}, ctx))
fmt.Println(compare(map[string]interface{}{"zztop": 17, "hello": "world"}, map[string]interface{}{"hello": "world", "zztop": "${IGNORE}"}, ctx))
fmt.Println(compare(map[string]interface{}{"zztop": []bool{true, false}, "hello": "world"}, map[string]interface{}{"hello": "world", "zztop": "${IGNORE}"}, ctx))
fmt.Println(compare(map[string]interface{}{}, map[string]interface{}{"hello": "world", "zztop": "band"}, ctx))
fmt.Println(compare(map[string]interface{}{"hello": "world", "zztop": "band"}, map[string]interface{}{}, ctx))

Output:

expected "map[hello:world zztop:band]", received "72"
<nil>
expected key: "hello", received key: "acdc"
<nil>
<nil>
<nil>
mismatch in structure, expected 2 fields, received 0. Expected keys: [hello, zztop]. Missing from Received: [hello, zztop]
mismatch in structure, expected 0 fields, received 2. Expected keys: []. Received keys: [hello, zztop]
Example (CompareMapsOfLists) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

// List comparison
// NOTE: testing here with doubles, ints fail, but JSON decode should never return an int anyway
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []int{1, 2, 3}}, map[string]interface{}{"helloo${LIST,MINLENGTH=4}": []int{}, "zztop": 17.2}, ctx))
// Expected map value not a list
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []int{1, 2, 3}}, map[string]interface{}{"hello${LIST,MINLENGTH=4}": "shouldbelist", "zztop": 17.2}, ctx))
// Expected value is an int, which we don't support due to json parser only returning doubles...
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []int{1, 2, 3}}, map[string]interface{}{"hello${LIST,MINLENGTH=4}": []int{}, "zztop": 17.2}, ctx))
// Received type is not a list
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": "should-be-list"}, map[string]interface{}{"hello${LIST,MINLENGTH=4}": []interface{}{}, "zztop": 17.2}, ctx))
// Not enough items
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{1, 2, 3}}, map[string]interface{}{"hello${LIST,MINLENGTH=4}": []interface{}{}, "zztop": 17.2}, ctx))
// Missing mode
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{1, 2, 3, 4}}, map[string]interface{}{"hello${LIST,MINLENGTH=4}": []interface{}{}, "zztop": 17.2}, ctx))

// Check with ints, should fail on a type error
fmt.Println(compare(map[string]interface{}{"zztop": 17, "hello": []interface{}{1, 2, 3, 4}}, map[string]interface{}{"hello${LIST,MODE=LENGTH,MINLENGTH=4}": []interface{}{}, "zztop": 17}, ctx))

// Back to doubles, this should work
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{1, 2, 3, 4}}, map[string]interface{}{"hello${LIST,MODE=LENGTH,MINLENGTH=4}": []interface{}{}, "zztop": 17.2}, ctx))

// Will fail because list contents are ints, but just says 1 not found, because it's actually getting an error from every comparison and can't
// tell the difference...
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{1, 2, 3, 4}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,MINLENGTH=4}": []interface{}{1, 3}, "zztop": 17.2}, ctx))

// With doubles in the list, it should work
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{1.2, 2.2, 3.2, 4.2}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,MINLENGTH=4}": []interface{}{1.2, 3.2}, "zztop": 17.2}, ctx))

// Genuine item not found
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{1.2, 2.2, 3.2, 4.2}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,MINLENGTH=4}": []interface{}{1.2, 7.2}, "zztop": 17.2}, ctx))

// Order shouldn't matter for list comparison
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{2.2, 4.2, 1.2, 3.2}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,MINLENGTH=4}": []interface{}{1.2, 3.2}, "zztop": 17.2}, ctx))
// Checking with LENGTH not MINLENGTH
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{2.2, 4.2, 1.2, 3.2}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,LENGTH=4}": []interface{}{1.2, 3.2}, "zztop": 17.2}, ctx))
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{2.2, 4.2, 1.2, 3.2}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,LENGTH=3}": []interface{}{1.2, 3.2}, "zztop": 17.2}, ctx))
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{2.2, 4.2, 1.2, 3.2}}, map[string]interface{}{"hello${LIST,MODE=LENGTH,LENGTH=4}": []interface{}{}, "zztop": 17.2}, ctx))
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{2.2, 4.2, 1.2, 3.2}}, map[string]interface{}{"hello${LIST,MODE=LENGTH}": []interface{}{3.3}, "zztop": 17.2}, ctx))

// Checking with unrecognised list specification
fmt.Println(compare(map[string]interface{}{"zztop": 17.2, "hello": []interface{}{2.2, 4.2, 1.2, 3.2}}, map[string]interface{}{"hello${LIST,MODE=CONTAINS,NICENESS=4}": []interface{}{1.2, 3.2}, "zztop": 17.2}, ctx))

Output:

expected key: "helloo", received key: "hello"
"hello${LIST,MINLENGTH=4}": expected list for list parse spec "map[MINLENGTH:4]"
"hello${LIST,MINLENGTH=4}": expected list for list parse spec "map[MINLENGTH:4]"
"hello${LIST,MINLENGTH=4}": expected list compatible with parse spec "map[MINLENGTH:4]", received "should-be-list"
"hello${LIST,MINLENGTH=4}": expected at least 4 list items, received 3
"hello${LIST,MINLENGTH=4}": invalid mode in list compare specifications: map[MINLENGTH:4]
"zztop": unexpected type: int for defined expected data
<nil>
"hello${LIST,MODE=CONTAINS,MINLENGTH=4}": expected list to contain item "1"
<nil>
"hello${LIST,MODE=CONTAINS,MINLENGTH=4}": expected list to contain item "7.2"
<nil>
<nil>
"hello${LIST,MODE=CONTAINS,LENGTH=3}": expected exactly 3 list items, received 4
<nil>
"hello${LIST,MODE=LENGTH}": expected 1 list items, received 4
"hello${LIST,MODE=CONTAINS,NICENESS=4}": unrecognised list spec: NICENESS
Example (CompareNil) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

fmt.Println(compare(nil, "hello", ctx))
fmt.Println(compare(174, nil, ctx))
fmt.Println(compare(nil, nil, ctx))

Output:

expected "hello", received "<nil>"
expected "<nil>", received "174"
<nil>
Example (CompareString) 
ctx := compareParams{userId: "user123", savedItems: map[string]string{"name": "value", "name2": "value2"}, allowSaveItemOverwrite: false}

// Some simple values
fmt.Println(compare("hello", "world", ctx))
fmt.Println(compare("hello", 1.7, ctx))
fmt.Println(compare("hello", "hello", ctx))

fmt.Println(compare("hello", "${IGNORE", ctx))
fmt.Println(compare("hello", "${IGNORE}", ctx))
fmt.Println(compare("hello", "${USERID}", ctx))
fmt.Println(compare("user123", "${USERID}", ctx))

Output:

expected "world", received "hello"
expected "1.7", received "hello"
<nil>
failed to find closing token for "}" in "${IGNORE"
<nil>
expected "user123" (raw string: "${USERID}"), received "hello"
<nil>
Example (DoReqReplacements) 
savedLookup := map[string]string{"theName": "NOW", "moreVar": "More"}
fmt.Println(doReqReplacements("here\nis some\ntext", savedLookup))
fmt.Println()
fmt.Println(doReqReplacements("here ${IDLOAD=theName} is\nsome ${IDLOAD=moreVar}\ntext", savedLookup))
fmt.Println(doReqReplacements("here ${IDLOAD=non-existant} it fails", savedLookup))
fmt.Println(doReqReplacements("here ${IDCHK=theName} it fails", savedLookup))
fmt.Println(doReqReplacements("here ${ID=theName unfinished", savedLookup))

Output:

here
is some
text <nil>

here NOW is
some More
text <nil>
 IDLOAD: No replacement text named: non-existant for request message: here ${IDLOAD=non-existant} it fails
 Unknown definition used on request message: IDCHK
 failed to find closing token for "}" in "here ${ID=theName unfinished"
Example (GetDefinitionBetween) 
fmt.Println(getDefinitionBetween("${USERID}", "${", "}"))
fmt.Println(getDefinitionBetween("pre${USERID}", "${", "}"))
fmt.Println(getDefinitionBetween("${USERID}post", "${", "}"))
fmt.Println(getDefinitionBetween("${IDCHK=someValue}", "${", "}"))
fmt.Println(getDefinitionBetween("${IDCHK=someValue,MODE=32,More=Less}", "${", "}"))
fmt.Println(getDefinitionBetween("${IDCHK=someValue, MODE = 32,More=Less}", "${", "}"))
fmt.Println(getDefinitionBetween("pre${IDCHK=someValue, MODE = 32,More=Less}post", "${", "}"))
fmt.Println(getDefinitionBetween("${hello-", "${", "}"))
fmt.Println(getDefinitionBetween("${}", "${", "}"))
fmt.Println(getDefinitionBetween("pre${}", "${", "}"))
fmt.Println(getDefinitionBetween("${}post", "${", "}"))
fmt.Println(getDefinitionBetween("pre${}post", "${", "}"))
fmt.Println(getDefinitionBetween("two${}defs${}here", "${", "}"))
fmt.Println(getDefinitionBetween("no tokens!", "${", "}"))

Output:

USERID   <nil>
USERID pre  <nil>
USERID  post <nil>
IDCHK=someValue   <nil>
IDCHK=someValue,MODE=32,More=Less   <nil>
IDCHK=someValue, MODE = 32,More=Less   <nil>
IDCHK=someValue, MODE = 32,More=Less pre post <nil>
   failed to find closing token for "}" in "${hello-"
   <nil>
 pre  <nil>
  post <nil>
 pre post <nil>
 two defs${}here <nil>
 no tokens!  <nil>
Example (ParseDefinitions) 
fmt.Println(parseDefinitions("${USERID}"))
fmt.Println(parseDefinitions("${IDCHK=someValue}"))
fmt.Println(parseDefinitions("${IDCHK=someValue,MODE=32,More=Less}"))
fmt.Println(parseDefinitions("pre${IDCHK=someValue, MODE = 32,More=Less}post"))
fmt.Println(parseDefinitions("${hello-"))
fmt.Println(parseDefinitions("${}"))
fmt.Println(parseDefinitions("no tokens!"))
fmt.Println(parseDefinitions("hello${LIST,MINLENGTH=4}"))
fmt.Println(parseDefinitions("hello${ZIPCMP,PATH=some/path/file.csv}"))

Output:

map[USERID:]   <nil>
map[IDCHK:someValue]   <nil>
map[IDCHK:someValue MODE:32 More:Less]   <nil>
map[IDCHK:someValue MODE:32 More:Less] pre post <nil>
map[]   failed to find closing token for "}" in "${hello-"
map[]   <nil>
map[] no tokens!  <nil>
map[LIST: MINLENGTH:4] hello  <nil>
map[PATH:some/path/file.csv ZIPCMP:] hello  <nil>

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func ClearJWTCache added in v4.10.2 

func ClearJWTCache()

func ExecQueuedActions 

func ExecQueuedActions(u *ScriptedTestUser)

func GetCaller 

func GetCaller(skip int) string

func GetDB 

func GetDB() *mongo.Database

func GetDBWithEnvironment added in v4.32.2 

func GetDBWithEnvironment(envName string) *mongo.Database

func GetIdCreated 

func GetIdCreated(name string) string

func GetJWTFromCache added in v4.24.3 

func GetJWTFromCache(host string, user string, pass string) string

func RunFullAccessTest 

func RunFullAccessTest(apiHost string, userId string, groupDepth int, noAccessCallback NoAccessTestccessCallbackFunc, accessCheckCallback AccessTestccessCallbackFunc)

Sets up users/groups for different scenarios and calls the callback function for each iteration. Note: noAccessCallback can be nil if not required Group depth defines the max number of groups chained together as part of the tests

Types

type AccessTestccessCallbackFunc 

type AccessTestccessCallbackFunc func(string, string, *protos.UserGroupList, *protos.UserGroupList, []*protos.UserGroupDB, bool)

type Auth0Info 

type Auth0Info struct {
	ClientId string
	Secret   string
	Domain   string
	Audience string
}

type ConnectInfo 

type ConnectInfo struct {
	Host string
	User string
	Pass string
}

type NoAccessTestccessCallbackFunc 

type NoAccessTestccessCallbackFunc func(string)

type ScriptedTestUser 

type ScriptedTestUser struct {
	// contains filtered or unexported fields
}

func MakeScriptedTestUser 

func MakeScriptedTestUser(auth0Params Auth0Info) ScriptedTestUser

func (*ScriptedTestUser) AddConnectAction 

func (s *ScriptedTestUser) AddConnectAction(annotation string, params *ConnectInfo)

Adding various action types

func (*ScriptedTestUser) AddDisonnectAction 

func (s *ScriptedTestUser) AddDisonnectAction(annotation string)

func (*ScriptedTestUser) AddSendReqAction 

func (s *ScriptedTestUser) AddSendReqAction(annotation string, sendReq string, expectedResp string)

func (*ScriptedTestUser) AddSleepAction 

func (s *ScriptedTestUser) AddSleepAction(annotation string, sleepMs uint32)

func (*ScriptedTestUser) ClearActions 

func (s *ScriptedTestUser) ClearActions()

Use to reset a user, fails if called before all existing groups are complete

func (*ScriptedTestUser) CloseActionGroup 

func (s *ScriptedTestUser) CloseActionGroup(expectedMsgs []string, timeoutMs int)

func (*ScriptedTestUser) GetUserId 

func (s *ScriptedTestUser) GetUserId() string

func (*ScriptedTestUser) RunNextAction 

func (s *ScriptedTestUser) RunNextAction() (bool, error)

Returns false if finished, error if there's an error

type WSMessageHeader 

type WSMessageHeader struct {
	MsgId int `json:"msgId"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.