core/core_test.go

   1 // Copyright (c) 2017 Cisco and/or its affiliates.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at:
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 package core
  16
  17 import (
  18         "testing"
  19
  20         "gerrit.fd.io/r/govpp/adapter/mock"
  21         "gerrit.fd.io/r/govpp/api"
  22         "gerrit.fd.io/r/govpp/core/bin_api/vpe"
  23         "gerrit.fd.io/r/govpp/examples/bin_api/interfaces"
  24
  25         . "github.com/onsi/gomega"
  26 )
  27
  28 type testCtx struct {
  29         mockVpp *mock.VppAdapter
  30         conn    *Connection
  31         ch      *api.Channel
  32 }
  33
  34 func setupTest(t *testing.T) *testCtx {
  35         RegisterTestingT(t)
  36
  37         ctx := &testCtx{}
  38         ctx.mockVpp = &mock.VppAdapter{}
  39
  40         var err error
  41         ctx.conn, err = Connect(ctx.mockVpp)
  42         Expect(err).ShouldNot(HaveOccurred())
  43
  44         ctx.ch, err = ctx.conn.NewAPIChannel()
  45         Expect(err).ShouldNot(HaveOccurred())
  46
  47         return ctx
  48 }
  49
  50 func (ctx *testCtx) teardownTest() {
  51         ctx.ch.Close()
  52         ctx.conn.Disconnect()
  53 }
  54
  55 func TestSimpleRequest(t *testing.T) {
  56         ctx := setupTest(t)
  57         defer ctx.teardownTest()
  58
  59         ctx.mockVpp.MockReply(&vpe.ControlPingReply{Retval: -5})
  60
  61         req := &vpe.ControlPing{}
  62         reply := &vpe.ControlPingReply{}
  63
  64         // send the request and receive a reply
  65         ctx.ch.ReqChan <- &api.VppRequest{Message: req}
  66         vppReply := <-ctx.ch.ReplyChan
  67
  68         Expect(vppReply).ShouldNot(BeNil())
  69         Expect(vppReply.Error).ShouldNot(HaveOccurred())
  70
  71         // decode the message
  72         err := ctx.ch.MsgDecoder.DecodeMsg(vppReply.Data, reply)
  73         Expect(err).ShouldNot(HaveOccurred())
  74
  75         Expect(reply.Retval).To(BeEquivalentTo(-5))
  76 }
  77
  78 func TestMultiRequest(t *testing.T) {
  79         ctx := setupTest(t)
  80         defer ctx.teardownTest()
  81
  82         for m := 0; m < 10; m++ {
  83                 ctx.mockVpp.MockReply(&interfaces.SwInterfaceDetails{})
  84         }
  85         ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
  86
  87         // send multipart request
  88         ctx.ch.ReqChan <- &api.VppRequest{Message: &interfaces.SwInterfaceDump{}, Multipart: true}
  89
  90         cnt := 0
  91         for {
  92                 // receive a reply
  93                 vppReply := <-ctx.ch.ReplyChan
  94                 if vppReply.LastReplyReceived {
  95                         break // break out of the loop
  96                 }
  97                 Expect(vppReply.Error).ShouldNot(HaveOccurred())
  98
  99                 // decode the message
 100                 reply := &interfaces.SwInterfaceDetails{}
 101                 err := ctx.ch.MsgDecoder.DecodeMsg(vppReply.Data, reply)
 102                 Expect(err).ShouldNot(HaveOccurred())
 103                 cnt++
 104         }
 105
 106         Expect(cnt).To(BeEquivalentTo(10))
 107 }
 108
 109 func TestNotifications(t *testing.T) {
 110         ctx := setupTest(t)
 111         defer ctx.teardownTest()
 112
 113         // subscribe for notification
 114         notifChan := make(chan api.Message, 1)
 115         subscription := &api.NotifSubscription{
 116                 NotifChan:  notifChan,
 117                 MsgFactory: interfaces.NewSwInterfaceSetFlags,
 118         }
 119         ctx.ch.NotifSubsChan <- &api.NotifSubscribeRequest{
 120                 Subscription: subscription,
 121                 Subscribe:    true,
 122         }
 123         err := <-ctx.ch.NotifSubsReplyChan
 124         Expect(err).ShouldNot(HaveOccurred())
 125
 126         // mock the notification and force its delivery
 127         ctx.mockVpp.MockReply(&interfaces.SwInterfaceSetFlags{
 128                 SwIfIndex:   3,
 129                 AdminUpDown: 1,
 130         })
 131         ctx.mockVpp.SendMsg(0, []byte{0})
 132
 133         // receive the notification
 134         notif := (<-notifChan).(*interfaces.SwInterfaceSetFlags)
 135
 136         Expect(notif.SwIfIndex).To(BeEquivalentTo(3))
 137
 138         // unsubscribe notification
 139         ctx.ch.NotifSubsChan <- &api.NotifSubscribeRequest{
 140                 Subscription: subscription,
 141                 Subscribe:    false,
 142         }
 143         err = <-ctx.ch.NotifSubsReplyChan
 144         Expect(err).ShouldNot(HaveOccurred())
 145 }
 146
 147 func TestDoubleConnection(t *testing.T) {
 148         ctx := setupTest(t)
 149         defer ctx.teardownTest()
 150
 151         conn, err := Connect(ctx.mockVpp)
 152         Expect(err).Should(HaveOccurred())
 153         Expect(err.Error()).To(ContainSubstring("only one connection per process"))
 154         Expect(conn).Should(BeNil())
 155 }
 156
 157 func TestFullBuffer(t *testing.T) {
 158         ctx := setupTest(t)
 159         defer ctx.teardownTest()
 160
 161         // close the default API channel
 162         ctx.ch.Close()
 163
 164         // create a new channel with limited buffer sizes
 165         var err error
 166         ctx.ch, err = ctx.conn.NewAPIChannelBuffered(10, 1)
 167         Expect(err).ShouldNot(HaveOccurred())
 168
 169         // send multiple requests, only one reply should be read
 170         for i := 0; i < 20; i++ {
 171                 ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
 172                 ctx.ch.ReqChan <- &api.VppRequest{Message: &vpe.ControlPing{}}
 173         }
 174
 175         vppReply := <-ctx.ch.ReplyChan
 176         Expect(vppReply).ShouldNot(BeNil())
 177
 178         received := false
 179         select {
 180         case vppReply = <-ctx.ch.ReplyChan:
 181                 received = true // this should not happen
 182         default:
 183                 received = false // no reply to be received
 184         }
 185         Expect(received).Should(BeFalse(), "A reply has been recieved, should had been ignored.")
 186 }
 187
 188 func TestCodec(t *testing.T) {
 189         RegisterTestingT(t)
 190
 191         codec := &MsgCodec{}
 192
 193         // request
 194         data, err := codec.EncodeMsg(&vpe.CreateLoopback{MacAddress: []byte{1, 2, 3, 4, 5, 6}}, 11)
 195         Expect(err).ShouldNot(HaveOccurred())
 196         Expect(data).ShouldNot(BeEmpty())
 197
 198         msg1 := &vpe.CreateLoopback{}
 199         err = codec.DecodeMsg(data, msg1)
 200         Expect(err).ShouldNot(HaveOccurred())
 201         Expect(msg1.MacAddress).To(BeEquivalentTo([]byte{1, 2, 3, 4, 5, 6}))
 202
 203         // reply
 204         data, err = codec.EncodeMsg(&vpe.ControlPingReply{Retval: 55}, 22)
 205         Expect(err).ShouldNot(HaveOccurred())
 206         Expect(data).ShouldNot(BeEmpty())
 207
 208         msg2 := &vpe.ControlPingReply{}
 209         err = codec.DecodeMsg(data, msg2)
 210         Expect(err).ShouldNot(HaveOccurred())
 211         Expect(msg2.Retval).To(BeEquivalentTo(55))
 212
 213         // other
 214         data, err = codec.EncodeMsg(&vpe.VnetIP4FibCounters{VrfID: 77}, 33)
 215         Expect(err).ShouldNot(HaveOccurred())
 216         Expect(data).ShouldNot(BeEmpty())
 217
 218         msg3 := &vpe.VnetIP4FibCounters{}
 219         err = codec.DecodeMsg(data, msg3)
 220         Expect(err).ShouldNot(HaveOccurred())
 221         Expect(msg3.VrfID).To(BeEquivalentTo(77))
 222 }
 223
 224 func TestCodecNegative(t *testing.T) {
 225         RegisterTestingT(t)
 226
 227         codec := &MsgCodec{}
 228
 229         // nil message for encoding
 230         data, err := codec.EncodeMsg(nil, 15)
 231         Expect(err).Should(HaveOccurred())
 232         Expect(err.Error()).To(ContainSubstring("nil message"))
 233         Expect(data).Should(BeNil())
 234
 235         // nil message for decoding
 236         err = codec.DecodeMsg(data, nil)
 237         Expect(err).Should(HaveOccurred())
 238         Expect(err.Error()).To(ContainSubstring("nil message"))
 239
 240         // nil data for decoding
 241         err = codec.DecodeMsg(nil, &vpe.ControlPingReply{})
 242         Expect(err).Should(HaveOccurred())
 243         Expect(err.Error()).To(ContainSubstring("EOF"))
 244 }