go.ligato.io/vpp-agent/v3@v3.5.0/plugins/vpp/natplugin/vppcalls/vpp2210/nat_vppcalls_test.go (about)

     1  //  Copyright (c) 2022 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 vpp2210_test
    16  
    17  import (
    18  	"bytes"
    19  	"net"
    20  	"testing"
    21  
    22  	"go.ligato.io/vpp-agent/v3/plugins/vpp/natplugin/vppcalls"
    23  	"go.ligato.io/vpp-agent/v3/plugins/vpp/natplugin/vppcalls/vpp2210"
    24  
    25  	. "github.com/onsi/gomega"
    26  
    27  	"go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2210/ip_types"
    28  	vpp_nat_ed "go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2210/nat44_ed"
    29  	vpp_nat_ei "go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2210/nat44_ei"
    30  	"go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2210/nat_types"
    31  	"go.ligato.io/vpp-agent/v3/plugins/vpp/ifplugin/ifaceidx"
    32  	nat "go.ligato.io/vpp-agent/v3/proto/ligato/vpp/nat"
    33  )
    34  
    35  func TestSetNat44EdForwarding(t *testing.T) {
    36  	ctx, natHandler, _, _ := natTestSetup(t)
    37  	defer ctx.TeardownTestCtx()
    38  
    39  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
    40  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
    41  	Expect(err).ShouldNot(HaveOccurred())
    42  
    43  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44ForwardingEnableDisableReply{})
    44  	err = natHandler.SetNat44Forwarding(true)
    45  
    46  	Expect(err).ShouldNot(HaveOccurred())
    47  
    48  	t.Logf("Msg: %+v (%#v)", ctx.MockChannel.Msg, ctx.MockChannel.Msg)
    49  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44ForwardingEnableDisable)
    50  	Expect(ok).To(BeTrue())
    51  	Expect(msg).ToNot(BeNil())
    52  	Expect(msg.Enable).To(BeTrue())
    53  }
    54  
    55  func TestSetNat44EiForwarding(t *testing.T) {
    56  	ctx, natHandler, _, _ := natTestSetup(t)
    57  	defer ctx.TeardownTestCtx()
    58  
    59  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
    60  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
    61  	Expect(err).ShouldNot(HaveOccurred())
    62  
    63  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiForwardingEnableDisableReply{})
    64  	err = natHandler.SetNat44Forwarding(true)
    65  
    66  	Expect(err).ShouldNot(HaveOccurred())
    67  
    68  	t.Logf("Msg: %+v (%#v)", ctx.MockChannel.Msg, ctx.MockChannel.Msg)
    69  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiForwardingEnableDisable)
    70  	Expect(ok).To(BeTrue())
    71  	Expect(msg).ToNot(BeNil())
    72  	Expect(msg.Enable).To(BeTrue())
    73  }
    74  
    75  func TestUnsetNat44EdForwarding(t *testing.T) {
    76  	ctx, natHandler, _, _ := natTestSetup(t)
    77  	defer ctx.TeardownTestCtx()
    78  
    79  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
    80  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
    81  	Expect(err).ShouldNot(HaveOccurred())
    82  
    83  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44ForwardingEnableDisableReply{})
    84  	err = natHandler.SetNat44Forwarding(false)
    85  
    86  	Expect(err).ShouldNot(HaveOccurred())
    87  
    88  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44ForwardingEnableDisable)
    89  	Expect(ok).To(BeTrue())
    90  	Expect(msg).ToNot(BeNil())
    91  	Expect(msg.Enable).To(BeFalse())
    92  }
    93  
    94  func TestUnsetNat44EiForwarding(t *testing.T) {
    95  	ctx, natHandler, _, _ := natTestSetup(t)
    96  	defer ctx.TeardownTestCtx()
    97  
    98  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
    99  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   100  	Expect(err).ShouldNot(HaveOccurred())
   101  
   102  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiForwardingEnableDisableReply{})
   103  	err = natHandler.SetNat44Forwarding(false)
   104  
   105  	Expect(err).ShouldNot(HaveOccurred())
   106  
   107  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiForwardingEnableDisable)
   108  	Expect(ok).To(BeTrue())
   109  	Expect(msg).ToNot(BeNil())
   110  	Expect(msg.Enable).To(BeFalse())
   111  }
   112  
   113  func TestSetNat44EdForwardingError(t *testing.T) {
   114  	ctx, natHandler, _, _ := natTestSetup(t)
   115  	defer ctx.TeardownTestCtx()
   116  
   117  	// Incorrect reply object
   118  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
   119  	err := natHandler.SetNat44Forwarding(true)
   120  
   121  	Expect(err).Should(HaveOccurred())
   122  }
   123  
   124  func TestSetNat44EiForwardingError(t *testing.T) {
   125  	ctx, natHandler, _, _ := natTestSetup(t)
   126  	defer ctx.TeardownTestCtx()
   127  
   128  	// Incorrect reply object
   129  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
   130  	err := natHandler.SetNat44Forwarding(true)
   131  
   132  	Expect(err).Should(HaveOccurred())
   133  }
   134  
   135  func TestSetNat44EdForwardingRetval(t *testing.T) {
   136  	ctx, natHandler, _, _ := natTestSetup(t)
   137  	defer ctx.TeardownTestCtx()
   138  
   139  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   140  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   141  	Expect(err).ShouldNot(HaveOccurred())
   142  
   143  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44ForwardingEnableDisableReply{
   144  		Retval: 1,
   145  	})
   146  	err = natHandler.SetNat44Forwarding(true)
   147  
   148  	Expect(err).Should(HaveOccurred())
   149  }
   150  
   151  func TestSetNat44EiForwardingRetval(t *testing.T) {
   152  	ctx, natHandler, _, _ := natTestSetup(t)
   153  	defer ctx.TeardownTestCtx()
   154  
   155  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   156  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   157  	Expect(err).ShouldNot(HaveOccurred())
   158  
   159  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiForwardingEnableDisableReply{
   160  		Retval: 1,
   161  	})
   162  	err = natHandler.SetNat44Forwarding(true)
   163  
   164  	Expect(err).Should(HaveOccurred())
   165  }
   166  
   167  func TestEnableNat44EdInterfaceAsInside(t *testing.T) {
   168  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   169  	defer ctx.TeardownTestCtx()
   170  
   171  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   172  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   173  	Expect(err).ShouldNot(HaveOccurred())
   174  
   175  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   176  
   177  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   178  	err = natHandler.EnableNat44Interface("if0", true, false)
   179  
   180  	Expect(err).ShouldNot(HaveOccurred())
   181  
   182  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   183  	Expect(ok).To(BeTrue())
   184  	Expect(msg).ToNot(BeNil())
   185  	Expect(msg.IsAdd).To(BeTrue())
   186  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_INSIDE))
   187  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   188  }
   189  
   190  func TestEnableNat44EiInterfaceAsInside(t *testing.T) {
   191  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   192  	defer ctx.TeardownTestCtx()
   193  
   194  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   195  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   196  	Expect(err).ShouldNot(HaveOccurred())
   197  
   198  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   199  
   200  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   201  	err = natHandler.EnableNat44Interface("if0", true, false)
   202  
   203  	Expect(err).ShouldNot(HaveOccurred())
   204  
   205  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   206  	Expect(ok).To(BeTrue())
   207  	Expect(msg).ToNot(BeNil())
   208  	Expect(msg.IsAdd).To(BeTrue())
   209  	Expect(msg.Flags).To(BeEquivalentTo(vpp_nat_ei.NAT44_EI_IF_INSIDE))
   210  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   211  }
   212  
   213  func TestEnableNat44EdInterfaceAsOutside(t *testing.T) {
   214  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   215  	defer ctx.TeardownTestCtx()
   216  
   217  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   218  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   219  	Expect(err).ShouldNot(HaveOccurred())
   220  
   221  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   222  
   223  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   224  	err = natHandler.EnableNat44Interface("if1", false, false)
   225  
   226  	Expect(err).ShouldNot(HaveOccurred())
   227  
   228  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   229  	Expect(ok).To(BeTrue())
   230  	Expect(msg).ToNot(BeNil())
   231  	Expect(msg.IsAdd).To(BeTrue())
   232  	Expect(msg.Flags).To(BeEquivalentTo(0))
   233  	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   234  }
   235  
   236  func TestEnableNat44EiInterfaceAsOutside(t *testing.T) {
   237  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   238  	defer ctx.TeardownTestCtx()
   239  
   240  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   241  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   242  	Expect(err).ShouldNot(HaveOccurred())
   243  
   244  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   245  
   246  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   247  	err = natHandler.EnableNat44Interface("if1", false, false)
   248  
   249  	Expect(err).ShouldNot(HaveOccurred())
   250  
   251  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   252  	Expect(ok).To(BeTrue())
   253  	Expect(msg).ToNot(BeNil())
   254  	Expect(msg.IsAdd).To(BeTrue())
   255  	Expect(msg.Flags).To(BeEquivalentTo(0))
   256  	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   257  }
   258  
   259  func TestEnableNat44EdInterfaceError(t *testing.T) {
   260  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   261  	defer ctx.TeardownTestCtx()
   262  
   263  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   264  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   265  	Expect(err).ShouldNot(HaveOccurred())
   266  
   267  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   268  
   269  	// Incorrect reply object
   270  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelAddressRangeReply{})
   271  	err = natHandler.EnableNat44Interface("if1", false, false)
   272  
   273  	Expect(err).Should(HaveOccurred())
   274  }
   275  
   276  func TestEnableNat44EiInterfaceError(t *testing.T) {
   277  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   278  	defer ctx.TeardownTestCtx()
   279  
   280  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   281  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   282  	Expect(err).ShouldNot(HaveOccurred())
   283  
   284  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   285  
   286  	// Incorrect reply object
   287  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelAddressRangeReply{})
   288  	err = natHandler.EnableNat44Interface("if1", false, false)
   289  
   290  	Expect(err).Should(HaveOccurred())
   291  }
   292  
   293  func TestEnableNat44EdInterfaceRetval(t *testing.T) {
   294  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   295  	defer ctx.TeardownTestCtx()
   296  
   297  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   298  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   299  	Expect(err).ShouldNot(HaveOccurred())
   300  
   301  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   302  
   303  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{
   304  		Retval: 1,
   305  	})
   306  	err = natHandler.EnableNat44Interface("if1", false, false)
   307  
   308  	Expect(err).Should(HaveOccurred())
   309  }
   310  
   311  func TestEnableNat44EiInterfaceRetval(t *testing.T) {
   312  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   313  	defer ctx.TeardownTestCtx()
   314  
   315  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   316  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   317  	Expect(err).ShouldNot(HaveOccurred())
   318  
   319  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   320  
   321  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{
   322  		Retval: 1,
   323  	})
   324  	err = natHandler.EnableNat44Interface("if1", false, false)
   325  
   326  	Expect(err).Should(HaveOccurred())
   327  }
   328  
   329  func TestDisableNat44EdInterfaceAsInside(t *testing.T) {
   330  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   331  	defer ctx.TeardownTestCtx()
   332  
   333  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   334  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   335  	Expect(err).ShouldNot(HaveOccurred())
   336  
   337  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   338  
   339  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   340  	err = natHandler.DisableNat44Interface("if0", true, false)
   341  
   342  	Expect(err).ShouldNot(HaveOccurred())
   343  
   344  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   345  	Expect(ok).To(BeTrue())
   346  	Expect(msg).ToNot(BeNil())
   347  	Expect(msg.IsAdd).To(BeFalse())
   348  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_INSIDE))
   349  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   350  }
   351  
   352  func TestDisableNat44EiInterfaceAsInside(t *testing.T) {
   353  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   354  	defer ctx.TeardownTestCtx()
   355  
   356  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   357  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   358  	Expect(err).ShouldNot(HaveOccurred())
   359  
   360  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   361  
   362  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   363  	err = natHandler.DisableNat44Interface("if0", true, false)
   364  
   365  	Expect(err).ShouldNot(HaveOccurred())
   366  
   367  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   368  	Expect(ok).To(BeTrue())
   369  	Expect(msg).ToNot(BeNil())
   370  	Expect(msg.IsAdd).To(BeFalse())
   371  	Expect(msg.Flags).To(BeEquivalentTo(vpp_nat_ei.NAT44_EI_IF_INSIDE))
   372  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   373  }
   374  
   375  func TestDisableNat44EdInterfaceAsOutside(t *testing.T) {
   376  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   377  	defer ctx.TeardownTestCtx()
   378  
   379  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   380  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   381  	Expect(err).ShouldNot(HaveOccurred())
   382  
   383  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   384  
   385  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   386  	err = natHandler.DisableNat44Interface("if1", false, false)
   387  
   388  	Expect(err).ShouldNot(HaveOccurred())
   389  
   390  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   391  	Expect(ok).To(BeTrue())
   392  	Expect(msg).ToNot(BeNil())
   393  	Expect(msg.IsAdd).To(BeFalse())
   394  	Expect(msg.Flags).To(BeEquivalentTo(0))
   395  	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   396  }
   397  
   398  func TestDisableNat44EiInterfaceAsOutside(t *testing.T) {
   399  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   400  	defer ctx.TeardownTestCtx()
   401  
   402  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   403  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   404  	Expect(err).ShouldNot(HaveOccurred())
   405  
   406  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   407  
   408  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   409  	err = natHandler.DisableNat44Interface("if1", false, false)
   410  
   411  	Expect(err).ShouldNot(HaveOccurred())
   412  
   413  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   414  	Expect(ok).To(BeTrue())
   415  	Expect(msg).ToNot(BeNil())
   416  	Expect(msg.IsAdd).To(BeFalse())
   417  	Expect(msg.Flags).To(BeEquivalentTo(0))
   418  	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   419  }
   420  
   421  func TestEnableNat44EdInterfaceOutputError(t *testing.T) {
   422  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   423  	defer ctx.TeardownTestCtx()
   424  
   425  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   426  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   427  	Expect(err).ShouldNot(HaveOccurred())
   428  
   429  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   430  
   431  	// Incorrect reply object
   432  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
   433  	err = natHandler.EnableNat44Interface("if1", false, true)
   434  
   435  	Expect(err).Should(HaveOccurred())
   436  }
   437  
   438  func TestEnableNat44InterfaceOutputError(t *testing.T) {
   439  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   440  	defer ctx.TeardownTestCtx()
   441  
   442  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   443  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   444  	Expect(err).ShouldNot(HaveOccurred())
   445  
   446  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   447  
   448  	// Incorrect reply object
   449  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
   450  	err = natHandler.EnableNat44Interface("if1", false, true)
   451  
   452  	Expect(err).Should(HaveOccurred())
   453  }
   454  
   455  func TestEnableNat44EdInterfaceOutputRetval(t *testing.T) {
   456  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   457  	defer ctx.TeardownTestCtx()
   458  
   459  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   460  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   461  	Expect(err).ShouldNot(HaveOccurred())
   462  
   463  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   464  
   465  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{
   466  		Retval: 1,
   467  	})
   468  	err = natHandler.EnableNat44Interface("if1", false, true)
   469  
   470  	Expect(err).Should(HaveOccurred())
   471  }
   472  
   473  func TestEnableNat44EiInterfaceOutputRetval(t *testing.T) {
   474  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   475  	defer ctx.TeardownTestCtx()
   476  
   477  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   478  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   479  	Expect(err).ShouldNot(HaveOccurred())
   480  
   481  	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   482  
   483  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelOutputInterfaceReply{
   484  		Retval: 1,
   485  	})
   486  	err = natHandler.EnableNat44Interface("if1", false, true)
   487  
   488  	Expect(err).Should(HaveOccurred())
   489  }
   490  
   491  // FIXME: The following commented out tests seem to no longer make sense in
   492  // VPP >= 22.10. If that is indeed the case (verify it), then delete them, else
   493  // adapt them to the new VPP.
   494  // func TestEnableNat44EdInterfaceOutputAsInside(t *testing.T) {
   495  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   496  // 	defer ctx.TeardownTestCtx()
   497  
   498  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   499  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   500  // 	Expect(err).ShouldNot(HaveOccurred())
   501  
   502  // 	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   503  
   504  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   505  // 	err = natHandler.EnableNat44Interface("if0", true, true)
   506  
   507  // 	Expect(err).ShouldNot(HaveOccurred())
   508  
   509  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   510  // 	Expect(ok).To(BeTrue())
   511  // 	Expect(msg).ToNot(BeNil())
   512  // 	Expect(msg.IsAdd).To(BeTrue())
   513  // 	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_INSIDE))
   514  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   515  // }
   516  
   517  // func TestEnableNat44EiInterfaceOutputAsInside(t *testing.T) {
   518  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   519  // 	defer ctx.TeardownTestCtx()
   520  
   521  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   522  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   523  // 	Expect(err).ShouldNot(HaveOccurred())
   524  
   525  // 	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   526  
   527  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   528  // 	err = natHandler.EnableNat44Interface("if0", true, true)
   529  
   530  // 	Expect(err).ShouldNot(HaveOccurred())
   531  
   532  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   533  // 	Expect(ok).To(BeTrue())
   534  // 	Expect(msg).ToNot(BeNil())
   535  // 	Expect(msg.IsAdd).To(BeTrue())
   536  // 	Expect(msg.Flags).To(BeEquivalentTo(vpp_nat_ei.NAT44_EI_IF_INSIDE))
   537  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   538  // }
   539  
   540  // func TestEnableNat44EdInterfaceOutputAsOutside(t *testing.T) {
   541  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   542  // 	defer ctx.TeardownTestCtx()
   543  
   544  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   545  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   546  // 	Expect(err).ShouldNot(HaveOccurred())
   547  
   548  // 	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   549  
   550  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   551  // 	err = natHandler.EnableNat44Interface("if1", false, true)
   552  
   553  // 	Expect(err).ShouldNot(HaveOccurred())
   554  
   555  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   556  // 	Expect(ok).To(BeTrue())
   557  // 	Expect(msg).ToNot(BeNil())
   558  // 	Expect(msg.IsAdd).To(BeTrue())
   559  // 	Expect(msg.Flags).To(BeEquivalentTo(0))
   560  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   561  // }
   562  
   563  // func TestEnableNat44EiInterfaceOutputAsOutside(t *testing.T) {
   564  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   565  // 	defer ctx.TeardownTestCtx()
   566  
   567  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   568  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   569  // 	Expect(err).ShouldNot(HaveOccurred())
   570  
   571  // 	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   572  
   573  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   574  // 	err = natHandler.EnableNat44Interface("if1", false, true)
   575  
   576  // 	Expect(err).ShouldNot(HaveOccurred())
   577  
   578  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   579  // 	Expect(ok).To(BeTrue())
   580  // 	Expect(msg).ToNot(BeNil())
   581  // 	Expect(msg.IsAdd).To(BeTrue())
   582  // 	Expect(msg.Flags).To(BeEquivalentTo(0))
   583  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   584  // }
   585  
   586  // func TestDisableNat44EdInterfaceOutputAsInside(t *testing.T) {
   587  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   588  // 	defer ctx.TeardownTestCtx()
   589  
   590  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   591  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   592  // 	Expect(err).ShouldNot(HaveOccurred())
   593  
   594  // 	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   595  
   596  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   597  // 	err = natHandler.DisableNat44Interface("if0", true, true)
   598  
   599  // 	Expect(err).ShouldNot(HaveOccurred())
   600  
   601  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   602  // 	Expect(ok).To(BeTrue())
   603  // 	Expect(msg).ToNot(BeNil())
   604  // 	Expect(msg.IsAdd).To(BeFalse())
   605  // 	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_INSIDE))
   606  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   607  // }
   608  
   609  // func TestDisableNat44EiInterfaceOutputAsInside(t *testing.T) {
   610  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   611  // 	defer ctx.TeardownTestCtx()
   612  
   613  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   614  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   615  // 	Expect(err).ShouldNot(HaveOccurred())
   616  
   617  // 	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   618  
   619  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   620  // 	err = natHandler.DisableNat44Interface("if0", true, true)
   621  
   622  // 	Expect(err).ShouldNot(HaveOccurred())
   623  
   624  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   625  // 	Expect(ok).To(BeTrue())
   626  // 	Expect(msg).ToNot(BeNil())
   627  // 	Expect(msg.IsAdd).To(BeFalse())
   628  // 	Expect(msg.Flags).To(BeEquivalentTo(vpp_nat_ei.NAT44_EI_IF_INSIDE))
   629  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
   630  // }
   631  
   632  // func TestDisableNat44EdInterfaceOutputAsOutside(t *testing.T) {
   633  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   634  // 	defer ctx.TeardownTestCtx()
   635  
   636  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   637  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   638  // 	Expect(err).ShouldNot(HaveOccurred())
   639  
   640  // 	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   641  
   642  // 	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44InterfaceAddDelFeatureReply{})
   643  // 	err = natHandler.DisableNat44Interface("if1", false, true)
   644  
   645  // 	Expect(err).ShouldNot(HaveOccurred())
   646  
   647  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44InterfaceAddDelFeature)
   648  // 	Expect(ok).To(BeTrue())
   649  // 	Expect(msg).ToNot(BeNil())
   650  // 	Expect(msg.IsAdd).To(BeFalse())
   651  // 	Expect(msg.Flags).To(BeEquivalentTo(0))
   652  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   653  // }
   654  
   655  // func TestDisableNat44EiInterfaceOutputAsOutside(t *testing.T) {
   656  // 	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   657  // 	defer ctx.TeardownTestCtx()
   658  
   659  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   660  // 	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   661  // 	Expect(err).ShouldNot(HaveOccurred())
   662  
   663  // 	swIfIndexes.Put("if1", &ifaceidx.IfaceMetadata{SwIfIndex: 2})
   664  
   665  // 	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiInterfaceAddDelFeatureReply{})
   666  // 	err = natHandler.DisableNat44Interface("if1", false, true)
   667  
   668  // 	Expect(err).ShouldNot(HaveOccurred())
   669  
   670  // 	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiInterfaceAddDelFeature)
   671  // 	Expect(ok).To(BeTrue())
   672  // 	Expect(msg).ToNot(BeNil())
   673  // 	Expect(msg.IsAdd).To(BeFalse())
   674  // 	Expect(msg.Flags).To(BeEquivalentTo(0))
   675  // 	Expect(msg.SwIfIndex).To(BeEquivalentTo(2))
   676  // }
   677  
   678  func TestAddNat44EdAddressPool(t *testing.T) {
   679  	ctx, natHandler, _, _ := natTestSetup(t)
   680  	defer ctx.TeardownTestCtx()
   681  
   682  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   683  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   684  	Expect(err).ShouldNot(HaveOccurred())
   685  
   686  	addr1 := net.ParseIP("10.0.0.1").To4()
   687  	addr2 := net.ParseIP("10.0.0.10").To4()
   688  
   689  	// first IP only
   690  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelAddressRangeReply{})
   691  	err = natHandler.AddNat44AddressPool(0, addr1.String(), "", false)
   692  	Expect(err).ShouldNot(HaveOccurred())
   693  
   694  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelAddressRange)
   695  	Expect(ok).To(BeTrue())
   696  	Expect(msg.IsAdd).To(BeTrue())
   697  	Expect(addressTo4IP(msg.FirstIPAddress)).To(BeEquivalentTo(addr1.String()))
   698  	Expect(addressTo4IP(msg.LastIPAddress)).To(BeEquivalentTo(addr1.String()))
   699  	Expect(msg.VrfID).To(BeEquivalentTo(0))
   700  	Expect(msg.Flags).To(BeEquivalentTo(0))
   701  
   702  	// first IP + last IP
   703  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelAddressRangeReply{})
   704  	err = natHandler.AddNat44AddressPool(0, addr1.String(), addr2.String(), false)
   705  	Expect(err).ShouldNot(HaveOccurred())
   706  
   707  	msg, ok = ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelAddressRange)
   708  	Expect(ok).To(BeTrue())
   709  	Expect(msg.IsAdd).To(BeTrue())
   710  	Expect(addressTo4IP(msg.FirstIPAddress)).To(BeEquivalentTo(addr1.String()))
   711  	Expect(addressTo4IP(msg.LastIPAddress)).To(BeEquivalentTo(addr2.String()))
   712  	Expect(msg.VrfID).To(BeEquivalentTo(0))
   713  	Expect(msg.Flags).To(BeEquivalentTo(0))
   714  }
   715  
   716  func TestAddNat44EiAddressPool(t *testing.T) {
   717  	ctx, natHandler, _, _ := natTestSetup(t)
   718  	defer ctx.TeardownTestCtx()
   719  
   720  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   721  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   722  	Expect(err).ShouldNot(HaveOccurred())
   723  
   724  	addr1 := net.ParseIP("10.0.0.1").To4()
   725  	addr2 := net.ParseIP("10.0.0.10").To4()
   726  
   727  	// first IP only
   728  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelAddressRangeReply{})
   729  	err = natHandler.AddNat44AddressPool(0, addr1.String(), "", false)
   730  	Expect(err).ShouldNot(HaveOccurred())
   731  
   732  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelAddressRange)
   733  	Expect(ok).To(BeTrue())
   734  	Expect(msg.IsAdd).To(BeTrue())
   735  	Expect(addressTo4IP(msg.FirstIPAddress)).To(BeEquivalentTo(addr1.String()))
   736  	Expect(addressTo4IP(msg.LastIPAddress)).To(BeEquivalentTo(addr1.String()))
   737  	Expect(msg.VrfID).To(BeEquivalentTo(0))
   738  	//Expect(msg.Flags).To(BeEquivalentTo(0))
   739  
   740  	// first IP + last IP
   741  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelAddressRangeReply{})
   742  	err = natHandler.AddNat44AddressPool(0, addr1.String(), addr2.String(), false)
   743  	Expect(err).ShouldNot(HaveOccurred())
   744  
   745  	msg, ok = ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelAddressRange)
   746  	Expect(ok).To(BeTrue())
   747  	Expect(msg.IsAdd).To(BeTrue())
   748  	Expect(addressTo4IP(msg.FirstIPAddress)).To(BeEquivalentTo(addr1.String()))
   749  	Expect(addressTo4IP(msg.LastIPAddress)).To(BeEquivalentTo(addr2.String()))
   750  	Expect(msg.VrfID).To(BeEquivalentTo(0))
   751  	//Expect(msg.Flags).To(BeEquivalentTo(0))
   752  }
   753  
   754  func TestAddNat44EdAddressPoolError(t *testing.T) {
   755  	ctx, natHandler, _, _ := natTestSetup(t)
   756  	defer ctx.TeardownTestCtx()
   757  
   758  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   759  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   760  	Expect(err).ShouldNot(HaveOccurred())
   761  
   762  	addr := net.ParseIP("10.0.0.1").To4()
   763  
   764  	// Incorrect reply object
   765  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
   766  	err = natHandler.AddNat44AddressPool(0, addr.String(), "", false)
   767  
   768  	Expect(err).Should(HaveOccurred())
   769  }
   770  
   771  func TestAddNat44EiAddressPoolError(t *testing.T) {
   772  	ctx, natHandler, _, _ := natTestSetup(t)
   773  	defer ctx.TeardownTestCtx()
   774  
   775  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   776  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   777  	Expect(err).ShouldNot(HaveOccurred())
   778  
   779  	addr := net.ParseIP("10.0.0.1").To4()
   780  
   781  	// Incorrect reply object
   782  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
   783  	err = natHandler.AddNat44AddressPool(0, addr.String(), "", false)
   784  
   785  	Expect(err).Should(HaveOccurred())
   786  }
   787  
   788  func TestAddNat44EdAddressPoolRetval(t *testing.T) {
   789  	ctx, natHandler, _, _ := natTestSetup(t)
   790  	defer ctx.TeardownTestCtx()
   791  
   792  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   793  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   794  	Expect(err).ShouldNot(HaveOccurred())
   795  
   796  	addr := net.ParseIP("10.0.0.1").To4()
   797  
   798  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelAddressRangeReply{
   799  		Retval: 1,
   800  	})
   801  	err = natHandler.AddNat44AddressPool(0, addr.String(), "", false)
   802  
   803  	Expect(err).Should(HaveOccurred())
   804  }
   805  
   806  func TestAddNat44EiAddressPoolRetval(t *testing.T) {
   807  	ctx, natHandler, _, _ := natTestSetup(t)
   808  	defer ctx.TeardownTestCtx()
   809  
   810  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   811  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   812  	Expect(err).ShouldNot(HaveOccurred())
   813  
   814  	addr := net.ParseIP("10.0.0.1").To4()
   815  
   816  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelAddressRangeReply{
   817  		Retval: 1,
   818  	})
   819  	err = natHandler.AddNat44AddressPool(0, addr.String(), "", false)
   820  
   821  	Expect(err).Should(HaveOccurred())
   822  }
   823  
   824  func TestDelNat44EdAddressPool(t *testing.T) {
   825  	ctx, natHandler, _, _ := natTestSetup(t)
   826  	defer ctx.TeardownTestCtx()
   827  
   828  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   829  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   830  	Expect(err).ShouldNot(HaveOccurred())
   831  
   832  	addr := net.ParseIP("10.0.0.1").To4()
   833  
   834  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelAddressRangeReply{})
   835  	err = natHandler.DelNat44AddressPool(0, addr.String(), "", false)
   836  
   837  	Expect(err).ShouldNot(HaveOccurred())
   838  
   839  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelAddressRange)
   840  	Expect(ok).To(BeTrue())
   841  	Expect(msg.IsAdd).To(BeFalse())
   842  	Expect(addressTo4IP(msg.FirstIPAddress)).To(BeEquivalentTo(addr.String()))
   843  	Expect(addressTo4IP(msg.LastIPAddress)).To(BeEquivalentTo(addr.String()))
   844  	Expect(msg.VrfID).To(BeEquivalentTo(0))
   845  	Expect(msg.Flags).To(BeEquivalentTo(0))
   846  }
   847  
   848  func TestDelNat44EiAddressPool(t *testing.T) {
   849  	ctx, natHandler, _, _ := natTestSetup(t)
   850  	defer ctx.TeardownTestCtx()
   851  
   852  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   853  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   854  	Expect(err).ShouldNot(HaveOccurred())
   855  
   856  	addr := net.ParseIP("10.0.0.1").To4()
   857  
   858  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelAddressRangeReply{})
   859  	err = natHandler.DelNat44AddressPool(0, addr.String(), "", false)
   860  
   861  	Expect(err).ShouldNot(HaveOccurred())
   862  
   863  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelAddressRange)
   864  	Expect(ok).To(BeTrue())
   865  	Expect(msg.IsAdd).To(BeFalse())
   866  	Expect(addressTo4IP(msg.FirstIPAddress)).To(BeEquivalentTo(addr.String()))
   867  	Expect(addressTo4IP(msg.LastIPAddress)).To(BeEquivalentTo(addr.String()))
   868  	Expect(msg.VrfID).To(BeEquivalentTo(0))
   869  }
   870  
   871  /* DEPRECATED
   872  
   873  func TestSetNat44VirtualReassemblyIPv4(t *testing.T) {
   874  	ctx, natHandler, _, _ := natTestSetup(t)
   875  	defer ctx.TeardownTestCtx()
   876  
   877  	ctx.MockVpp.MockReply(&vpp_nat_ed.NatSetReassReply{})
   878  	err := natHandler.SetVirtualReassemblyIPv4(&nat.VirtualReassembly{
   879  		Timeout:         10,
   880  		MaxFragments:    20,
   881  		MaxReassemblies: 30,
   882  		DropFragments:   true,
   883  	})
   884  
   885  	Expect(err).ShouldNot(HaveOccurred())
   886  
   887  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.NatSetReass)
   888  	Expect(ok).To(BeTrue())
   889  	Expect(msg.Timeout).To(BeEquivalentTo(10))
   890  	Expect(msg.MaxFrag).To(BeEquivalentTo(20))
   891  	Expect(msg.MaxReass).To(BeEquivalentTo(30))
   892  	Expect(msg.DropFrag).To(BeEquivalentTo(1))
   893  }
   894  
   895  func TestSetNat44VirtualReassemblyIPv6(t *testing.T) {
   896  	ctx, natHandler, _, _ := natTestSetup(t)
   897  	defer ctx.TeardownTestCtx()
   898  
   899  	ctx.MockVpp.MockReply(&vpp_nat_ed.NatSetReassReply{})
   900  	err := natHandler.SetVirtualReassemblyIPv6(&nat.VirtualReassembly{
   901  		Timeout:         5,
   902  		MaxFragments:    10,
   903  		MaxReassemblies: 15,
   904  		DropFragments:   true,
   905  	})
   906  
   907  	Expect(err).ShouldNot(HaveOccurred())
   908  
   909  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.NatSetReass)
   910  	Expect(ok).To(BeTrue())
   911  	Expect(msg.Timeout).To(BeEquivalentTo(5))
   912  	Expect(msg.MaxFrag).To(BeEquivalentTo(10))
   913  	Expect(msg.MaxReass).To(BeEquivalentTo(15))
   914  	Expect(msg.DropFrag).To(BeEquivalentTo(1))
   915  }*/
   916  
   917  func TestAddNat44EdStaticMapping(t *testing.T) {
   918  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   919  	defer ctx.TeardownTestCtx()
   920  
   921  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
   922  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
   923  	Expect(err).ShouldNot(HaveOccurred())
   924  
   925  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   926  
   927  	localIP := net.ParseIP("10.0.0.1").To4()
   928  	externalIP := net.ParseIP("10.0.0.2").To4()
   929  
   930  	// DataContext
   931  	mapping := &nat.DNat44_StaticMapping{
   932  		ExternalIp:        externalIP.String(),
   933  		ExternalPort:      8080,
   934  		ExternalInterface: "if0", // overrides external IP
   935  		Protocol:          nat.DNat44_TCP,
   936  		TwiceNat:          nat.DNat44_StaticMapping_ENABLED,
   937  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
   938  			{
   939  				LocalIp:   localIP.String(),
   940  				VrfId:     1,
   941  				LocalPort: 24,
   942  			},
   943  		},
   944  	}
   945  
   946  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
   947  	err = natHandler.AddNat44StaticMapping(mapping, "DNAT 1")
   948  
   949  	Expect(err).ShouldNot(HaveOccurred())
   950  
   951  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelStaticMappingV2)
   952  	Expect(ok).To(BeTrue())
   953  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
   954  	Expect(msg.VrfID).To(BeEquivalentTo(1))
   955  	Expect(msg.IsAdd).To(BeTrue())
   956  	Expect(msg.LocalPort).To(BeEquivalentTo(24))
   957  	Expect(msg.ExternalPort).To(BeEquivalentTo(8080))
   958  	Expect(msg.Protocol).To(BeEquivalentTo(6))
   959  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo("0.0.0.0"))
   960  	Expect(msg.ExternalSwIfIndex).To(BeEquivalentTo(1))
   961  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
   962  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_TWICE_NAT + nat_types.NAT_IS_OUT2IN_ONLY))
   963  }
   964  
   965  func TestAddNat44EiStaticMapping(t *testing.T) {
   966  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
   967  	defer ctx.TeardownTestCtx()
   968  
   969  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
   970  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
   971  	Expect(err).ShouldNot(HaveOccurred())
   972  
   973  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
   974  
   975  	localIP := net.ParseIP("10.0.0.1").To4()
   976  	externalIP := net.ParseIP("10.0.0.2").To4()
   977  
   978  	// DataContext
   979  	mapping := &nat.DNat44_StaticMapping{
   980  		ExternalIp:        externalIP.String(),
   981  		ExternalPort:      8080,
   982  		ExternalInterface: "if0", // overrides external IP
   983  		Protocol:          nat.DNat44_TCP,
   984  		//TwiceNat:          nat.DNat44_StaticMapping_ENABLED,
   985  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
   986  			{
   987  				LocalIp:   localIP.String(),
   988  				VrfId:     1,
   989  				LocalPort: 24,
   990  			},
   991  		},
   992  	}
   993  
   994  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
   995  	err = natHandler.AddNat44StaticMapping(mapping, "DNAT 1")
   996  
   997  	Expect(err).ShouldNot(HaveOccurred())
   998  
   999  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelStaticMapping)
  1000  	Expect(ok).To(BeTrue())
  1001  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1002  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1003  	Expect(msg.IsAdd).To(BeTrue())
  1004  	Expect(msg.LocalPort).To(BeEquivalentTo(24))
  1005  	Expect(msg.ExternalPort).To(BeEquivalentTo(8080))
  1006  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1007  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1008  	Expect(msg.ExternalSwIfIndex).To(BeEquivalentTo(1))
  1009  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1010  }
  1011  
  1012  func TestAddNat44EdIdentityMappingWithInterface(t *testing.T) {
  1013  	ctx, natHandler, _, _ := natTestSetup(t)
  1014  	defer ctx.TeardownTestCtx()
  1015  
  1016  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1017  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1018  	Expect(err).ShouldNot(HaveOccurred())
  1019  
  1020  	localIP := net.ParseIP("10.0.0.1").To4()
  1021  	externalIP := net.ParseIP("10.0.0.2").To4()
  1022  
  1023  	// DataContext
  1024  	mapping := &nat.DNat44_StaticMapping{
  1025  		ExternalIp: externalIP.String(),
  1026  		Protocol:   nat.DNat44_TCP,
  1027  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1028  			{
  1029  				LocalIp: localIP.String(),
  1030  			},
  1031  		},
  1032  	}
  1033  
  1034  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
  1035  	err = natHandler.AddNat44StaticMapping(mapping, "DNAT 1")
  1036  
  1037  	Expect(err).ShouldNot(HaveOccurred())
  1038  
  1039  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelStaticMappingV2)
  1040  	Expect(ok).To(BeTrue())
  1041  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1042  	Expect(msg.IsAdd).To(BeTrue())
  1043  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo(externalIP.String()))
  1044  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1045  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_OUT2IN_ONLY + nat_types.NAT_IS_ADDR_ONLY))
  1046  }
  1047  
  1048  func TestAddNat44EiIdentityMappingWithInterface(t *testing.T) {
  1049  	ctx, natHandler, _, _ := natTestSetup(t)
  1050  	defer ctx.TeardownTestCtx()
  1051  
  1052  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1053  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1054  	Expect(err).ShouldNot(HaveOccurred())
  1055  
  1056  	localIP := net.ParseIP("10.0.0.1").To4()
  1057  	externalIP := net.ParseIP("10.0.0.2").To4()
  1058  
  1059  	// DataContext
  1060  	mapping := &nat.DNat44_StaticMapping{
  1061  		ExternalIp: externalIP.String(),
  1062  		Protocol:   nat.DNat44_TCP,
  1063  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1064  			{
  1065  				LocalIp: localIP.String(),
  1066  			},
  1067  		},
  1068  	}
  1069  
  1070  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
  1071  	err = natHandler.AddNat44StaticMapping(mapping, "DNAT 1")
  1072  
  1073  	Expect(err).ShouldNot(HaveOccurred())
  1074  
  1075  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelStaticMapping)
  1076  	Expect(ok).To(BeTrue())
  1077  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1078  	Expect(msg.IsAdd).To(BeTrue())
  1079  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo(externalIP.String()))
  1080  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1081  	//Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_OUT2IN_ONLY + nat_types.NAT_IS_ADDR_ONLY))
  1082  	Expect(msg.Flags).To(BeEquivalentTo(vpp_nat_ei.NAT44_EI_ADDR_ONLY_MAPPING))
  1083  }
  1084  
  1085  func TestAddNat44EdStaticMappingError(t *testing.T) {
  1086  	ctx, natHandler, _, _ := natTestSetup(t)
  1087  	defer ctx.TeardownTestCtx()
  1088  
  1089  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1090  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1091  	Expect(err).ShouldNot(HaveOccurred())
  1092  
  1093  	// Incorrect reply object
  1094  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelLbStaticMappingReply{})
  1095  	err = natHandler.AddNat44StaticMapping(&nat.DNat44_StaticMapping{}, "")
  1096  
  1097  	Expect(err).Should(HaveOccurred())
  1098  }
  1099  
  1100  func TestAddNat44EiStaticMappingError(t *testing.T) {
  1101  	ctx, natHandler, _, _ := natTestSetup(t)
  1102  	defer ctx.TeardownTestCtx()
  1103  
  1104  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1105  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1106  	Expect(err).ShouldNot(HaveOccurred())
  1107  
  1108  	// Incorrect reply object
  1109  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelOutputInterfaceReply{})
  1110  	err = natHandler.AddNat44StaticMapping(&nat.DNat44_StaticMapping{}, "")
  1111  
  1112  	Expect(err).Should(HaveOccurred())
  1113  }
  1114  
  1115  func TestAddNat44EdStaticMappingRetval(t *testing.T) {
  1116  	ctx, natHandler, _, _ := natTestSetup(t)
  1117  	defer ctx.TeardownTestCtx()
  1118  
  1119  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1120  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1121  	Expect(err).ShouldNot(HaveOccurred())
  1122  
  1123  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{
  1124  		Retval: 1,
  1125  	})
  1126  	err = natHandler.AddNat44StaticMapping(&nat.DNat44_StaticMapping{}, "")
  1127  
  1128  	Expect(err).Should(HaveOccurred())
  1129  }
  1130  
  1131  func TestAddNat44EiStaticMappingRetval(t *testing.T) {
  1132  	ctx, natHandler, _, _ := natTestSetup(t)
  1133  	defer ctx.TeardownTestCtx()
  1134  
  1135  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1136  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1137  	Expect(err).ShouldNot(HaveOccurred())
  1138  
  1139  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{
  1140  		Retval: 1,
  1141  	})
  1142  	err = natHandler.AddNat44StaticMapping(&nat.DNat44_StaticMapping{}, "")
  1143  
  1144  	Expect(err).Should(HaveOccurred())
  1145  }
  1146  
  1147  func TestDelNat44EdStaticMapping(t *testing.T) {
  1148  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1149  	defer ctx.TeardownTestCtx()
  1150  
  1151  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1152  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1153  	Expect(err).ShouldNot(HaveOccurred())
  1154  
  1155  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1156  
  1157  	localIP := net.ParseIP("10.0.0.1").To4()
  1158  	externalIP := net.ParseIP("10.0.0.2").To4()
  1159  
  1160  	mapping := &nat.DNat44_StaticMapping{
  1161  		ExternalIp:        externalIP.String(),
  1162  		ExternalPort:      8080,
  1163  		ExternalInterface: "if0", // overrides external IP
  1164  		Protocol:          nat.DNat44_TCP,
  1165  		TwiceNat:          nat.DNat44_StaticMapping_ENABLED,
  1166  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1167  			{
  1168  				LocalIp:   localIP.String(),
  1169  				VrfId:     1,
  1170  				LocalPort: 24,
  1171  			},
  1172  		},
  1173  	}
  1174  
  1175  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
  1176  	err = natHandler.DelNat44StaticMapping(mapping, "DNAT 1")
  1177  
  1178  	Expect(err).ShouldNot(HaveOccurred())
  1179  
  1180  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelStaticMappingV2)
  1181  	Expect(ok).To(BeTrue())
  1182  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1183  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1184  	Expect(msg.IsAdd).To(BeFalse())
  1185  	Expect(msg.LocalPort).To(BeEquivalentTo(24))
  1186  	Expect(msg.ExternalPort).To(BeEquivalentTo(8080))
  1187  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1188  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1189  	Expect(msg.ExternalSwIfIndex).To(BeEquivalentTo(1))
  1190  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1191  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_TWICE_NAT + nat_types.NAT_IS_OUT2IN_ONLY))
  1192  }
  1193  
  1194  func TestDelNat44EiStaticMapping(t *testing.T) {
  1195  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1196  	defer ctx.TeardownTestCtx()
  1197  
  1198  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1199  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1200  	Expect(err).ShouldNot(HaveOccurred())
  1201  
  1202  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1203  
  1204  	localIP := net.ParseIP("10.0.0.1").To4()
  1205  	externalIP := net.ParseIP("10.0.0.2").To4()
  1206  
  1207  	mapping := &nat.DNat44_StaticMapping{
  1208  		ExternalIp:        externalIP.String(),
  1209  		ExternalPort:      8080,
  1210  		ExternalInterface: "if0", // overrides external IP
  1211  		Protocol:          nat.DNat44_TCP,
  1212  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1213  			{
  1214  				LocalIp:   localIP.String(),
  1215  				VrfId:     1,
  1216  				LocalPort: 24,
  1217  			},
  1218  		},
  1219  	}
  1220  
  1221  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
  1222  	err = natHandler.DelNat44StaticMapping(mapping, "DNAT 1")
  1223  
  1224  	Expect(err).ShouldNot(HaveOccurred())
  1225  
  1226  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelStaticMapping)
  1227  	Expect(ok).To(BeTrue())
  1228  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1229  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1230  	Expect(msg.IsAdd).To(BeFalse())
  1231  	Expect(msg.LocalPort).To(BeEquivalentTo(24))
  1232  	Expect(msg.ExternalPort).To(BeEquivalentTo(8080))
  1233  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1234  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1235  	Expect(msg.ExternalSwIfIndex).To(BeEquivalentTo(1))
  1236  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1237  }
  1238  func TestDelNat44EdStaticMappingAddrOnly(t *testing.T) {
  1239  	ctx, natHandler, _, _ := natTestSetup(t)
  1240  	defer ctx.TeardownTestCtx()
  1241  
  1242  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1243  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1244  	Expect(err).ShouldNot(HaveOccurred())
  1245  
  1246  	localIP := net.ParseIP("10.0.0.1").To4()
  1247  	externalIP := net.ParseIP("10.0.0.2").To4()
  1248  
  1249  	mapping := &nat.DNat44_StaticMapping{
  1250  		ExternalIp: externalIP.String(),
  1251  		Protocol:   nat.DNat44_TCP,
  1252  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1253  			{
  1254  				LocalIp: localIP.String(),
  1255  			},
  1256  		},
  1257  	}
  1258  
  1259  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
  1260  	err = natHandler.DelNat44StaticMapping(mapping, "DNAT 1")
  1261  
  1262  	Expect(err).ShouldNot(HaveOccurred())
  1263  
  1264  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelStaticMappingV2)
  1265  	Expect(ok).To(BeTrue())
  1266  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1267  	Expect(msg.IsAdd).To(BeFalse())
  1268  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo(externalIP.String()))
  1269  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1270  }
  1271  
  1272  func TestDelNat44EiStaticMappingAddrOnly(t *testing.T) {
  1273  	ctx, natHandler, _, _ := natTestSetup(t)
  1274  	defer ctx.TeardownTestCtx()
  1275  
  1276  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1277  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1278  	Expect(err).ShouldNot(HaveOccurred())
  1279  
  1280  	localIP := net.ParseIP("10.0.0.1").To4()
  1281  	externalIP := net.ParseIP("10.0.0.2").To4()
  1282  
  1283  	mapping := &nat.DNat44_StaticMapping{
  1284  		ExternalIp: externalIP.String(),
  1285  		Protocol:   nat.DNat44_TCP,
  1286  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1287  			{
  1288  				LocalIp: localIP.String(),
  1289  			},
  1290  		},
  1291  	}
  1292  
  1293  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
  1294  	err = natHandler.DelNat44StaticMapping(mapping, "DNAT 1")
  1295  
  1296  	Expect(err).ShouldNot(HaveOccurred())
  1297  
  1298  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelStaticMapping)
  1299  	Expect(ok).To(BeTrue())
  1300  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1301  	Expect(msg.IsAdd).To(BeFalse())
  1302  	Expect(addressTo4IP(msg.ExternalIPAddress)).To(BeEquivalentTo(externalIP.String()))
  1303  	Expect(addressTo4IP(msg.LocalIPAddress)).To(BeEquivalentTo(localIP.String()))
  1304  }
  1305  
  1306  func TestAddNat44EdStaticMappingLb(t *testing.T) {
  1307  	ctx, natHandler, _, _ := natTestSetup(t)
  1308  	defer ctx.TeardownTestCtx()
  1309  
  1310  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1311  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1312  	Expect(err).ShouldNot(HaveOccurred())
  1313  
  1314  	externalIP := net.ParseIP("10.0.0.1").To4()
  1315  	localIP1 := net.ParseIP("10.0.0.2").To4()
  1316  	localIP2 := net.ParseIP("10.0.0.3").To4()
  1317  
  1318  	mapping := &nat.DNat44_StaticMapping{
  1319  		ExternalIp:        externalIP.String(),
  1320  		ExternalPort:      8080,
  1321  		ExternalInterface: "if0",
  1322  		Protocol:          nat.DNat44_TCP,
  1323  		TwiceNat:          nat.DNat44_StaticMapping_ENABLED,
  1324  		LocalIps:          localIPs(localIP1, localIP2),
  1325  	}
  1326  
  1327  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelLbStaticMappingReply{})
  1328  	err = natHandler.AddNat44StaticMapping(mapping, "DNAT 1")
  1329  
  1330  	Expect(err).ShouldNot(HaveOccurred())
  1331  
  1332  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelLbStaticMapping)
  1333  	Expect(ok).To(BeTrue())
  1334  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1335  	Expect(msg.IsAdd).To(BeTrue())
  1336  	Expect(addressTo4IP(msg.ExternalAddr)).To(BeEquivalentTo(externalIP.String()))
  1337  	Expect(msg.ExternalPort).To(BeEquivalentTo(8080))
  1338  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1339  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_TWICE_NAT + nat_types.NAT_IS_OUT2IN_ONLY))
  1340  
  1341  	// Local IPs
  1342  	Expect(msg.Locals).To(HaveLen(2))
  1343  	expectedCount := 0
  1344  	for _, local := range msg.Locals {
  1345  		localAddr := make(net.IP, net.IPv4len)
  1346  		copy(localAddr, local.Addr[:])
  1347  		if bytes.Equal(localAddr, localIP1) && local.Port == 8080 && local.Probability == 35 {
  1348  			expectedCount++
  1349  		}
  1350  		copy(localAddr, local.Addr[:])
  1351  		if bytes.Equal(localAddr, localIP2) && local.Port == 8181 && local.Probability == 65 {
  1352  			expectedCount++
  1353  		}
  1354  	}
  1355  	Expect(expectedCount).To(BeEquivalentTo(2))
  1356  }
  1357  
  1358  func TestDelNat44EdStaticMappingLb(t *testing.T) {
  1359  	ctx, natHandler, _, _ := natTestSetup(t)
  1360  	defer ctx.TeardownTestCtx()
  1361  
  1362  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1363  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1364  	Expect(err).ShouldNot(HaveOccurred())
  1365  
  1366  	externalIP := net.ParseIP("10.0.0.1").To4()
  1367  	localIP1 := net.ParseIP("10.0.0.2").To4()
  1368  	localIP2 := net.ParseIP("10.0.0.3").To4()
  1369  
  1370  	mapping := &nat.DNat44_StaticMapping{
  1371  		ExternalIp:        externalIP.String(),
  1372  		ExternalPort:      8080,
  1373  		ExternalInterface: "if0",
  1374  		Protocol:          nat.DNat44_TCP,
  1375  		TwiceNat:          nat.DNat44_StaticMapping_ENABLED,
  1376  		LocalIps:          localIPs(localIP1, localIP2),
  1377  	}
  1378  
  1379  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelLbStaticMappingReply{})
  1380  	err = natHandler.DelNat44StaticMapping(mapping, "DNAT 1")
  1381  
  1382  	Expect(err).ShouldNot(HaveOccurred())
  1383  
  1384  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelLbStaticMapping)
  1385  	Expect(ok).To(BeTrue())
  1386  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1387  	Expect(msg.IsAdd).To(BeFalse())
  1388  	Expect(addressTo4IP(msg.ExternalAddr)).To(BeEquivalentTo(externalIP.String()))
  1389  	Expect(msg.ExternalPort).To(BeEquivalentTo(8080))
  1390  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1391  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_TWICE_NAT + nat_types.NAT_IS_OUT2IN_ONLY))
  1392  
  1393  	// Local IPs
  1394  	Expect(msg.Locals).To(HaveLen(2))
  1395  	expectedCount := 0
  1396  	for _, local := range msg.Locals {
  1397  		localAddr := make(net.IP, net.IPv4len)
  1398  		copy(localAddr, local.Addr[:])
  1399  		if bytes.Equal(localAddr, localIP1) && local.Port == 8080 && local.Probability == 35 {
  1400  			expectedCount++
  1401  		}
  1402  		copy(localAddr, local.Addr[:])
  1403  		if bytes.Equal(localAddr, localIP2) && local.Port == 8181 && local.Probability == 65 {
  1404  			expectedCount++
  1405  		}
  1406  	}
  1407  	Expect(expectedCount).To(BeEquivalentTo(2))
  1408  }
  1409  
  1410  func TestAddNat44EdIdentityMapping(t *testing.T) {
  1411  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1412  	defer ctx.TeardownTestCtx()
  1413  
  1414  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1415  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1416  	Expect(err).ShouldNot(HaveOccurred())
  1417  
  1418  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1419  
  1420  	address := net.ParseIP("10.0.0.1").To4()
  1421  
  1422  	mapping := &nat.DNat44_IdentityMapping{
  1423  		VrfId:     1,
  1424  		Interface: "if0", // overrides IP address
  1425  		IpAddress: address.String(),
  1426  		Port:      9000,
  1427  		Protocol:  nat.DNat44_UDP,
  1428  	}
  1429  
  1430  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
  1431  	err = natHandler.AddNat44IdentityMapping(mapping, "DNAT 1")
  1432  
  1433  	Expect(err).ShouldNot(HaveOccurred())
  1434  
  1435  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelIdentityMapping)
  1436  	Expect(ok).To(BeTrue())
  1437  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1438  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1439  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1440  	Expect(msg.IsAdd).To(BeTrue())
  1441  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
  1442  	Expect(msg.Protocol).To(BeEquivalentTo(17))
  1443  	Expect(msg.Port).To(BeEquivalentTo(9000))
  1444  	Expect(msg.Flags).To(BeEquivalentTo(0))
  1445  }
  1446  
  1447  func TestAddNat44EiIdentityMapping(t *testing.T) {
  1448  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1449  	defer ctx.TeardownTestCtx()
  1450  
  1451  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1452  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1453  	Expect(err).ShouldNot(HaveOccurred())
  1454  
  1455  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1456  
  1457  	address := net.ParseIP("10.0.0.1").To4()
  1458  
  1459  	mapping := &nat.DNat44_IdentityMapping{
  1460  		VrfId:     1,
  1461  		Interface: "if0", // overrides IP address
  1462  		IpAddress: address.String(),
  1463  		Port:      9000,
  1464  		Protocol:  nat.DNat44_UDP,
  1465  	}
  1466  
  1467  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
  1468  	err = natHandler.AddNat44IdentityMapping(mapping, "DNAT 1")
  1469  
  1470  	Expect(err).ShouldNot(HaveOccurred())
  1471  
  1472  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelIdentityMapping)
  1473  	Expect(ok).To(BeTrue())
  1474  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1475  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1476  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1477  	Expect(msg.IsAdd).To(BeTrue())
  1478  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
  1479  	Expect(msg.Protocol).To(BeEquivalentTo(17))
  1480  	Expect(msg.Port).To(BeEquivalentTo(9000))
  1481  	Expect(msg.Flags).To(BeEquivalentTo(0))
  1482  }
  1483  func TestAddNat44EdIdentityMappingAddrOnly(t *testing.T) {
  1484  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1485  	defer ctx.TeardownTestCtx()
  1486  
  1487  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1488  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1489  	Expect(err).ShouldNot(HaveOccurred())
  1490  
  1491  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1492  
  1493  	// IPAddress == nil and Port == 0 means it's address only
  1494  	mapping := &nat.DNat44_IdentityMapping{
  1495  		VrfId:     1,
  1496  		Interface: "if0", // overrides IP address
  1497  		Protocol:  nat.DNat44_UDP,
  1498  	}
  1499  
  1500  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
  1501  	err = natHandler.AddNat44IdentityMapping(mapping, "DNAT 1")
  1502  
  1503  	Expect(err).ShouldNot(HaveOccurred())
  1504  
  1505  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelIdentityMapping)
  1506  	Expect(ok).To(BeTrue())
  1507  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1508  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1509  	Expect(msg.IsAdd).To(BeTrue())
  1510  	Expect(msg.Protocol).To(BeEquivalentTo(17))
  1511  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
  1512  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_ADDR_ONLY))
  1513  }
  1514  
  1515  func TestAddNat44EiIdentityMappingAddrOnly(t *testing.T) {
  1516  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1517  	defer ctx.TeardownTestCtx()
  1518  
  1519  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1520  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1521  	Expect(err).ShouldNot(HaveOccurred())
  1522  
  1523  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1524  
  1525  	// IPAddress == nil and Port == 0 means it's address only
  1526  	mapping := &nat.DNat44_IdentityMapping{
  1527  		VrfId:     1,
  1528  		Interface: "if0", // overrides IP address
  1529  		Protocol:  nat.DNat44_UDP,
  1530  	}
  1531  
  1532  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
  1533  	err = natHandler.AddNat44IdentityMapping(mapping, "DNAT 1")
  1534  
  1535  	Expect(err).ShouldNot(HaveOccurred())
  1536  
  1537  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelIdentityMapping)
  1538  	Expect(ok).To(BeTrue())
  1539  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 1"))
  1540  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1541  	Expect(msg.IsAdd).To(BeTrue())
  1542  	Expect(msg.Protocol).To(BeEquivalentTo(17))
  1543  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
  1544  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_ADDR_ONLY))
  1545  }
  1546  
  1547  func TestAddNat44EdIdentityMappingNoInterface(t *testing.T) {
  1548  	ctx, natHandler, _, _ := natTestSetup(t)
  1549  	defer ctx.TeardownTestCtx()
  1550  
  1551  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1552  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1553  	Expect(err).ShouldNot(HaveOccurred())
  1554  
  1555  	address := net.ParseIP("10.0.0.1").To4()
  1556  
  1557  	mapping := &nat.DNat44_IdentityMapping{
  1558  		VrfId:     1,
  1559  		Protocol:  nat.DNat44_UDP,
  1560  		IpAddress: address.String(),
  1561  		Port:      8989,
  1562  	}
  1563  
  1564  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
  1565  	err = natHandler.AddNat44IdentityMapping(mapping, "DNAT 2")
  1566  
  1567  	Expect(err).ShouldNot(HaveOccurred())
  1568  
  1569  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelIdentityMapping)
  1570  	Expect(ok).To(BeTrue())
  1571  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 2"))
  1572  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo(address.String()))
  1573  	Expect(msg.Port).To(BeEquivalentTo(8989))
  1574  	Expect(msg.SwIfIndex).To(BeEquivalentTo(vpp2210.NoInterface))
  1575  	Expect(msg.Flags).To(BeEquivalentTo(0))
  1576  }
  1577  
  1578  func TestAddNat44EiIdentityMappingNoInterface(t *testing.T) {
  1579  	ctx, natHandler, _, _ := natTestSetup(t)
  1580  	defer ctx.TeardownTestCtx()
  1581  
  1582  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1583  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1584  	Expect(err).ShouldNot(HaveOccurred())
  1585  
  1586  	address := net.ParseIP("10.0.0.1").To4()
  1587  
  1588  	mapping := &nat.DNat44_IdentityMapping{
  1589  		VrfId:     1,
  1590  		Protocol:  nat.DNat44_UDP,
  1591  		IpAddress: address.String(),
  1592  		Port:      8989,
  1593  	}
  1594  
  1595  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
  1596  	err = natHandler.AddNat44IdentityMapping(mapping, "DNAT 2")
  1597  
  1598  	Expect(err).ShouldNot(HaveOccurred())
  1599  
  1600  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelIdentityMapping)
  1601  	Expect(ok).To(BeTrue())
  1602  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 2"))
  1603  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo(address.String()))
  1604  	Expect(msg.Port).To(BeEquivalentTo(8989))
  1605  	Expect(msg.SwIfIndex).To(BeEquivalentTo(vpp2210.NoInterface))
  1606  	Expect(msg.Flags).To(BeEquivalentTo(0))
  1607  }
  1608  
  1609  func TestAddNat44EdIdentityMappingError(t *testing.T) {
  1610  	ctx, natHandler, _, _ := natTestSetup(t)
  1611  	defer ctx.TeardownTestCtx()
  1612  
  1613  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1614  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1615  	Expect(err).ShouldNot(HaveOccurred())
  1616  
  1617  	// Incorrect reply object
  1618  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
  1619  	err = natHandler.AddNat44IdentityMapping(&nat.DNat44_IdentityMapping{}, "")
  1620  
  1621  	Expect(err).Should(HaveOccurred())
  1622  }
  1623  
  1624  func TestAddNat44EiIdentityMappingError(t *testing.T) {
  1625  	ctx, natHandler, _, _ := natTestSetup(t)
  1626  	defer ctx.TeardownTestCtx()
  1627  
  1628  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1629  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1630  	Expect(err).ShouldNot(HaveOccurred())
  1631  
  1632  	// Incorrect reply object
  1633  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
  1634  	err = natHandler.AddNat44IdentityMapping(&nat.DNat44_IdentityMapping{}, "")
  1635  
  1636  	Expect(err).Should(HaveOccurred())
  1637  }
  1638  
  1639  func TestAddNat44EdIdentityMappingRetval(t *testing.T) {
  1640  	ctx, natHandler, _, _ := natTestSetup(t)
  1641  	defer ctx.TeardownTestCtx()
  1642  
  1643  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1644  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1645  	Expect(err).ShouldNot(HaveOccurred())
  1646  
  1647  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{
  1648  		Retval: 1,
  1649  	})
  1650  	err = natHandler.AddNat44IdentityMapping(&nat.DNat44_IdentityMapping{}, "")
  1651  
  1652  	Expect(err).Should(HaveOccurred())
  1653  }
  1654  
  1655  func TestAddNat44IdentityMappingRetval(t *testing.T) {
  1656  	ctx, natHandler, _, _ := natTestSetup(t)
  1657  	defer ctx.TeardownTestCtx()
  1658  
  1659  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1660  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1661  	Expect(err).ShouldNot(HaveOccurred())
  1662  
  1663  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{
  1664  		Retval: 1,
  1665  	})
  1666  	err = natHandler.AddNat44IdentityMapping(&nat.DNat44_IdentityMapping{}, "")
  1667  
  1668  	Expect(err).Should(HaveOccurred())
  1669  }
  1670  
  1671  func TestDelNat44EdIdentityMapping(t *testing.T) {
  1672  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1673  	defer ctx.TeardownTestCtx()
  1674  
  1675  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1676  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1677  	Expect(err).ShouldNot(HaveOccurred())
  1678  
  1679  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1680  
  1681  	address := net.ParseIP("10.0.0.1").To4()
  1682  
  1683  	mapping := &nat.DNat44_IdentityMapping{
  1684  		Interface: "if0",
  1685  		IpAddress: address.String(),
  1686  		Protocol:  nat.DNat44_TCP,
  1687  		VrfId:     1,
  1688  	}
  1689  
  1690  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
  1691  	err = natHandler.DelNat44IdentityMapping(mapping, "DNAT 2")
  1692  
  1693  	Expect(err).ShouldNot(HaveOccurred())
  1694  
  1695  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ed.Nat44AddDelIdentityMapping)
  1696  	Expect(ok).To(BeTrue())
  1697  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 2"))
  1698  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1699  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1700  	Expect(msg.IsAdd).To(BeFalse())
  1701  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
  1702  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1703  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_ADDR_ONLY))
  1704  }
  1705  
  1706  func TestDelNat44EiIdentityMapping(t *testing.T) {
  1707  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1708  	defer ctx.TeardownTestCtx()
  1709  
  1710  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1711  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1712  	Expect(err).ShouldNot(HaveOccurred())
  1713  
  1714  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1715  
  1716  	address := net.ParseIP("10.0.0.1").To4()
  1717  
  1718  	mapping := &nat.DNat44_IdentityMapping{
  1719  		Interface: "if0",
  1720  		IpAddress: address.String(),
  1721  		Protocol:  nat.DNat44_TCP,
  1722  		VrfId:     1,
  1723  	}
  1724  
  1725  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
  1726  	err = natHandler.DelNat44IdentityMapping(mapping, "DNAT 2")
  1727  
  1728  	Expect(err).ShouldNot(HaveOccurred())
  1729  
  1730  	msg, ok := ctx.MockChannel.Msg.(*vpp_nat_ei.Nat44EiAddDelIdentityMapping)
  1731  	Expect(ok).To(BeTrue())
  1732  	Expect(msg.Tag).To(BeEquivalentTo("DNAT 2"))
  1733  	Expect(msg.VrfID).To(BeEquivalentTo(1))
  1734  	Expect(addressTo4IP(msg.IPAddress)).To(BeEquivalentTo("0.0.0.0"))
  1735  	Expect(msg.IsAdd).To(BeFalse())
  1736  	Expect(msg.SwIfIndex).To(BeEquivalentTo(1))
  1737  	Expect(msg.Protocol).To(BeEquivalentTo(6))
  1738  	Expect(msg.Flags).To(BeEquivalentTo(nat_types.NAT_IS_ADDR_ONLY))
  1739  }
  1740  
  1741  func TestNat44EdMappingLongTag(t *testing.T) {
  1742  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1743  	defer ctx.TeardownTestCtx()
  1744  
  1745  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44EdPluginEnableDisableReply{})
  1746  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: true})
  1747  	Expect(err).ShouldNot(HaveOccurred())
  1748  
  1749  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1750  
  1751  	normalTag := "normalTag"
  1752  	longTag := "some-weird-tag-which-is-much-longer-than-allowed-sixty-four-bytes"
  1753  
  1754  	localIP1 := net.ParseIP("10.0.0.1").To4()
  1755  	localIP2 := net.ParseIP("20.0.0.1").To4()
  1756  	externalIP := net.ParseIP("10.0.0.2").To4()
  1757  
  1758  	mapping := &nat.DNat44_StaticMapping{
  1759  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1760  			{
  1761  				LocalIp: localIP1.String(),
  1762  			},
  1763  		},
  1764  		ExternalIp: externalIP.String(),
  1765  	}
  1766  	lbMapping := &nat.DNat44_StaticMapping{
  1767  		LocalIps:     localIPs(localIP1, localIP2),
  1768  		ExternalIp:   externalIP.String(),
  1769  		ExternalPort: 8080,
  1770  		Protocol:     nat.DNat44_TCP,
  1771  		TwiceNat:     nat.DNat44_StaticMapping_ENABLED,
  1772  	}
  1773  	idMapping := &nat.DNat44_IdentityMapping{
  1774  		IpAddress: localIP1.String(),
  1775  		Protocol:  nat.DNat44_UDP,
  1776  		VrfId:     1,
  1777  		Interface: "if0",
  1778  	}
  1779  
  1780  	// 1. test
  1781  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
  1782  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelLbStaticMappingReply{})
  1783  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
  1784  	// 2. test
  1785  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelStaticMappingV2Reply{})
  1786  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelLbStaticMappingReply{})
  1787  	ctx.MockVpp.MockReply(&vpp_nat_ed.Nat44AddDelIdentityMappingReply{})
  1788  
  1789  	// Successful scenario (to ensure there is no other error)
  1790  	err = natHandler.AddNat44StaticMapping(mapping, normalTag)
  1791  	Expect(err).To(BeNil())
  1792  	err = natHandler.AddNat44StaticMapping(lbMapping, normalTag)
  1793  	Expect(err).To(BeNil())
  1794  	err = natHandler.AddNat44IdentityMapping(idMapping, normalTag)
  1795  	Expect(err).To(BeNil())
  1796  
  1797  	// Replace tags and test again
  1798  	err = natHandler.AddNat44StaticMapping(mapping, longTag)
  1799  	Expect(err).ToNot(BeNil())
  1800  	err = natHandler.AddNat44StaticMapping(lbMapping, longTag)
  1801  	Expect(err).ToNot(BeNil())
  1802  	err = natHandler.AddNat44IdentityMapping(idMapping, longTag)
  1803  	Expect(err).ToNot(BeNil())
  1804  }
  1805  
  1806  func TestNat44EiMappingLongTag(t *testing.T) {
  1807  	ctx, natHandler, swIfIndexes, _ := natTestSetup(t)
  1808  	defer ctx.TeardownTestCtx()
  1809  
  1810  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiPluginEnableDisableReply{})
  1811  	err := natHandler.EnableNAT44Plugin(vppcalls.Nat44InitOpts{EndpointDependent: false})
  1812  	Expect(err).ShouldNot(HaveOccurred())
  1813  
  1814  	swIfIndexes.Put("if0", &ifaceidx.IfaceMetadata{SwIfIndex: 1})
  1815  
  1816  	normalTag := "normalTag"
  1817  	longTag := "some-weird-tag-which-is-much-longer-than-allowed-sixty-four-bytes"
  1818  
  1819  	localIP1 := net.ParseIP("10.0.0.1").To4()
  1820  	externalIP := net.ParseIP("10.0.0.2").To4()
  1821  
  1822  	mapping := &nat.DNat44_StaticMapping{
  1823  		LocalIps: []*nat.DNat44_StaticMapping_LocalIP{
  1824  			{
  1825  				LocalIp: localIP1.String(),
  1826  			},
  1827  		},
  1828  		ExternalIp: externalIP.String(),
  1829  	}
  1830  	idMapping := &nat.DNat44_IdentityMapping{
  1831  		IpAddress: localIP1.String(),
  1832  		Protocol:  nat.DNat44_UDP,
  1833  		VrfId:     1,
  1834  		Interface: "if0",
  1835  	}
  1836  
  1837  	// 1. test
  1838  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
  1839  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
  1840  	// 2. test
  1841  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelStaticMappingReply{})
  1842  	ctx.MockVpp.MockReply(&vpp_nat_ei.Nat44EiAddDelIdentityMappingReply{})
  1843  
  1844  	// Successful scenario (to ensure there is no other error)
  1845  	err = natHandler.AddNat44StaticMapping(mapping, normalTag)
  1846  	Expect(err).To(BeNil())
  1847  	err = natHandler.AddNat44IdentityMapping(idMapping, normalTag)
  1848  	Expect(err).To(BeNil())
  1849  
  1850  	// Replace tags and test again
  1851  	err = natHandler.AddNat44StaticMapping(mapping, longTag)
  1852  	Expect(err).ToNot(BeNil())
  1853  	err = natHandler.AddNat44IdentityMapping(idMapping, longTag)
  1854  	Expect(err).ToNot(BeNil())
  1855  }
  1856  
  1857  func localIPs(addr1, addr2 net.IP) []*nat.DNat44_StaticMapping_LocalIP {
  1858  	return []*nat.DNat44_StaticMapping_LocalIP{
  1859  		{
  1860  			LocalIp:     addr1.String(),
  1861  			LocalPort:   8080,
  1862  			Probability: 35,
  1863  		},
  1864  		{
  1865  			LocalIp:     addr2.String(),
  1866  			LocalPort:   8181,
  1867  			Probability: 65,
  1868  		},
  1869  	}
  1870  }
  1871  
  1872  func addressTo4IP(address ip_types.IP4Address) string {
  1873  	ipAddr := make(net.IP, net.IPv4len)
  1874  	copy(ipAddr[:], address[:])
  1875  	if ipAddr.To4() == nil {
  1876  		return ""
  1877  	}
  1878  	return ipAddr.To4().String()
  1879  }