Simplify subscribing to events and fix events

- there is no need for sending subscription requests through channels,
  since all the messages are registered and no communication with VPP
  is needed

Change-Id: Ibc29957be02a32e26309f66c369a071559b822a9
Signed-off-by: Ondrej Fabry <ofabry@cisco.com>

1 files changed, 89 insertions, 84 deletions

diff --git a/core/channel_test.go b/core/channel_test.go
index 4a9ab2b..0eafa32 100644
--- a/core/channel_test.go
+++ b/core/channel_test.go
@@ -22,6 +22,7 @@ import (
 	"git.fd.io/govpp.git/examples/bin_api/interfaces"
 	"git.fd.io/govpp.git/examples/bin_api/memif"
 	"git.fd.io/govpp.git/examples/bin_api/tap"
+	"git.fd.io/govpp.git/examples/binapi/vpe"
 
 	"git.fd.io/govpp.git/api"
 	. "github.com/onsi/gomega"
@@ -59,10 +60,11 @@ func TestRequestReplyTapConnect(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	ctx.mockVpp.MockReply(&tap.TapConnectReply{
-		Retval:    0,
 		SwIfIndex: 1,
 	})
+
 	request := &tap.TapConnect{
 		TapName:      []byte("test-tap-name"),
 		UseRandomMac: 1,
@@ -71,17 +73,21 @@ func TestRequestReplyTapConnect(t *testing.T) {
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapConnectReply")
-	Expect(reply.SwIfIndex).To(BeEquivalentTo(1), "Incorrect SwIfIndex value for TapConnectReply")
+	Expect(reply.Retval).To(BeEquivalentTo(0),
+		"Incorrect Retval value for TapConnectReply")
+	Expect(reply.SwIfIndex).To(BeEquivalentTo(1),
+		"Incorrect SwIfIndex value for TapConnectReply")
 }
 
 func TestRequestReplyTapModify(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	ctx.mockVpp.MockReply(&tap.TapModifyReply{
 		SwIfIndex: 2,
 	})
+
 	request := &tap.TapModify{
 		TapName:           []byte("test-tap-modify"),
 		UseRandomMac:      1,
@@ -91,15 +97,19 @@ func TestRequestReplyTapModify(t *testing.T) {
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapModifyReply")
-	Expect(reply.SwIfIndex).To(BeEquivalentTo(2), "Incorrect SwIfIndex value for TapModifyReply")
+	Expect(reply.Retval).To(BeEquivalentTo(0),
+		"Incorrect Retval value for TapModifyReply")
+	Expect(reply.SwIfIndex).To(BeEquivalentTo(2),
+		"Incorrect SwIfIndex value for TapModifyReply")
 }
 
 func TestRequestReplyTapDelete(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	ctx.mockVpp.MockReply(&tap.TapDeleteReply{})
+
 	request := &tap.TapDelete{
 		SwIfIndex: 3,
 	}
@@ -107,34 +117,41 @@ func TestRequestReplyTapDelete(t *testing.T) {
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapDeleteReply")
+	Expect(reply.Retval).To(BeEquivalentTo(0),
+		"Incorrect Retval value for TapDeleteReply")
 }
 
 func TestRequestReplySwInterfaceTapDump(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	byteName := []byte("dev-name-test")
 	ctx.mockVpp.MockReply(&tap.SwInterfaceTapDetails{
 		SwIfIndex: 25,
 		DevName:   byteName,
 	})
+
 	request := &tap.SwInterfaceTapDump{}
 	reply := &tap.SwInterfaceTapDetails{}
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.SwIfIndex).To(BeEquivalentTo(25), "Incorrect SwIfIndex value for SwInterfaceTapDetails")
-	Expect(reply.DevName).ToNot(BeNil(), "Incorrect DevName value for SwInterfaceTapDetails")
+	Expect(reply.SwIfIndex).To(BeEquivalentTo(25),
+		"Incorrect SwIfIndex value for SwInterfaceTapDetails")
+	Expect(reply.DevName).ToNot(BeEquivalentTo(byteName),
+		"Incorrect DevName value for SwInterfaceTapDetails")
 }
 
 func TestRequestReplyMemifCreate(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	ctx.mockVpp.MockReply(&memif.MemifCreateReply{
 		SwIfIndex: 4,
 	})
+
 	request := &memif.MemifCreate{
 		Role:       10,
 		ID:         12,
@@ -145,15 +162,19 @@ func TestRequestReplyMemifCreate(t *testing.T) {
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect Retval value for MemifCreate")
-	Expect(reply.SwIfIndex).To(BeEquivalentTo(4), "Incorrect SwIfIndex value for MemifCreate")
+	Expect(reply.Retval).To(BeEquivalentTo(0),
+		"Incorrect Retval value for MemifCreate")
+	Expect(reply.SwIfIndex).To(BeEquivalentTo(4),
+		"Incorrect SwIfIndex value for MemifCreate")
 }
 
 func TestRequestReplyMemifDelete(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	ctx.mockVpp.MockReply(&memif.MemifDeleteReply{})
+
 	request := &memif.MemifDelete{
 		SwIfIndex: 15,
 	}
@@ -161,26 +182,30 @@ func TestRequestReplyMemifDelete(t *testing.T) {
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect Retval value for MemifDelete")
 }
 
 func TestRequestReplyMemifDetails(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
+	// mock reply
 	ctx.mockVpp.MockReply(&memif.MemifDetails{
 		SwIfIndex: 25,
 		IfName:    []byte("memif-name"),
 		Role:      0,
 	})
+
 	request := &memif.MemifDump{}
 	reply := &memif.MemifDetails{}
 
 	err := ctx.ch.SendRequest(request).ReceiveReply(reply)
 	Expect(err).ShouldNot(HaveOccurred())
-	Expect(reply.SwIfIndex).To(BeEquivalentTo(25), "Incorrect SwIfIndex value for MemifDetails")
-	Expect(reply.IfName).ToNot(BeEmpty(), "MemifDetails IfName is empty byte array")
-	Expect(reply.Role).To(BeEquivalentTo(0), "Incorrect Role value for MemifDetails")
+	Expect(reply.SwIfIndex).To(BeEquivalentTo(25),
+		"Incorrect SwIfIndex value for MemifDetails")
+	Expect(reply.IfName).ToNot(BeEmpty(),
+		"MemifDetails IfName is empty byte array")
+	Expect(reply.Role).To(BeEquivalentTo(0),
+		"Incorrect Role value for MemifDetails")
 }
 
 func TestMultiRequestReplySwInterfaceTapDump(t *testing.T) {
@@ -204,7 +229,7 @@ func TestMultiRequestReplySwInterfaceTapDump(t *testing.T) {
 		msg := &tap.SwInterfaceTapDetails{}
 		stop, err := reqCtx.ReceiveReply(msg)
 		if stop {
-			break // break out of the loop
+			break
 		}
 		Expect(err).ShouldNot(HaveOccurred())
 		cnt++
@@ -232,7 +257,7 @@ func TestMultiRequestReplySwInterfaceMemifDump(t *testing.T) {
 		msg := &memif.MemifDetails{}
 		stop, err := reqCtx.ReceiveReply(msg)
 		if stop {
-			break // break out of the loop
+			break
 		}
 		Expect(err).ShouldNot(HaveOccurred())
 		cnt++
@@ -240,51 +265,16 @@ func TestMultiRequestReplySwInterfaceMemifDump(t *testing.T) {
 	Expect(cnt).To(BeEquivalentTo(10))
 }
 
-func TestNotifications(t *testing.T) {
-	ctx := setupTest(t)
-	defer ctx.teardownTest()
-
-	// subscribe for notification
-	notifChan := make(chan api.Message, 1)
-	subs, err := ctx.ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceSetFlags)
-	Expect(err).ShouldNot(HaveOccurred())
-
-	// mock the notification and force its delivery
-	ctx.mockVpp.MockReply(&interfaces.SwInterfaceSetFlags{
-		SwIfIndex:   3,
-		AdminUpDown: 1,
-	})
-	ctx.mockVpp.SendMsg(0, []byte(""))
-
-	// receive the notification
-	var notif *interfaces.SwInterfaceSetFlags
-	Eventually(func() *interfaces.SwInterfaceSetFlags {
-		select {
-		case n := <-notifChan:
-			notif = n.(*interfaces.SwInterfaceSetFlags)
-			return notif
-		default:
-			return nil
-		}
-	}).ShouldNot(BeNil())
-
-	// verify the received notifications
-	Expect(notif.SwIfIndex).To(BeEquivalentTo(3), "Incorrect SwIfIndex value for SwInterfaceSetFlags")
-	Expect(notif.AdminUpDown).To(BeEquivalentTo(1), "Incorrect AdminUpDown value for SwInterfaceSetFlags")
-
-	ctx.ch.UnsubscribeNotification(subs)
-}
-
 func TestNotificationEvent(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
 	// subscribe for notification
 	notifChan := make(chan api.Message, 1)
-	subs, err := ctx.ch.SubscribeNotification(notifChan, interfaces.NewSwInterfaceEvent)
+	sub, err := ctx.ch.SubscribeNotification(notifChan, &interfaces.SwInterfaceEvent{})
 	Expect(err).ShouldNot(HaveOccurred())
 
-	// mock the notification and force its delivery
+	// mock event and force its delivery
 	ctx.mockVpp.MockReply(&interfaces.SwInterfaceEvent{
 		SwIfIndex:  2,
 		LinkUpDown: 1,
@@ -307,16 +297,9 @@ func TestNotificationEvent(t *testing.T) {
 	Expect(notif.SwIfIndex).To(BeEquivalentTo(2), "Incorrect SwIfIndex value for SwInterfaceSetFlags")
 	Expect(notif.LinkUpDown).To(BeEquivalentTo(1), "Incorrect LinkUpDown value for SwInterfaceSetFlags")
 
-	ctx.ch.UnsubscribeNotification(subs)
-}
-
-/*func TestCheckMessageCompatibility(t *testing.T) {
-	ctx := setupTest(t)
-	defer ctx.teardownTest()
-
-	err := ctx.ch.CheckMessageCompatibility(&interfaces.SwInterfaceSetFlags{})
+	err = sub.Unsubscribe()
 	Expect(err).ShouldNot(HaveOccurred())
-}*/
+}
 
 func TestSetReplyTimeout(t *testing.T) {
 	ctx := setupTest(t)
@@ -324,8 +307,10 @@ func TestSetReplyTimeout(t *testing.T) {
 
 	ctx.ch.SetReplyTimeout(time.Millisecond)
 
-	// first one request should work
+	// mock reply
 	ctx.mockVpp.MockReply(&ControlPingReply{})
+
+	// first one request should work
 	err := ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
 	Expect(err).ShouldNot(HaveOccurred())
 
@@ -339,16 +324,23 @@ func TestSetReplyTimeoutMultiRequest(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
-	ctx.ch.SetReplyTimeout(time.Millisecond)
+	ctx.ch.SetReplyTimeout(time.Millisecond * 100)
 
-	var msgs []api.Message
-	for i := 1; i <= 3; i++ {
-		msgs = append(msgs, &interfaces.SwInterfaceDetails{
-			SwIfIndex:     uint32(i),
+	// mock reply
+	ctx.mockVpp.MockReply(
+		&interfaces.SwInterfaceDetails{
+			SwIfIndex:     1,
 			InterfaceName: []byte("if-name-test"),
-		})
-	}
-	ctx.mockVpp.MockReply(msgs...)
+		},
+		&interfaces.SwInterfaceDetails{
+			SwIfIndex:     2,
+			InterfaceName: []byte("if-name-test"),
+		},
+		&interfaces.SwInterfaceDetails{
+			SwIfIndex:     3,
+			InterfaceName: []byte("if-name-test"),
+		},
+	)
 	ctx.mockVpp.MockReply(&ControlPingReply{})
 
 	cnt := 0
@@ -357,12 +349,12 @@ func TestSetReplyTimeoutMultiRequest(t *testing.T) {
 		for {
 			msg := &interfaces.SwInterfaceDetails{}
 			stop, err := reqCtx.ReceiveReply(msg)
-			if stop {
-				break // break out of the loop
-			}
 			if err != nil {
 				return err
 			}
+			if stop {
+				break
+			}
 			cnt++
 		}
 		return nil
@@ -443,7 +435,7 @@ func TestMultiRequestDouble(t *testing.T) {
 			msg := &interfaces.SwInterfaceDetails{}
 			stop, err := reqCtx.ReceiveReply(msg)
 			if stop {
-				break // break out of the loop
+				break
 			}
 			if err != nil {
 				return err
@@ -468,8 +460,10 @@ func TestReceiveReplyAfterTimeout(t *testing.T) {
 
 	ctx.ch.SetReplyTimeout(time.Millisecond)
 
-	// first one request should work
+	// mock reply
 	ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &ControlPingReply{}, SeqNum: 1})
+	// first one request should work
+
 	err := ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
 	Expect(err).ShouldNot(HaveOccurred())
 
@@ -479,9 +473,16 @@ func TestReceiveReplyAfterTimeout(t *testing.T) {
 
 	ctx.mockVpp.MockReplyWithContext(
 		// simulating late reply
-		mock.MsgWithContext{Msg: &ControlPingReply{}, SeqNum: 2},
+		mock.MsgWithContext{
+			Msg:    &ControlPingReply{},
+			SeqNum: 2,
+		},
 		// normal reply for next request
-		mock.MsgWithContext{Msg: &tap.TapConnectReply{}, SeqNum: 3})
+		mock.MsgWithContext{
+			Msg:    &tap.TapConnectReply{},
+			SeqNum: 3,
+		},
+	)
 
 	req := &tap.TapConnect{
 		TapName:      []byte("test-tap-name"),
@@ -508,8 +509,10 @@ func TestReceiveReplyAfterTimeoutMultiRequest(t *testing.T) {
 
 	ctx.ch.SetReplyTimeout(time.Millisecond * 100)
 
-	// first one request should work
+	// mock reply
 	ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &ControlPingReply{}, SeqNum: 1})
+
+	// first one request should work
 	err := ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
 	Expect(err).ShouldNot(HaveOccurred())
 
@@ -520,7 +523,7 @@ func TestReceiveReplyAfterTimeoutMultiRequest(t *testing.T) {
 			msg := &interfaces.SwInterfaceDetails{}
 			stop, err := reqCtx.ReceiveReply(msg)
 			if stop {
-				break // break out of the loop
+				break
 			}
 			if err != nil {
 				return err
@@ -564,18 +567,20 @@ func TestReceiveReplyAfterTimeoutMultiRequest(t *testing.T) {
 	Expect(err).ShouldNot(HaveOccurred())
 }
 
-/*func TestInvalidMessageID(t *testing.T) {
+func TestInvalidMessageID(t *testing.T) {
 	ctx := setupTest(t)
 	defer ctx.teardownTest()
 
-	// first one request should work
+	// mock reply
+	ctx.mockVpp.MockReply(&vpe.ShowVersionReply{})
 	ctx.mockVpp.MockReply(&vpe.ShowVersionReply{})
+
+	// first one request should work
 	err := ctx.ch.SendRequest(&vpe.ShowVersion{}).ReceiveReply(&vpe.ShowVersionReply{})
 	Expect(err).ShouldNot(HaveOccurred())
 
 	// second should fail with error invalid message ID
-	ctx.mockVpp.MockReply(&vpe.ShowVersionReply{})
 	err = ctx.ch.SendRequest(&ControlPing{}).ReceiveReply(&ControlPingReply{})
 	Expect(err).Should(HaveOccurred())
 	Expect(err.Error()).To(ContainSubstring("invalid message ID"))
-}*/
+}