Simplify subscribing to events and fix events

[govpp.git] / core / channel_test.go

diff --git a/core/channel_test.go b/core/channel_test.go
index 4a9ab2b..0eafa32 100644 (file)
--- 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"))
-}*/
+}