go.ligato.io/vpp-agent/v3@v3.5.0/plugins/vpp/abfplugin/vppcalls/vpp2106/abf_vppcalls_test.go (about)

     1  //  Copyright (c) 2021 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 vpp2106
    16  
    17  import (
    18  	"net"
    19  	"testing"
    20  
    21  	. "github.com/onsi/gomega"
    22  	"go.ligato.io/cn-infra/v2/logging/logrus"
    23  
    24  	"go.ligato.io/vpp-agent/v3/plugins/vpp/abfplugin/vppcalls"
    25  	"go.ligato.io/vpp-agent/v3/plugins/vpp/aclplugin/aclidx"
    26  	vpp_abf "go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2106/abf"
    27  	"go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2106/ip_types"
    28  	"go.ligato.io/vpp-agent/v3/plugins/vpp/ifplugin/ifaceidx"
    29  	"go.ligato.io/vpp-agent/v3/plugins/vpp/vppmock"
    30  	abf "go.ligato.io/vpp-agent/v3/proto/ligato/vpp/abf"
    31  )
    32  
    33  func TestGetABFVersion(t *testing.T) {
    34  	ctx, abfHandler, _ := abfTestSetup(t)
    35  	defer ctx.TeardownTestCtx()
    36  
    37  	ctx.MockVpp.MockReply(&vpp_abf.AbfPluginGetVersionReply{
    38  		Major: 1,
    39  		Minor: 0,
    40  	})
    41  	version, err := abfHandler.GetAbfVersion()
    42  
    43  	Expect(err).To(BeNil())
    44  	Expect(version).To(Equal("1.0"))
    45  }
    46  
    47  func TestAddABFPolicy(t *testing.T) {
    48  	ctx, abfHandler, ifIndexes := abfTestSetup(t)
    49  	defer ctx.TeardownTestCtx()
    50  
    51  	ctx.MockVpp.MockReply(&vpp_abf.AbfPolicyAddDelReply{})
    52  
    53  	ifIndexes.Put("if1", &ifaceidx.IfaceMetadata{
    54  		SwIfIndex: 5,
    55  	})
    56  	ifIndexes.Put("if2", &ifaceidx.IfaceMetadata{
    57  		SwIfIndex: 10,
    58  	})
    59  
    60  	err := abfHandler.AddAbfPolicy(1, 2, []*abf.ABF_ForwardingPath{
    61  		{
    62  			InterfaceName: "if1",
    63  			NextHopIp:     "10.0.0.1",
    64  		},
    65  		{
    66  			InterfaceName: "if2",
    67  			NextHopIp:     "ffff::",
    68  		},
    69  	})
    70  
    71  	Expect(err).To(BeNil())
    72  	req, ok := ctx.MockChannel.Msg.(*vpp_abf.AbfPolicyAddDel)
    73  	Expect(ok).To(BeTrue())
    74  	Expect(req.IsAdd).To(BeTrue())
    75  	Expect(req.Policy.PolicyID).To(Equal(uint32(1)))
    76  	Expect(req.Policy.ACLIndex).To(Equal(uint32(2)))
    77  	Expect(req.Policy.NPaths).To(Equal(uint8(2)))
    78  	Expect(req.Policy.Paths[0].SwIfIndex).To(Equal(uint32(5)))
    79  	Expect(req.Policy.Paths[0].Nh.Address.GetIP4()).To(BeEquivalentTo(ip_types.IP4Address([4]uint8{10, 0, 0, 1})))
    80  	Expect(req.Policy.Paths[1].SwIfIndex).To(Equal(uint32(10)))
    81  	Expect(req.Policy.Paths[1].Nh.Address.GetIP6()).To(BeEquivalentTo(ip_types.IP6Address([16]uint8{255, 255})))
    82  }
    83  
    84  func TestAddABFPolicyError(t *testing.T) {
    85  	ctx, abfHandler, _ := abfTestSetup(t)
    86  	defer ctx.TeardownTestCtx()
    87  
    88  	ctx.MockVpp.MockReply(&vpp_abf.AbfPolicyAddDelReply{
    89  		Retval: 1,
    90  	})
    91  
    92  	err := abfHandler.AddAbfPolicy(1, 2, nil)
    93  
    94  	Expect(err).ToNot(BeNil())
    95  }
    96  
    97  func TestDeleteABFPolicy(t *testing.T) {
    98  	ctx, abfHandler, ifIndexes := abfTestSetup(t)
    99  	defer ctx.TeardownTestCtx()
   100  
   101  	ctx.MockVpp.MockReply(&vpp_abf.AbfPolicyAddDelReply{})
   102  
   103  	ifIndexes.Put("if1", &ifaceidx.IfaceMetadata{
   104  		SwIfIndex: 5,
   105  	})
   106  	ifIndexes.Put("if2", &ifaceidx.IfaceMetadata{
   107  		SwIfIndex: 10,
   108  	})
   109  
   110  	err := abfHandler.DeleteAbfPolicy(1, []*abf.ABF_ForwardingPath{
   111  		{
   112  			InterfaceName: "if1",
   113  			NextHopIp:     "10.0.0.1",
   114  		},
   115  		{
   116  			InterfaceName: "if2",
   117  			NextHopIp:     "ffff::",
   118  		},
   119  	})
   120  
   121  	Expect(err).To(BeNil())
   122  	req, ok := ctx.MockChannel.Msg.(*vpp_abf.AbfPolicyAddDel)
   123  	Expect(ok).To(BeTrue())
   124  	Expect(req.IsAdd).To(BeFalse())
   125  	Expect(req.Policy.PolicyID).To(Equal(uint32(1)))
   126  	Expect(req.Policy.NPaths).To(Equal(uint8(2)))
   127  	Expect(req.Policy.Paths[0].SwIfIndex).To(Equal(uint32(5)))
   128  	Expect(req.Policy.Paths[0].Nh.Address.XXX_UnionData[:4]).To(BeEquivalentTo(net.ParseIP("10.0.0.1").To4()))
   129  	Expect(req.Policy.Paths[1].SwIfIndex).To(Equal(uint32(10)))
   130  	Expect(req.Policy.Paths[1].Nh.Address.XXX_UnionData[:]).To(BeEquivalentTo(net.ParseIP("ffff::").To16()))
   131  }
   132  
   133  func TestDeleteABFPolicyError(t *testing.T) {
   134  	ctx, abfHandler, _ := abfTestSetup(t)
   135  	defer ctx.TeardownTestCtx()
   136  
   137  	ctx.MockVpp.MockReply(&vpp_abf.AbfPolicyAddDelReply{
   138  		Retval: 1,
   139  	})
   140  
   141  	err := abfHandler.DeleteAbfPolicy(1, nil)
   142  
   143  	Expect(err).ToNot(BeNil())
   144  }
   145  
   146  func TestAttachABFInterfaceIPv4(t *testing.T) {
   147  	ctx, abfHandler, _ := abfTestSetup(t)
   148  	defer ctx.TeardownTestCtx()
   149  
   150  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{})
   151  
   152  	err := abfHandler.AbfAttachInterfaceIPv4(1, 2, 3)
   153  
   154  	Expect(err).To(BeNil())
   155  	req, ok := ctx.MockChannel.Msg.(*vpp_abf.AbfItfAttachAddDel)
   156  	Expect(ok).To(BeTrue())
   157  	Expect(req.IsAdd).To(BeTrue())
   158  	Expect(req.Attach.PolicyID).To(Equal(uint32(1)))
   159  	Expect(req.Attach.SwIfIndex).To(BeEquivalentTo(uint32(2)))
   160  	Expect(req.Attach.Priority).To(Equal(uint32(3)))
   161  	Expect(req.Attach.IsIPv6).To(BeFalse())
   162  }
   163  
   164  func TestAttachABFInterfaceIPv4Error(t *testing.T) {
   165  	ctx, abfHandler, _ := abfTestSetup(t)
   166  	defer ctx.TeardownTestCtx()
   167  
   168  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{
   169  		Retval: -1,
   170  	})
   171  
   172  	err := abfHandler.AbfAttachInterfaceIPv4(1, 2, 3)
   173  
   174  	Expect(err).ToNot(BeNil())
   175  }
   176  
   177  func TestAttachABFInterfaceIPv6(t *testing.T) {
   178  	ctx, abfHandler, _ := abfTestSetup(t)
   179  	defer ctx.TeardownTestCtx()
   180  
   181  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{})
   182  
   183  	err := abfHandler.AbfAttachInterfaceIPv6(1, 2, 3)
   184  
   185  	Expect(err).To(BeNil())
   186  	req, ok := ctx.MockChannel.Msg.(*vpp_abf.AbfItfAttachAddDel)
   187  	Expect(ok).To(BeTrue())
   188  	Expect(req.IsAdd).To(BeTrue())
   189  	Expect(req.Attach.PolicyID).To(Equal(uint32(1)))
   190  	Expect(req.Attach.SwIfIndex).To(BeEquivalentTo(uint32(2)))
   191  	Expect(req.Attach.Priority).To(Equal(uint32(3)))
   192  	Expect(req.Attach.IsIPv6).To(BeTrue())
   193  }
   194  
   195  func TestAttachABFInterfaceIPv6Error(t *testing.T) {
   196  	ctx, abfHandler, _ := abfTestSetup(t)
   197  	defer ctx.TeardownTestCtx()
   198  
   199  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{
   200  		Retval: -1,
   201  	})
   202  
   203  	err := abfHandler.AbfAttachInterfaceIPv6(1, 2, 3)
   204  
   205  	Expect(err).ToNot(BeNil())
   206  }
   207  
   208  func TestDetachABFInterfaceIPv4(t *testing.T) {
   209  	ctx, abfHandler, _ := abfTestSetup(t)
   210  	defer ctx.TeardownTestCtx()
   211  
   212  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{})
   213  
   214  	err := abfHandler.AbfDetachInterfaceIPv4(1, 2, 3)
   215  
   216  	Expect(err).To(BeNil())
   217  	req, ok := ctx.MockChannel.Msg.(*vpp_abf.AbfItfAttachAddDel)
   218  	Expect(ok).To(BeTrue())
   219  	Expect(req.IsAdd).To(BeFalse())
   220  	Expect(req.Attach.PolicyID).To(Equal(uint32(1)))
   221  	Expect(req.Attach.SwIfIndex).To(BeEquivalentTo(uint32(2)))
   222  	Expect(req.Attach.Priority).To(Equal(uint32(3)))
   223  	Expect(req.Attach.IsIPv6).To(BeFalse())
   224  }
   225  
   226  func TestDetachABFInterfaceIPv4Error(t *testing.T) {
   227  	ctx, abfHandler, _ := abfTestSetup(t)
   228  	defer ctx.TeardownTestCtx()
   229  
   230  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{
   231  		Retval: -1,
   232  	})
   233  
   234  	err := abfHandler.AbfDetachInterfaceIPv4(1, 2, 3)
   235  
   236  	Expect(err).ToNot(BeNil())
   237  }
   238  
   239  func TestDetachABFInterfaceIPv6(t *testing.T) {
   240  	ctx, abfHandler, _ := abfTestSetup(t)
   241  	defer ctx.TeardownTestCtx()
   242  
   243  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{})
   244  
   245  	err := abfHandler.AbfDetachInterfaceIPv6(1, 2, 3)
   246  
   247  	Expect(err).To(BeNil())
   248  	req, ok := ctx.MockChannel.Msg.(*vpp_abf.AbfItfAttachAddDel)
   249  	Expect(ok).To(BeTrue())
   250  	Expect(req.IsAdd).To(BeFalse())
   251  	Expect(req.Attach.PolicyID).To(Equal(uint32(1)))
   252  	Expect(req.Attach.SwIfIndex).To(BeEquivalentTo(uint32(2)))
   253  	Expect(req.Attach.Priority).To(Equal(uint32(3)))
   254  	Expect(req.Attach.IsIPv6).To(BeTrue())
   255  }
   256  
   257  func TestDetachABFInterfaceIPv6Error(t *testing.T) {
   258  	ctx, abfHandler, _ := abfTestSetup(t)
   259  	defer ctx.TeardownTestCtx()
   260  
   261  	ctx.MockVpp.MockReply(&vpp_abf.AbfItfAttachAddDelReply{
   262  		Retval: -1,
   263  	})
   264  
   265  	err := abfHandler.AbfDetachInterfaceIPv6(1, 2, 3)
   266  
   267  	Expect(err).ToNot(BeNil())
   268  }
   269  
   270  func abfTestSetup(t *testing.T) (*vppmock.TestCtx, vppcalls.ABFVppAPI, ifaceidx.IfaceMetadataIndexRW) {
   271  	ctx := vppmock.SetupTestCtx(t)
   272  	log := logrus.NewLogger("test-log")
   273  	aclIdx := aclidx.NewACLIndex(log, "acl-index")
   274  	ifIdx := ifaceidx.NewIfaceIndex(log, "if-index")
   275  	abfHandler := NewABFVppHandler(ctx.MockChannel, aclIdx, ifIdx, log)
   276  	return ctx, abfHandler, ifIdx
   277  }