func assertChannelContainsMessage(a *assert.Assertions, c <-chan *protocol.Message, msg []byte) {
select {
case m := <-c:
a.Equal(string(msg), string(m.Body))
case <-time.After(time.Millisecond * 5):
a.Fail("No message received")
}
}
// ExpectDone waits to receive a value in the doneChannel for at least a second
// or fails the test.
func ExpectDone(a *assert.Assertions, doneChannel chan bool) {
select {
case <-doneChannel:
return
case <-time.After(time.Second):
a.Fail("timeout in expectDone")
}
}
func assertChannelContainsMessage(a *assert.Assertions, c chan MsgAndRoute, msg []byte) {
//log.Println("DEBUG: start assertChannelContainsMessage-> select")
select {
case msgBack := <-c:
a.Equal(string(msg), string(msgBack.Message.Body))
case <-time.After(time.Millisecond):
a.Fail("No message received")
}
}
func messagePartitionReader(name string, a *assert.Assertions, store *MessagePartition, n int, done chan bool) {
lastReadMessage := 0
for lastReadMessage < n {
msgC := make(chan MessageAndId)
errorC := make(chan error)
log.WithFields(log.Fields{
"module": "testing",
"name": name,
"lastReadMsg": lastReadMessage + 1,
}).Debug("Start fetching at")
store.Fetch(FetchRequest{
Partition: "myMessages",
StartId: uint64(lastReadMessage + 1),
Direction: 1,
Count: math.MaxInt32,
MessageC: msgC,
ErrorCallback: errorC,
StartCallback: make(chan int, 1),
})
fetch:
for {
select {
case msgAndId, open := <-msgC:
if !open {
log.WithFields(log.Fields{
"module": "testing",
"name": name,
"lastReadMsg": lastReadMessage,
}).Debug("Stop fetching at")
break fetch
}
a.Equal(lastReadMessage+1, int(msgAndId.Id))
lastReadMessage = int(msgAndId.Id)
case err := <-errorC:
a.Fail("received error", err.Error())
<-done
return
}
}
}
log.WithFields(log.Fields{
"module": "testing",
"name": name,
"lastReadMsg": lastReadMessage,
}).Debug("Ready got id")
done <- true
}
func expectMessages(a *assert.Assertions, msgChannel chan []byte, message ...string) {
for _, m := range message {
select {
case msg := <-msgChannel:
a.Equal(m, string(msg))
case <-time.After(time.Millisecond * 100):
a.Fail("timeout: " + m)
}
}
}
func loadJson(filename string, a *assert.Assertions) map[string]string {
var data map[string]string
content, err := ioutil.ReadFile("./test.json")
if err != nil {
a.Fail("Failed to read file ", err)
}
json.Unmarshal(content, &data)
return data
}
func messagePartitionReader(name string, a *assert.Assertions, mStore *messagePartition, n int, done chan bool) {
lastReadMessage := 0
for lastReadMessage < n {
msgC := make(chan *store.FetchedMessage, 10)
errorC := make(chan error)
log.WithFields(log.Fields{
"module": "testing",
"name": name,
"lastReadMsg": lastReadMessage + 1,
}).Debug("Start fetching")
mStore.Fetch(&store.FetchRequest{
Partition: "myMessages",
StartID: uint64(lastReadMessage + 1),
Direction: 1,
Count: math.MaxInt32,
MessageC: msgC,
ErrorC: errorC,
StartC: make(chan int, 1),
})
FETCH:
for {
select {
case msgAndID, open := <-msgC:
if !open {
log.WithFields(log.Fields{
"module": "testing",
"name": name,
"lastReadMsg": lastReadMessage,
}).Debug("Stop fetching")
break FETCH
}
a.Equal(lastReadMessage+1, int(msgAndID.ID), "Reader: "+name)
lastReadMessage = int(msgAndID.ID)
case err := <-errorC:
a.Fail("received error", err.Error())
<-done
return
}
}
}
log.WithFields(log.Fields{
"module": "testing",
"name": name,
"lastReadMsg": lastReadMessage,
}).Debug("Ready got id")
done <- true
}
// deepCheckValue checks that all given keys correspond to a valid path in the
// configuration map of the given layer, and that the final value equals the one given
func deepCheckValue(assert *assert.Assertions, v *Viper, l layer, keys []string, value interface{}) {
if assert == nil || v == nil ||
len(keys) == 0 || len(keys[0]) == 0 {
return
}
// init
var val interface{}
var ms string
switch l {
case defaultLayer:
val = v.defaults
ms = "v.defaults"
case overrideLayer:
val = v.override
ms = "v.override"
}
// loop through map
var m map[string]interface{}
err := false
for _, k := range keys {
if val == nil {
assert.Fail(fmt.Sprintf("%s is not a map[string]interface{}", ms))
return
}
// deep scan of the map to get the final value
switch val.(type) {
case map[interface{}]interface{}:
m = cast.ToStringMap(val)
case map[string]interface{}:
m = val.(map[string]interface{})
default:
assert.Fail(fmt.Sprintf("%s is not a map[string]interface{}", ms))
return
}
ms = ms + "[\"" + k + "\"]"
val = m[k]
}
if !err {
assert.Equal(value, val)
}
}
func asserChannelContainsEntries(a *assert.Assertions, entryC chan [2]string, expectedEntries ...[2]string) {
allEntries := make([][2]string, 0)
loop:
for {
select {
case entry, ok := <-entryC:
if !ok {
break loop
}
allEntries = append(allEntries, entry)
case <-time.After(time.Second):
a.Fail("timeout")
}
}
a.Equal(len(expectedEntries), len(allEntries))
for _, expected := range expectedEntries {
a.Contains(allEntries, expected)
}
}
func assertChannelContains(a *assert.Assertions, entryC chan string, expectedEntries ...string) {
var allEntries []string
WAITLOOP:
for {
select {
case entry, ok := <-entryC:
if !ok {
break WAITLOOP
}
allEntries = append(allEntries, entry)
case <-time.After(time.Second):
a.Fail("timeout")
}
}
a.Equal(len(expectedEntries), len(allEntries))
for _, expected := range expectedEntries {
a.Contains(allEntries, expected)
}
}
func runTestCase(assert *assert.Assertions, given interface{}, testcase TestCase, filename string) {
lexer := NewLexer()
var err error
_, err = lexer.tokenize(testcase.Expression)
if err != nil {
errMsg := fmt.Sprintf("(%s) Could not lex expression: %s -- %s", filename, testcase.Expression, err.Error())
assert.Fail(errMsg)
return
}
parser := NewParser()
_, err = parser.Parse(testcase.Expression)
if err != nil {
errMsg := fmt.Sprintf("(%s) Could not parse expression: %s -- %s", filename, testcase.Expression, err.Error())
assert.Fail(errMsg)
return
}
actual, err := Search(testcase.Expression, given)
if assert.Nil(err, fmt.Sprintf("Expression: %s", testcase.Expression)) {
assert.Equal(testcase.Result, actual, fmt.Sprintf("Expression: %s", testcase.Expression))
}
}
func messagePartitionReader(name string, a *assert.Assertions, store *MessagePartition, n int, done chan bool) {
lastReadMessage := 0
for lastReadMessage < n {
msgC := make(chan MessageAndId)
errorC := make(chan error)
guble.Debug("[%v] start fetching at: %v", name, lastReadMessage+1)
store.Fetch(FetchRequest{
Partition: "myMessages",
StartId: uint64(lastReadMessage + 1),
Direction: 1,
Count: math.MaxInt32,
MessageC: msgC,
ErrorCallback: errorC,
StartCallback: make(chan int, 1),
})
fetch:
for {
select {
case msgAndId, open := <-msgC:
if !open {
guble.Debug("[%v] stop fetching at %v", name, lastReadMessage)
break fetch
}
a.Equal(lastReadMessage+1, int(msgAndId.Id))
lastReadMessage = int(msgAndId.Id)
case err := <-errorC:
a.Fail("received error", err.Error())
<-done
return
}
}
}
guble.Debug("[%v] ready, got %v", name, lastReadMessage)
done <- true
}
func checkNode(t testing.TB, x *assert.Assertions, node Node) {
acount, err := node.AdjacentCount()
if err != nil {
t.Fatal(err)
}
kcount, err := node.ChildCount()
if err != nil {
t.Fatal(err)
}
kids, err := node.Children()
if err != nil {
t.Fatal(err)
}
pcount, err := node.ParentCount()
if err != nil {
t.Fatal(err)
}
parents, err := node.Parents()
if err != nil {
t.Fatal(err)
}
if kcount != len(kids) {
x.Fail("kcount != len(kids)")
}
if pcount != len(parents) {
x.Fail("count != len(parents)")
}
if kcount+pcount != acount {
x.Fail("kcount + pcount != acount")
}
for _, kid := range kids {
checkKid(t, x, node, kid.(Node))
}
for _, parent := range parents {
checkKid(t, x, parent.(Node), node)
}
}
func checkKid(t testing.TB, x *assert.Assertions, parent, kid Node) {
pkids, err := parent.Children()
if err != nil {
t.Fatal(err)
}
found := false
for _, pkid := range pkids {
if bytes.Equal(pkid.Pattern().Label(), kid.Label()) {
found = true
}
}
if !found {
t.Errorf("parent %v kids %v did not have %v", parent, pkids, kid)
findChildren(parent, nil, true)
t.Fatalf("assert-fail")
}
kparents, err := kid.Parents()
if err != nil {
t.Fatal(err)
}
found = false
for _, kparent := range kparents {
if bytes.Equal(kparent.Pattern().Label(), parent.Label()) {
found = true
}
}
if !found {
t.Fatalf("kid %v parents %v did not have %v", kid, kparents, parent)
}
pkids, err = parent.CanonKids()
if err != nil {
errors.Logf("ERROR", "err = %v", err)
x.Fail("err != nil")
os.Exit(2)
}
found = false
for _, pkid := range pkids {
if bytes.Equal(pkid.Pattern().Label(), kid.Label()) {
found = true
}
}
if found {
// kid is a canon kid
// kid should have no other canon parents
kparents, err := kid.Parents()
if err != nil {
t.Fatal(err)
}
found = false
for _, kparent := range kparents {
if bytes.Equal(kparent.Pattern().Label(), parent.Label()) {
continue
}
kparent_ckids, err := kparent.CanonKids()
if err != nil {
t.Fatal(err)
}
for _, kparent_ckid := range kparent_ckids {
if bytes.Equal(kparent_ckid.Pattern().Label(), kid.Label()) {
x.Fail(errors.Errorf("kid %v had multiple canon parents %v %v", kid, parent, kparent).Error())
}
}
}
}
}
