X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=core%2Fchannel_test.go;h=d06e2b3fd8e316323f3428e617642452822ed1c0;hb=c7ae74a95d1bd6fefcbb061f5f045c60c11e32fc;hp=4a9ab2be1b841b3fdcc7988c79206e42e6ff6bdc;hpb=892683bef86cacc2ccda2b4df2b079171bd92164;p=govpp.git diff --git a/core/channel_test.go b/core/channel_test.go index 4a9ab2b..d06e2b3 100644 --- a/core/channel_test.go +++ b/core/channel_test.go @@ -18,13 +18,14 @@ import ( "testing" "time" - "git.fd.io/govpp.git/adapter/mock" - "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" + . "github.com/onsi/gomega" + "git.fd.io/govpp.git/adapter/mock" "git.fd.io/govpp.git/api" - . "github.com/onsi/gomega" + "git.fd.io/govpp.git/examples/binapi/interface_types" + "git.fd.io/govpp.git/examples/binapi/interfaces" + "git.fd.io/govpp.git/examples/binapi/memif" + "git.fd.io/govpp.git/examples/binapi/vpe" ) type testCtx struct { @@ -55,86 +56,15 @@ func (ctx *testCtx) teardownTest() { ctx.conn.Disconnect() } -func TestRequestReplyTapConnect(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&tap.TapConnectReply{ - Retval: 0, - SwIfIndex: 1, - }) - request := &tap.TapConnect{ - TapName: []byte("test-tap-name"), - UseRandomMac: 1, - } - reply := &tap.TapConnectReply{} - - 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") -} - -func TestRequestReplyTapModify(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&tap.TapModifyReply{ - SwIfIndex: 2, - }) - request := &tap.TapModify{ - TapName: []byte("test-tap-modify"), - UseRandomMac: 1, - CustomDevInstance: 1, - } - reply := &tap.TapModifyReply{} - - 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") -} - -func TestRequestReplyTapDelete(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - ctx.mockVpp.MockReply(&tap.TapDeleteReply{}) - request := &tap.TapDelete{ - SwIfIndex: 3, - } - reply := &tap.TapDeleteReply{} - - err := ctx.ch.SendRequest(request).ReceiveReply(reply) - Expect(err).ShouldNot(HaveOccurred()) - Expect(reply.Retval).To(BeEquivalentTo(0), "Incorrect retval value for TapDeleteReply") -} - -func TestRequestReplySwInterfaceTapDump(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - 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") -} - 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 +75,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,55 +95,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"), + IfName: "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") -} - -func TestMultiRequestReplySwInterfaceTapDump(t *testing.T) { - ctx := setupTest(t) - defer ctx.teardownTest() - - // mock reply - var msgs []api.Message - for i := 1; i <= 10; i++ { - msgs = append(msgs, &tap.SwInterfaceTapDetails{ - SwIfIndex: uint32(i), - DevName: []byte("dev-name-test"), - }) - } - ctx.mockVpp.MockReply(msgs...) - ctx.mockVpp.MockReply(&ControlPingReply{}) - - reqCtx := ctx.ch.SendMultiRequest(&tap.SwInterfaceTapDump{}) - cnt := 0 - for { - msg := &tap.SwInterfaceTapDetails{} - stop, err := reqCtx.ReceiveReply(msg) - if stop { - break // break out of the loop - } - Expect(err).ShouldNot(HaveOccurred()) - cnt++ - } - Expect(cnt).To(BeEquivalentTo(10)) + 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 TestMultiRequestReplySwInterfaceMemifDump(t *testing.T) { @@ -220,7 +129,7 @@ func TestMultiRequestReplySwInterfaceMemifDump(t *testing.T) { var msgs []api.Message for i := 1; i <= 10; i++ { msgs = append(msgs, &memif.MemifDetails{ - SwIfIndex: uint32(i), + SwIfIndex: interface_types.InterfaceIndex(i), }) } ctx.mockVpp.MockReply(msgs...) @@ -232,7 +141,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,54 +149,19 @@ 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, + SwIfIndex: 2, + Flags: interface_types.IF_STATUS_API_FLAG_LINK_UP, }) ctx.mockVpp.SendMsg(0, []byte("")) @@ -305,18 +179,11 @@ func TestNotificationEvent(t *testing.T) { // verify the received notifications 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() + Expect(notif.Flags).To(BeEquivalentTo(interface_types.IF_STATUS_API_FLAG_LINK_UP), "Incorrect LinkUpDown value for SwInterfaceSetFlags") - err := ctx.ch.CheckMessageCompatibility(&interfaces.SwInterfaceSetFlags{}) + err = sub.Unsubscribe() Expect(err).ShouldNot(HaveOccurred()) -}*/ +} func TestSetReplyTimeout(t *testing.T) { ctx := setupTest(t) @@ -324,8 +191,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 +208,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), - InterfaceName: []byte("if-name-test"), - }) - } - ctx.mockVpp.MockReply(msgs...) + // mock reply + ctx.mockVpp.MockReply( + &interfaces.SwInterfaceDetails{ + SwIfIndex: 1, + InterfaceName: "if-name-test", + }, + &interfaces.SwInterfaceDetails{ + SwIfIndex: 2, + InterfaceName: "if-name-test", + }, + &interfaces.SwInterfaceDetails{ + SwIfIndex: 3, + InterfaceName: "if-name-test", + }, + ) ctx.mockVpp.MockReply(&ControlPingReply{}) cnt := 0 @@ -357,12 +233,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 @@ -412,8 +288,8 @@ func TestMultiRequestDouble(t *testing.T) { for i := 1; i <= 3; i++ { msgs = append(msgs, mock.MsgWithContext{ Msg: &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), + SwIfIndex: interface_types.InterfaceIndex(i), + InterfaceName: "if-name-test", }, Multipart: true, SeqNum: 1, @@ -425,8 +301,8 @@ func TestMultiRequestDouble(t *testing.T) { msgs = append(msgs, mock.MsgWithContext{ Msg: &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), + SwIfIndex: interface_types.InterfaceIndex(i), + InterfaceName: "if-name-test", }, Multipart: true, SeqNum: 2, @@ -443,7 +319,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 +344,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,15 +357,22 @@ 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: &interfaces.SwInterfaceSetFlagsReply{}, + SeqNum: 3, + }, + ) - req := &tap.TapConnect{ - TapName: []byte("test-tap-name"), - UseRandomMac: 1, + req := &interfaces.SwInterfaceSetFlags{ + SwIfIndex: 1, + Flags: interface_types.IF_STATUS_API_FLAG_ADMIN_UP, } - reply := &tap.TapConnectReply{} + reply := &interfaces.SwInterfaceSetFlagsReply{} // should succeed err = ctx.ch.SendRequest(req).ReceiveReply(reply) @@ -508,8 +393,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 +407,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 @@ -540,8 +427,8 @@ func TestReceiveReplyAfterTimeoutMultiRequest(t *testing.T) { for i := 1; i <= 3; i++ { msgs = append(msgs, mock.MsgWithContext{ Msg: &interfaces.SwInterfaceDetails{ - SwIfIndex: uint32(i), - InterfaceName: []byte("if-name-test"), + SwIfIndex: interface_types.InterfaceIndex(i), + InterfaceName: "if-name-test", }, Multipart: true, SeqNum: 2, @@ -551,31 +438,33 @@ func TestReceiveReplyAfterTimeoutMultiRequest(t *testing.T) { ctx.mockVpp.MockReplyWithContext(msgs...) // normal reply for next request - ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &tap.TapConnectReply{}, SeqNum: 3}) + ctx.mockVpp.MockReplyWithContext(mock.MsgWithContext{Msg: &interfaces.SwInterfaceSetFlagsReply{}, SeqNum: 3}) - req := &tap.TapConnect{ - TapName: []byte("test-tap-name"), - UseRandomMac: 1, + req := &interfaces.SwInterfaceSetFlags{ + SwIfIndex: 1, + Flags: interface_types.IF_STATUS_API_FLAG_ADMIN_UP, } - reply := &tap.TapConnectReply{} + reply := &interfaces.SwInterfaceSetFlagsReply{} // should succeed err = ctx.ch.SendRequest(req).ReceiveReply(reply) 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")) -}*/ + Expect(err.Error()).To(ContainSubstring("unexpected message")) +}