github.com/osrg/gobgp@v2.0.0+incompatible/internal/pkg/apiutil/attribute_test.go (about)

     1  // Copyright (C) 2016 Nippon Telegraph and Telephone Corporation.
     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
    12  // implied.
    13  // See the License for the specific language governing permissions and
    14  // limitations under the License.
    15  
    16  package apiutil
    17  
    18  import (
    19  	"net"
    20  	"testing"
    21  
    22  	"github.com/golang/protobuf/ptypes"
    23  	"github.com/golang/protobuf/ptypes/any"
    24  	api "github.com/osrg/gobgp/api"
    25  	"github.com/osrg/gobgp/pkg/packet/bgp"
    26  	"github.com/stretchr/testify/assert"
    27  )
    28  
    29  func Test_OriginAttribute(t *testing.T) {
    30  	assert := assert.New(t)
    31  
    32  	input := &api.OriginAttribute{
    33  		Origin: 0, // IGP
    34  	}
    35  	a, err := ptypes.MarshalAny(input)
    36  	assert.Nil(err)
    37  	n, err := unmarshalAttribute(a)
    38  	assert.Nil(err)
    39  
    40  	output := NewOriginAttributeFromNative(n.(*bgp.PathAttributeOrigin))
    41  	assert.Equal(input.Origin, output.Origin)
    42  }
    43  
    44  func Test_AsPathAttribute(t *testing.T) {
    45  	assert := assert.New(t)
    46  
    47  	input := &api.AsPathAttribute{
    48  		Segments: []*api.AsSegment{
    49  			{
    50  				Type:    1, // SET
    51  				Numbers: []uint32{100, 200},
    52  			},
    53  			{
    54  				Type:    2, // SEQ
    55  				Numbers: []uint32{300, 400},
    56  			},
    57  		},
    58  	}
    59  
    60  	a, err := ptypes.MarshalAny(input)
    61  	assert.Nil(err)
    62  	n, err := unmarshalAttribute(a)
    63  	assert.Nil(err)
    64  
    65  	output := NewAsPathAttributeFromNative(n.(*bgp.PathAttributeAsPath))
    66  	assert.Equal(2, len(output.Segments))
    67  	assert.Equal(input.Segments, output.Segments)
    68  }
    69  
    70  func Test_NextHopAttribute(t *testing.T) {
    71  	assert := assert.New(t)
    72  
    73  	input := &api.NextHopAttribute{
    74  		NextHop: "192.168.0.1",
    75  	}
    76  
    77  	a, err := ptypes.MarshalAny(input)
    78  	assert.Nil(err)
    79  	n, err := unmarshalAttribute(a)
    80  	assert.Nil(err)
    81  
    82  	output := NewNextHopAttributeFromNative(n.(*bgp.PathAttributeNextHop))
    83  	assert.Equal(input.NextHop, output.NextHop)
    84  }
    85  
    86  func Test_MultiExitDiscAttribute(t *testing.T) {
    87  	assert := assert.New(t)
    88  
    89  	input := &api.MultiExitDiscAttribute{
    90  		Med: 100,
    91  	}
    92  
    93  	a, err := ptypes.MarshalAny(input)
    94  	assert.Nil(err)
    95  	n, err := unmarshalAttribute(a)
    96  	assert.Nil(err)
    97  
    98  	output := NewMultiExitDiscAttributeFromNative(n.(*bgp.PathAttributeMultiExitDisc))
    99  	assert.Equal(input.Med, output.Med)
   100  }
   101  
   102  func Test_LocalPrefAttribute(t *testing.T) {
   103  	assert := assert.New(t)
   104  
   105  	input := &api.LocalPrefAttribute{
   106  		LocalPref: 100,
   107  	}
   108  
   109  	a, err := ptypes.MarshalAny(input)
   110  	assert.Nil(err)
   111  	n, err := unmarshalAttribute(a)
   112  	assert.Nil(err)
   113  
   114  	output := NewLocalPrefAttributeFromNative(n.(*bgp.PathAttributeLocalPref))
   115  	assert.Equal(input.LocalPref, output.LocalPref)
   116  }
   117  
   118  func Test_AtomicAggregateAttribute(t *testing.T) {
   119  	assert := assert.New(t)
   120  
   121  	input := &api.AtomicAggregateAttribute{}
   122  
   123  	a, err := ptypes.MarshalAny(input)
   124  	assert.Nil(err)
   125  	n, err := unmarshalAttribute(a)
   126  	assert.Nil(err)
   127  
   128  	output := NewAtomicAggregateAttributeFromNative(n.(*bgp.PathAttributeAtomicAggregate))
   129  	// AtomicAggregateAttribute has no value
   130  	assert.NotNil(output)
   131  }
   132  
   133  func Test_AggregatorAttribute(t *testing.T) {
   134  	assert := assert.New(t)
   135  
   136  	input := &api.AggregatorAttribute{
   137  		As:      65000,
   138  		Address: "1.1.1.1",
   139  	}
   140  
   141  	a, err := ptypes.MarshalAny(input)
   142  	assert.Nil(err)
   143  	n, err := unmarshalAttribute(a)
   144  	assert.Nil(err)
   145  
   146  	output := NewAggregatorAttributeFromNative(n.(*bgp.PathAttributeAggregator))
   147  	assert.Equal(input.As, output.As)
   148  	assert.Equal(input.Address, output.Address)
   149  }
   150  
   151  func Test_CommunitiesAttribute(t *testing.T) {
   152  	assert := assert.New(t)
   153  
   154  	input := &api.CommunitiesAttribute{
   155  		Communities: []uint32{100, 200},
   156  	}
   157  
   158  	a, err := ptypes.MarshalAny(input)
   159  	assert.Nil(err)
   160  	n, err := unmarshalAttribute(a)
   161  	assert.Nil(err)
   162  
   163  	output := NewCommunitiesAttributeFromNative(n.(*bgp.PathAttributeCommunities))
   164  	assert.Equal(input.Communities, output.Communities)
   165  }
   166  
   167  func Test_OriginatorIdAttribute(t *testing.T) {
   168  	assert := assert.New(t)
   169  
   170  	input := &api.OriginatorIdAttribute{
   171  		Id: "1.1.1.1",
   172  	}
   173  
   174  	a, err := ptypes.MarshalAny(input)
   175  	assert.Nil(err)
   176  	n, err := unmarshalAttribute(a)
   177  	assert.Nil(err)
   178  
   179  	output := NewOriginatorIdAttributeFromNative(n.(*bgp.PathAttributeOriginatorId))
   180  	assert.Equal(input.Id, output.Id)
   181  }
   182  
   183  func Test_ClusterListAttribute(t *testing.T) {
   184  	assert := assert.New(t)
   185  
   186  	input := &api.ClusterListAttribute{
   187  		Ids: []string{"1.1.1.1", "2.2.2.2"},
   188  	}
   189  
   190  	a, err := ptypes.MarshalAny(input)
   191  	assert.Nil(err)
   192  	n, err := unmarshalAttribute(a)
   193  	assert.Nil(err)
   194  
   195  	output := NewClusterListAttributeFromNative(n.(*bgp.PathAttributeClusterList))
   196  	assert.Equal(input.Ids, output.Ids)
   197  }
   198  
   199  func Test_MpReachNLRIAttribute_IPv4_UC(t *testing.T) {
   200  	assert := assert.New(t)
   201  
   202  	nlris := make([]*any.Any, 0, 2)
   203  	a, err := ptypes.MarshalAny(&api.IPAddressPrefix{
   204  		PrefixLen: 24,
   205  		Prefix:    "192.168.101.0",
   206  	})
   207  	assert.Nil(err)
   208  	nlris = append(nlris, a)
   209  	a, err = ptypes.MarshalAny(&api.IPAddressPrefix{
   210  		PrefixLen: 24,
   211  		Prefix:    "192.168.201.0",
   212  	})
   213  	assert.Nil(err)
   214  	nlris = append(nlris, a)
   215  
   216  	input := &api.MpReachNLRIAttribute{
   217  		Family: &api.Family{
   218  			Afi:  api.Family_AFI_IP,
   219  			Safi: api.Family_SAFI_UNICAST,
   220  		},
   221  		NextHops: []string{"192.168.1.1"},
   222  		Nlris:    nlris,
   223  	}
   224  
   225  	a, err = ptypes.MarshalAny(input)
   226  	assert.Nil(err)
   227  	n, err := unmarshalAttribute(a)
   228  	assert.Nil(err)
   229  
   230  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   231  	assert.Equal(input.Family, output.Family)
   232  	assert.Equal(input.NextHops, output.NextHops)
   233  	assert.Equal(2, len(output.Nlris))
   234  	for idx, inputNLRI := range input.Nlris {
   235  		outputNLRI := output.Nlris[idx]
   236  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   237  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   238  	}
   239  }
   240  
   241  func Test_MpReachNLRIAttribute_IPv6_UC(t *testing.T) {
   242  	assert := assert.New(t)
   243  
   244  	nlris := make([]*any.Any, 0, 2)
   245  	a, err := ptypes.MarshalAny(&api.IPAddressPrefix{
   246  		PrefixLen: 64,
   247  		Prefix:    "2001:db8:1::",
   248  	})
   249  	assert.Nil(err)
   250  	nlris = append(nlris, a)
   251  	a, err = ptypes.MarshalAny(&api.IPAddressPrefix{
   252  		PrefixLen: 64,
   253  		Prefix:    "2001:db8:2::",
   254  	})
   255  	assert.Nil(err)
   256  	nlris = append(nlris, a)
   257  
   258  	input := &api.MpReachNLRIAttribute{
   259  		Family: &api.Family{
   260  			Afi:  api.Family_AFI_IP6,
   261  			Safi: api.Family_SAFI_UNICAST,
   262  		},
   263  		NextHops: []string{"2001:db8::1", "2001:db8::2"},
   264  		Nlris:    nlris,
   265  	}
   266  
   267  	a, err = ptypes.MarshalAny(input)
   268  	assert.Nil(err)
   269  	n, err := unmarshalAttribute(a)
   270  	assert.Nil(err)
   271  
   272  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   273  	assert.Equal(input.Family, output.Family)
   274  	assert.Equal(input.NextHops, output.NextHops)
   275  	assert.Equal(2, len(output.Nlris))
   276  	for idx, inputNLRI := range input.Nlris {
   277  		outputNLRI := output.Nlris[idx]
   278  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   279  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   280  	}
   281  }
   282  
   283  func Test_MpReachNLRIAttribute_IPv4_MPLS(t *testing.T) {
   284  	assert := assert.New(t)
   285  
   286  	nlris := make([]*any.Any, 0, 2)
   287  	a, err := ptypes.MarshalAny(&api.LabeledIPAddressPrefix{
   288  		Labels:    []uint32{100},
   289  		PrefixLen: 24,
   290  		Prefix:    "192.168.101.0",
   291  	})
   292  	assert.Nil(err)
   293  	nlris = append(nlris, a)
   294  	a, err = ptypes.MarshalAny(&api.LabeledIPAddressPrefix{
   295  		Labels:    []uint32{200},
   296  		PrefixLen: 24,
   297  		Prefix:    "192.168.201.0",
   298  	})
   299  	assert.Nil(err)
   300  	nlris = append(nlris, a)
   301  
   302  	input := &api.MpReachNLRIAttribute{
   303  		Family: &api.Family{
   304  			Afi:  api.Family_AFI_IP,
   305  			Safi: api.Family_SAFI_MPLS_LABEL,
   306  		},
   307  		NextHops: []string{"192.168.1.1"},
   308  		Nlris:    nlris,
   309  	}
   310  
   311  	a, err = ptypes.MarshalAny(input)
   312  	assert.Nil(err)
   313  	n, err := unmarshalAttribute(a)
   314  	assert.Nil(err)
   315  
   316  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   317  	assert.Equal(input.Family, output.Family)
   318  	assert.Equal(input.NextHops, output.NextHops)
   319  	assert.Equal(2, len(output.Nlris))
   320  	for idx, inputNLRI := range input.Nlris {
   321  		outputNLRI := output.Nlris[idx]
   322  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   323  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   324  	}
   325  }
   326  
   327  func Test_MpReachNLRIAttribute_IPv6_MPLS(t *testing.T) {
   328  	assert := assert.New(t)
   329  
   330  	nlris := make([]*any.Any, 0, 2)
   331  	a, err := ptypes.MarshalAny(&api.LabeledIPAddressPrefix{
   332  		Labels:    []uint32{100},
   333  		PrefixLen: 64,
   334  		Prefix:    "2001:db8:1::",
   335  	})
   336  	assert.Nil(err)
   337  	nlris = append(nlris, a)
   338  	a, err = ptypes.MarshalAny(&api.LabeledIPAddressPrefix{
   339  		Labels:    []uint32{200},
   340  		PrefixLen: 64,
   341  		Prefix:    "2001:db8:2::",
   342  	})
   343  	assert.Nil(err)
   344  	nlris = append(nlris, a)
   345  
   346  	input := &api.MpReachNLRIAttribute{
   347  		Family: &api.Family{
   348  			Afi:  api.Family_AFI_IP6,
   349  			Safi: api.Family_SAFI_MPLS_LABEL,
   350  		},
   351  		NextHops: []string{"2001:db8::1"},
   352  		Nlris:    nlris,
   353  	}
   354  
   355  	a, err = ptypes.MarshalAny(input)
   356  	assert.Nil(err)
   357  	n, err := unmarshalAttribute(a)
   358  	assert.Nil(err)
   359  
   360  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   361  	assert.Equal(input.Family, output.Family)
   362  	assert.Equal(input.NextHops, output.NextHops)
   363  	assert.Equal(2, len(output.Nlris))
   364  	for idx, inputNLRI := range input.Nlris {
   365  		outputNLRI := output.Nlris[idx]
   366  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   367  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   368  	}
   369  }
   370  
   371  func Test_MpReachNLRIAttribute_IPv4_ENCAP(t *testing.T) {
   372  	assert := assert.New(t)
   373  
   374  	nlris := make([]*any.Any, 0, 2)
   375  	a, err := ptypes.MarshalAny(&api.EncapsulationNLRI{
   376  		Address: "192.168.101.1",
   377  	})
   378  	assert.Nil(err)
   379  	nlris = append(nlris, a)
   380  	a, err = ptypes.MarshalAny(&api.EncapsulationNLRI{
   381  		Address: "192.168.201.1",
   382  	})
   383  	assert.Nil(err)
   384  	nlris = append(nlris, a)
   385  
   386  	input := &api.MpReachNLRIAttribute{
   387  		Family: &api.Family{
   388  			Afi:  api.Family_AFI_IP,
   389  			Safi: api.Family_SAFI_ENCAPSULATION,
   390  		},
   391  		NextHops: []string{"192.168.1.1"},
   392  		Nlris:    nlris,
   393  	}
   394  
   395  	a, err = ptypes.MarshalAny(input)
   396  	assert.Nil(err)
   397  	n, err := unmarshalAttribute(a)
   398  	assert.Nil(err)
   399  
   400  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   401  	assert.Equal(input.Family, output.Family)
   402  	assert.Equal(input.NextHops, output.NextHops)
   403  	assert.Equal(2, len(output.Nlris))
   404  	for idx, inputNLRI := range input.Nlris {
   405  		outputNLRI := output.Nlris[idx]
   406  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   407  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   408  	}
   409  }
   410  
   411  func Test_MpReachNLRIAttribute_IPv6_ENCAP(t *testing.T) {
   412  	assert := assert.New(t)
   413  
   414  	nlris := make([]*any.Any, 0, 2)
   415  	a, err := ptypes.MarshalAny(&api.EncapsulationNLRI{
   416  		Address: "2001:db8:1::1",
   417  	})
   418  	assert.Nil(err)
   419  	nlris = append(nlris, a)
   420  	a, err = ptypes.MarshalAny(&api.EncapsulationNLRI{
   421  		Address: "2001:db8:2::1",
   422  	})
   423  	assert.Nil(err)
   424  	nlris = append(nlris, a)
   425  
   426  	input := &api.MpReachNLRIAttribute{
   427  		Family: &api.Family{
   428  			Afi:  api.Family_AFI_IP6,
   429  			Safi: api.Family_SAFI_ENCAPSULATION,
   430  		},
   431  		NextHops: []string{"2001:db8::1"},
   432  		Nlris:    nlris,
   433  	}
   434  
   435  	a, err = ptypes.MarshalAny(input)
   436  	assert.Nil(err)
   437  	n, err := unmarshalAttribute(a)
   438  	assert.Nil(err)
   439  
   440  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   441  	assert.Equal(input.Family, output.Family)
   442  	assert.Equal(input.NextHops, output.NextHops)
   443  	assert.Equal(2, len(output.Nlris))
   444  	for idx, inputNLRI := range input.Nlris {
   445  		outputNLRI := output.Nlris[idx]
   446  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   447  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   448  	}
   449  }
   450  
   451  func Test_MpReachNLRIAttribute_EVPN_AD_Route(t *testing.T) {
   452  	assert := assert.New(t)
   453  
   454  	nlris := make([]*any.Any, 0, 1)
   455  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherTwoOctetAS{
   456  		Admin:    65000,
   457  		Assigned: 100,
   458  	})
   459  	assert.Nil(err)
   460  	esi := &api.EthernetSegmentIdentifier{
   461  		Type:  0,
   462  		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
   463  	}
   464  	a, err := ptypes.MarshalAny(&api.EVPNEthernetAutoDiscoveryRoute{
   465  		Rd:          rd,
   466  		Esi:         esi,
   467  		EthernetTag: 100,
   468  		Label:       200,
   469  	})
   470  	assert.Nil(err)
   471  	nlris = append(nlris, a)
   472  
   473  	input := &api.MpReachNLRIAttribute{
   474  		Family: &api.Family{
   475  			Afi:  api.Family_AFI_L2VPN,
   476  			Safi: api.Family_SAFI_EVPN,
   477  		},
   478  		NextHops: []string{"192.168.1.1"},
   479  		Nlris:    nlris,
   480  	}
   481  
   482  	a, err = ptypes.MarshalAny(input)
   483  	assert.Nil(err)
   484  	n, err := unmarshalAttribute(a)
   485  	assert.Nil(err)
   486  
   487  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   488  	assert.Equal(input.Family, output.Family)
   489  	assert.Equal(input.NextHops, output.NextHops)
   490  	assert.Equal(1, len(output.Nlris))
   491  	for idx, inputNLRI := range input.Nlris {
   492  		outputNLRI := output.Nlris[idx]
   493  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   494  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   495  	}
   496  }
   497  
   498  func Test_MpReachNLRIAttribute_EVPN_MAC_IP_Route(t *testing.T) {
   499  	assert := assert.New(t)
   500  
   501  	nlris := make([]*any.Any, 0, 1)
   502  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
   503  		Admin:    "1.1.1.1",
   504  		Assigned: 100,
   505  	})
   506  	assert.Nil(err)
   507  	esi := &api.EthernetSegmentIdentifier{
   508  		Type:  0,
   509  		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
   510  	}
   511  	a, err := ptypes.MarshalAny(&api.EVPNMACIPAdvertisementRoute{
   512  		Rd:          rd,
   513  		Esi:         esi,
   514  		EthernetTag: 100,
   515  		MacAddress:  "aa:bb:cc:dd:ee:ff",
   516  		IpAddress:   "192.168.101.1",
   517  		Labels:      []uint32{200},
   518  	})
   519  	assert.Nil(err)
   520  	nlris = append(nlris, a)
   521  
   522  	input := &api.MpReachNLRIAttribute{
   523  		Family: &api.Family{
   524  			Afi:  api.Family_AFI_L2VPN,
   525  			Safi: api.Family_SAFI_EVPN,
   526  		},
   527  		NextHops: []string{"192.168.1.1"},
   528  		Nlris:    nlris,
   529  	}
   530  
   531  	a, err = ptypes.MarshalAny(input)
   532  	assert.Nil(err)
   533  	n, err := unmarshalAttribute(a)
   534  	assert.Nil(err)
   535  
   536  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   537  	assert.Equal(input.Family, output.Family)
   538  	assert.Equal(input.NextHops, output.NextHops)
   539  	assert.Equal(1, len(output.Nlris))
   540  	for idx, inputNLRI := range input.Nlris {
   541  		outputNLRI := output.Nlris[idx]
   542  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   543  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   544  	}
   545  }
   546  
   547  func Test_MpReachNLRIAttribute_EVPN_MC_Route(t *testing.T) {
   548  	assert := assert.New(t)
   549  
   550  	nlris := make([]*any.Any, 0, 1)
   551  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherFourOctetAS{
   552  		Admin:    65000,
   553  		Assigned: 100,
   554  	})
   555  	assert.Nil(err)
   556  	a, err := ptypes.MarshalAny(&api.EVPNInclusiveMulticastEthernetTagRoute{
   557  		Rd:          rd,
   558  		EthernetTag: 100,
   559  		IpAddress:   "192.168.101.1",
   560  	})
   561  	assert.Nil(err)
   562  	nlris = append(nlris, a)
   563  
   564  	input := &api.MpReachNLRIAttribute{
   565  		Family: &api.Family{
   566  			Afi:  api.Family_AFI_L2VPN,
   567  			Safi: api.Family_SAFI_EVPN,
   568  		},
   569  		NextHops: []string{"192.168.1.1"},
   570  		Nlris:    nlris,
   571  	}
   572  
   573  	a, err = ptypes.MarshalAny(input)
   574  	assert.Nil(err)
   575  	n, err := unmarshalAttribute(a)
   576  	assert.Nil(err)
   577  
   578  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   579  	assert.Equal(input.Family, output.Family)
   580  	assert.Equal(input.NextHops, output.NextHops)
   581  	assert.Equal(1, len(output.Nlris))
   582  	for idx, inputNLRI := range input.Nlris {
   583  		outputNLRI := output.Nlris[idx]
   584  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   585  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   586  	}
   587  }
   588  
   589  func Test_MpReachNLRIAttribute_EVPN_ES_Route(t *testing.T) {
   590  	assert := assert.New(t)
   591  
   592  	nlris := make([]*any.Any, 0, 1)
   593  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
   594  		Admin:    "1.1.1.1",
   595  		Assigned: 100,
   596  	})
   597  	assert.Nil(err)
   598  	esi := &api.EthernetSegmentIdentifier{
   599  		Type:  0,
   600  		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
   601  	}
   602  	a, err := ptypes.MarshalAny(&api.EVPNEthernetSegmentRoute{
   603  		Rd:        rd,
   604  		Esi:       esi,
   605  		IpAddress: "192.168.101.1",
   606  	})
   607  	assert.Nil(err)
   608  	nlris = append(nlris, a)
   609  
   610  	input := &api.MpReachNLRIAttribute{
   611  		Family: &api.Family{
   612  			Afi:  api.Family_AFI_L2VPN,
   613  			Safi: api.Family_SAFI_EVPN,
   614  		},
   615  		NextHops: []string{"192.168.1.1"},
   616  		Nlris:    nlris,
   617  	}
   618  
   619  	a, err = ptypes.MarshalAny(input)
   620  	assert.Nil(err)
   621  	n, err := unmarshalAttribute(a)
   622  	assert.Nil(err)
   623  
   624  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   625  	assert.Equal(input.Family, output.Family)
   626  	assert.Equal(input.NextHops, output.NextHops)
   627  	assert.Equal(1, len(output.Nlris))
   628  	for idx, inputNLRI := range input.Nlris {
   629  		outputNLRI := output.Nlris[idx]
   630  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   631  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   632  	}
   633  }
   634  
   635  func Test_MpReachNLRIAttribute_EVPN_Prefix_Route(t *testing.T) {
   636  	assert := assert.New(t)
   637  
   638  	nlris := make([]*any.Any, 0, 1)
   639  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
   640  		Admin:    "1.1.1.1",
   641  		Assigned: 100,
   642  	})
   643  	assert.Nil(err)
   644  	esi := &api.EthernetSegmentIdentifier{
   645  		Type:  0,
   646  		Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
   647  	}
   648  	a, err := ptypes.MarshalAny(&api.EVPNIPPrefixRoute{
   649  		Rd:          rd,
   650  		Esi:         esi,
   651  		EthernetTag: 100,
   652  		IpPrefixLen: 24,
   653  		IpPrefix:    "192.168.101.0",
   654  		Label:       200,
   655  		GwAddress:   "172.16.101.1",
   656  	})
   657  	assert.Nil(err)
   658  	nlris = append(nlris, a)
   659  
   660  	input := &api.MpReachNLRIAttribute{
   661  		Family: &api.Family{
   662  			Afi:  api.Family_AFI_L2VPN,
   663  			Safi: api.Family_SAFI_EVPN,
   664  		},
   665  		NextHops: []string{"192.168.1.1"},
   666  		Nlris:    nlris,
   667  	}
   668  
   669  	a, err = ptypes.MarshalAny(input)
   670  	assert.Nil(err)
   671  	n, err := unmarshalAttribute(a)
   672  	assert.Nil(err)
   673  
   674  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   675  	assert.Equal(input.Family, output.Family)
   676  	assert.Equal(input.NextHops, output.NextHops)
   677  	assert.Equal(1, len(output.Nlris))
   678  	for idx, inputNLRI := range input.Nlris {
   679  		outputNLRI := output.Nlris[idx]
   680  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   681  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   682  	}
   683  }
   684  
   685  func Test_MpReachNLRIAttribute_IPv4_VPN(t *testing.T) {
   686  	assert := assert.New(t)
   687  
   688  	nlris := make([]*any.Any, 0, 1)
   689  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
   690  		Admin:    "1.1.1.1",
   691  		Assigned: 100,
   692  	})
   693  	assert.Nil(err)
   694  	a, err := ptypes.MarshalAny(&api.LabeledVPNIPAddressPrefix{
   695  		Labels:    []uint32{100, 200},
   696  		Rd:        rd,
   697  		PrefixLen: 24,
   698  		Prefix:    "192.168.101.0",
   699  	})
   700  	assert.Nil(err)
   701  	nlris = append(nlris, a)
   702  
   703  	input := &api.MpReachNLRIAttribute{
   704  		Family: &api.Family{
   705  			Afi:  api.Family_AFI_IP,
   706  			Safi: api.Family_SAFI_MPLS_VPN,
   707  		},
   708  		NextHops: []string{"192.168.1.1"},
   709  		Nlris:    nlris,
   710  	}
   711  
   712  	a, err = ptypes.MarshalAny(input)
   713  	assert.Nil(err)
   714  	n, err := unmarshalAttribute(a)
   715  	assert.Nil(err)
   716  
   717  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   718  	assert.Equal(input.Family, output.Family)
   719  	assert.Equal(input.NextHops, output.NextHops)
   720  	assert.Equal(1, len(output.Nlris))
   721  	for idx, inputNLRI := range input.Nlris {
   722  		outputNLRI := output.Nlris[idx]
   723  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   724  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   725  	}
   726  }
   727  
   728  func Test_MpReachNLRIAttribute_IPv6_VPN(t *testing.T) {
   729  	assert := assert.New(t)
   730  
   731  	nlris := make([]*any.Any, 0, 1)
   732  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
   733  		Admin:    "1.1.1.1",
   734  		Assigned: 100,
   735  	})
   736  	assert.Nil(err)
   737  	a, err := ptypes.MarshalAny(&api.LabeledVPNIPAddressPrefix{
   738  		Labels:    []uint32{100, 200},
   739  		Rd:        rd,
   740  		PrefixLen: 64,
   741  		Prefix:    "2001:db8:1::",
   742  	})
   743  	assert.Nil(err)
   744  	nlris = append(nlris, a)
   745  
   746  	input := &api.MpReachNLRIAttribute{
   747  		Family: &api.Family{
   748  			Afi:  api.Family_AFI_IP6,
   749  			Safi: api.Family_SAFI_MPLS_VPN,
   750  		},
   751  		NextHops: []string{"2001:db8::1"},
   752  		Nlris:    nlris,
   753  	}
   754  
   755  	a, err = ptypes.MarshalAny(input)
   756  	assert.Nil(err)
   757  	n, err := unmarshalAttribute(a)
   758  	assert.Nil(err)
   759  
   760  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   761  	assert.Equal(input.Family, output.Family)
   762  	assert.Equal(input.NextHops, output.NextHops)
   763  	assert.Equal(1, len(output.Nlris))
   764  	for idx, inputNLRI := range input.Nlris {
   765  		outputNLRI := output.Nlris[idx]
   766  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   767  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   768  	}
   769  }
   770  
   771  func Test_MpReachNLRIAttribute_RTC_UC(t *testing.T) {
   772  	assert := assert.New(t)
   773  
   774  	nlris := make([]*any.Any, 0, 1)
   775  	rt, err := ptypes.MarshalAny(&api.IPv4AddressSpecificExtended{
   776  		IsTransitive: true,
   777  		SubType:      0x02, // Route Target
   778  		Address:      "1.1.1.1",
   779  		LocalAdmin:   100,
   780  	})
   781  	assert.Nil(err)
   782  	a, err := ptypes.MarshalAny(&api.RouteTargetMembershipNLRI{
   783  		As: 65000,
   784  		Rt: rt,
   785  	})
   786  	assert.Nil(err)
   787  	nlris = append(nlris, a)
   788  
   789  	input := &api.MpReachNLRIAttribute{
   790  		Family: &api.Family{
   791  			Afi:  api.Family_AFI_IP,
   792  			Safi: api.Family_SAFI_ROUTE_TARGET_CONSTRAINTS,
   793  		},
   794  		NextHops: []string{"192.168.1.1"},
   795  		Nlris:    nlris,
   796  	}
   797  
   798  	a, err = ptypes.MarshalAny(input)
   799  	assert.Nil(err)
   800  	n, err := unmarshalAttribute(a)
   801  	assert.Nil(err)
   802  
   803  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   804  	assert.Equal(input.Family, output.Family)
   805  	assert.Equal(input.NextHops, output.NextHops)
   806  	assert.Equal(1, len(output.Nlris))
   807  	for idx, inputNLRI := range input.Nlris {
   808  		outputNLRI := output.Nlris[idx]
   809  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   810  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   811  	}
   812  }
   813  
   814  func Test_MpReachNLRIAttribute_FS_IPv4_UC(t *testing.T) {
   815  	assert := assert.New(t)
   816  
   817  	rules := make([]*any.Any, 0, 3)
   818  	rule, err := ptypes.MarshalAny(&api.FlowSpecIPPrefix{
   819  		Type:      1, // Destination Prefix
   820  		PrefixLen: 24,
   821  		Prefix:    "192.168.101.0",
   822  	})
   823  	assert.Nil(err)
   824  	rules = append(rules, rule)
   825  	rule, err = ptypes.MarshalAny(&api.FlowSpecIPPrefix{
   826  		Type:      2, // Source Prefix
   827  		PrefixLen: 24,
   828  		Prefix:    "192.168.201.0",
   829  	})
   830  	assert.Nil(err)
   831  	rules = append(rules, rule)
   832  	rule, err = ptypes.MarshalAny(&api.FlowSpecComponent{
   833  		Type: 3, // IP Protocol
   834  		Items: []*api.FlowSpecComponentItem{
   835  			{
   836  				Op:    0x80 | 0x01, // End, EQ
   837  				Value: 6,           // TCP
   838  			},
   839  		},
   840  	})
   841  	assert.Nil(err)
   842  	rules = append(rules, rule)
   843  
   844  	nlris := make([]*any.Any, 0, 1)
   845  	a, err := ptypes.MarshalAny(&api.FlowSpecNLRI{
   846  		Rules: rules,
   847  	})
   848  	assert.Nil(err)
   849  	nlris = append(nlris, a)
   850  
   851  	input := &api.MpReachNLRIAttribute{
   852  		Family: &api.Family{
   853  			Afi:  api.Family_AFI_IP,
   854  			Safi: api.Family_SAFI_FLOW_SPEC_UNICAST,
   855  		},
   856  		// NextHops: // No nexthop required
   857  		Nlris: nlris,
   858  	}
   859  
   860  	a, err = ptypes.MarshalAny(input)
   861  	assert.Nil(err)
   862  	n, err := unmarshalAttribute(a)
   863  	assert.Nil(err)
   864  
   865  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   866  	assert.Equal(input.Family, output.Family)
   867  	assert.Equal(input.NextHops, output.NextHops)
   868  	assert.Equal(1, len(output.Nlris))
   869  	for idx, inputNLRI := range input.Nlris {
   870  		outputNLRI := output.Nlris[idx]
   871  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   872  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   873  	}
   874  }
   875  
   876  func Test_MpReachNLRIAttribute_FS_IPv4_VPN(t *testing.T) {
   877  	assert := assert.New(t)
   878  
   879  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
   880  		Admin:    "1.1.1.1",
   881  		Assigned: 100,
   882  	})
   883  	assert.Nil(err)
   884  
   885  	rules := make([]*any.Any, 0, 3)
   886  	rule, err := ptypes.MarshalAny(&api.FlowSpecIPPrefix{
   887  		Type:      1, // Destination Prefix
   888  		PrefixLen: 24,
   889  		Prefix:    "192.168.101.0",
   890  	})
   891  	assert.Nil(err)
   892  	rules = append(rules, rule)
   893  	rule, err = ptypes.MarshalAny(&api.FlowSpecIPPrefix{
   894  		Type:      2, // Source Prefix
   895  		PrefixLen: 24,
   896  		Prefix:    "192.168.201.0",
   897  	})
   898  	assert.Nil(err)
   899  	rules = append(rules, rule)
   900  	rule, err = ptypes.MarshalAny(&api.FlowSpecComponent{
   901  		Type: 3, // IP Protocol
   902  		Items: []*api.FlowSpecComponentItem{
   903  			{
   904  				Op:    0x80 | 0x01, // End, EQ
   905  				Value: 6,           // TCP
   906  			},
   907  		},
   908  	})
   909  	assert.Nil(err)
   910  	rules = append(rules, rule)
   911  
   912  	nlris := make([]*any.Any, 0, 1)
   913  	a, err := ptypes.MarshalAny(&api.VPNFlowSpecNLRI{
   914  		Rd:    rd,
   915  		Rules: rules,
   916  	})
   917  	assert.Nil(err)
   918  	nlris = append(nlris, a)
   919  
   920  	input := &api.MpReachNLRIAttribute{
   921  		Family: &api.Family{
   922  			Afi:  api.Family_AFI_IP,
   923  			Safi: api.Family_SAFI_FLOW_SPEC_VPN,
   924  		},
   925  		// NextHops: // No nexthop required
   926  		Nlris: nlris,
   927  	}
   928  
   929  	a, err = ptypes.MarshalAny(input)
   930  	assert.Nil(err)
   931  	n, err := unmarshalAttribute(a)
   932  	assert.Nil(err)
   933  
   934  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   935  	assert.Equal(input.Family, output.Family)
   936  	assert.Equal(input.NextHops, output.NextHops)
   937  	assert.Equal(1, len(output.Nlris))
   938  	for idx, inputNLRI := range input.Nlris {
   939  		outputNLRI := output.Nlris[idx]
   940  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
   941  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
   942  	}
   943  }
   944  
   945  func Test_MpReachNLRIAttribute_FS_IPv6_UC(t *testing.T) {
   946  	assert := assert.New(t)
   947  
   948  	rules := make([]*any.Any, 0, 3)
   949  	rule, err := ptypes.MarshalAny(&api.FlowSpecIPPrefix{
   950  		Type:      1, // Destination Prefix
   951  		PrefixLen: 64,
   952  		Prefix:    "2001:db8:1::",
   953  	})
   954  	assert.Nil(err)
   955  	rules = append(rules, rule)
   956  	rule, err = ptypes.MarshalAny(&api.FlowSpecIPPrefix{
   957  		Type:      2, // Source Prefix
   958  		PrefixLen: 64,
   959  		Prefix:    "2001:db8:2::",
   960  	})
   961  	assert.Nil(err)
   962  	rules = append(rules, rule)
   963  	rule, err = ptypes.MarshalAny(&api.FlowSpecComponent{
   964  		Type: 3, // Next Header
   965  		Items: []*api.FlowSpecComponentItem{
   966  			{
   967  				Op:    0x80 | 0x01, // End, EQ
   968  				Value: 6,           // TCP
   969  			},
   970  		},
   971  	})
   972  	assert.Nil(err)
   973  	rules = append(rules, rule)
   974  
   975  	nlris := make([]*any.Any, 0, 1)
   976  	a, err := ptypes.MarshalAny(&api.FlowSpecNLRI{
   977  		Rules: rules,
   978  	})
   979  	assert.Nil(err)
   980  	nlris = append(nlris, a)
   981  
   982  	input := &api.MpReachNLRIAttribute{
   983  		Family: &api.Family{
   984  			Afi:  api.Family_AFI_IP6,
   985  			Safi: api.Family_SAFI_FLOW_SPEC_UNICAST,
   986  		},
   987  		// NextHops: // No nexthop required
   988  		Nlris: nlris,
   989  	}
   990  
   991  	a, err = ptypes.MarshalAny(input)
   992  	assert.Nil(err)
   993  	n, err := unmarshalAttribute(a)
   994  	assert.Nil(err)
   995  
   996  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
   997  	assert.Equal(input.Family, output.Family)
   998  	assert.Equal(input.NextHops, output.NextHops)
   999  	assert.Equal(1, len(output.Nlris))
  1000  	for idx, inputNLRI := range input.Nlris {
  1001  		outputNLRI := output.Nlris[idx]
  1002  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
  1003  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
  1004  	}
  1005  }
  1006  
  1007  func Test_MpReachNLRIAttribute_FS_IPv6_VPN(t *testing.T) {
  1008  	assert := assert.New(t)
  1009  
  1010  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
  1011  		Admin:    "1.1.1.1",
  1012  		Assigned: 100,
  1013  	})
  1014  	assert.Nil(err)
  1015  
  1016  	rules := make([]*any.Any, 0, 3)
  1017  	rule, err := ptypes.MarshalAny(&api.FlowSpecIPPrefix{
  1018  		Type:      1, // Destination Prefix
  1019  		PrefixLen: 64,
  1020  		Prefix:    "2001:db8:1::",
  1021  	})
  1022  	assert.Nil(err)
  1023  	rules = append(rules, rule)
  1024  	rule, err = ptypes.MarshalAny(&api.FlowSpecIPPrefix{
  1025  		Type:      2, // Source Prefix
  1026  		PrefixLen: 64,
  1027  		Prefix:    "2001:db8:2::",
  1028  	})
  1029  	assert.Nil(err)
  1030  	rules = append(rules, rule)
  1031  	rule, err = ptypes.MarshalAny(&api.FlowSpecComponent{
  1032  		Type: 3, // Next Header
  1033  		Items: []*api.FlowSpecComponentItem{
  1034  			{
  1035  				Op:    0x80 | 0x01, // End, EQ
  1036  				Value: 6,           // TCP
  1037  			},
  1038  		},
  1039  	})
  1040  	assert.Nil(err)
  1041  	rules = append(rules, rule)
  1042  
  1043  	nlris := make([]*any.Any, 0, 1)
  1044  	a, err := ptypes.MarshalAny(&api.VPNFlowSpecNLRI{
  1045  		Rd:    rd,
  1046  		Rules: rules,
  1047  	})
  1048  	assert.Nil(err)
  1049  	nlris = append(nlris, a)
  1050  
  1051  	input := &api.MpReachNLRIAttribute{
  1052  		Family: &api.Family{
  1053  			Afi:  api.Family_AFI_IP6,
  1054  			Safi: api.Family_SAFI_FLOW_SPEC_VPN,
  1055  		},
  1056  		// NextHops: // No nexthop required
  1057  		Nlris: nlris,
  1058  	}
  1059  
  1060  	a, err = ptypes.MarshalAny(input)
  1061  	assert.Nil(err)
  1062  	n, err := unmarshalAttribute(a)
  1063  	assert.Nil(err)
  1064  
  1065  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
  1066  	assert.Equal(input.Family, output.Family)
  1067  	assert.Equal(input.NextHops, output.NextHops)
  1068  	assert.Equal(1, len(output.Nlris))
  1069  	for idx, inputNLRI := range input.Nlris {
  1070  		outputNLRI := output.Nlris[idx]
  1071  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
  1072  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
  1073  	}
  1074  }
  1075  
  1076  func Test_MpReachNLRIAttribute_FS_L2_VPN(t *testing.T) {
  1077  	assert := assert.New(t)
  1078  
  1079  	rd, err := ptypes.MarshalAny(&api.RouteDistinguisherIPAddress{
  1080  		Admin:    "1.1.1.1",
  1081  		Assigned: 100,
  1082  	})
  1083  	assert.Nil(err)
  1084  
  1085  	rules := make([]*any.Any, 0, 3)
  1086  	rule, err := ptypes.MarshalAny(&api.FlowSpecMAC{
  1087  		Type:    15, // Source MAC
  1088  		Address: "aa:bb:cc:11:22:33",
  1089  	})
  1090  	assert.Nil(err)
  1091  	rules = append(rules, rule)
  1092  	rule, err = ptypes.MarshalAny(&api.FlowSpecMAC{
  1093  		Type:    16, // Destination MAC
  1094  		Address: "dd:ee:ff:11:22:33",
  1095  	})
  1096  	assert.Nil(err)
  1097  	rules = append(rules, rule)
  1098  	rule, err = ptypes.MarshalAny(&api.FlowSpecComponent{
  1099  		Type: 21, // VLAN ID
  1100  		Items: []*api.FlowSpecComponentItem{
  1101  			{
  1102  				Op:    0x80 | 0x01, // End, EQ
  1103  				Value: 100,
  1104  			},
  1105  		},
  1106  	})
  1107  	assert.Nil(err)
  1108  	rules = append(rules, rule)
  1109  
  1110  	nlris := make([]*any.Any, 0, 1)
  1111  	a, err := ptypes.MarshalAny(&api.VPNFlowSpecNLRI{
  1112  		Rd:    rd,
  1113  		Rules: rules,
  1114  	})
  1115  	assert.Nil(err)
  1116  	nlris = append(nlris, a)
  1117  
  1118  	input := &api.MpReachNLRIAttribute{
  1119  		Family: &api.Family{
  1120  			Afi:  api.Family_AFI_L2VPN,
  1121  			Safi: api.Family_SAFI_FLOW_SPEC_VPN,
  1122  		},
  1123  		// NextHops: // No nexthop required
  1124  		Nlris: nlris,
  1125  	}
  1126  
  1127  	a, err = ptypes.MarshalAny(input)
  1128  	assert.Nil(err)
  1129  	n, err := unmarshalAttribute(a)
  1130  	assert.Nil(err)
  1131  
  1132  	output := NewMpReachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpReachNLRI))
  1133  	assert.Equal(input.Family, output.Family)
  1134  	assert.Equal(input.NextHops, output.NextHops)
  1135  	assert.Equal(1, len(output.Nlris))
  1136  	for idx, inputNLRI := range input.Nlris {
  1137  		outputNLRI := output.Nlris[idx]
  1138  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
  1139  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
  1140  	}
  1141  }
  1142  
  1143  func Test_MpUnreachNLRIAttribute_IPv4_UC(t *testing.T) {
  1144  	assert := assert.New(t)
  1145  
  1146  	nlris := make([]*any.Any, 0, 2)
  1147  	a, err := ptypes.MarshalAny(&api.IPAddressPrefix{
  1148  		PrefixLen: 24,
  1149  		Prefix:    "192.168.101.0",
  1150  	})
  1151  	assert.Nil(err)
  1152  	nlris = append(nlris, a)
  1153  	a, err = ptypes.MarshalAny(&api.IPAddressPrefix{
  1154  		PrefixLen: 24,
  1155  		Prefix:    "192.168.201.0",
  1156  	})
  1157  	assert.Nil(err)
  1158  	nlris = append(nlris, a)
  1159  
  1160  	input := &api.MpUnreachNLRIAttribute{
  1161  		Family: &api.Family{
  1162  			Afi:  api.Family_AFI_IP,
  1163  			Safi: api.Family_SAFI_UNICAST,
  1164  		},
  1165  		Nlris: nlris,
  1166  	}
  1167  
  1168  	a, err = ptypes.MarshalAny(input)
  1169  	assert.Nil(err)
  1170  	n, err := unmarshalAttribute(a)
  1171  	assert.Nil(err)
  1172  
  1173  	output := NewMpUnreachNLRIAttributeFromNative(n.(*bgp.PathAttributeMpUnreachNLRI))
  1174  	assert.Equal(input.Family, output.Family)
  1175  	assert.Equal(2, len(output.Nlris))
  1176  	for idx, inputNLRI := range input.Nlris {
  1177  		outputNLRI := output.Nlris[idx]
  1178  		assert.Equal(inputNLRI.TypeUrl, outputNLRI.TypeUrl)
  1179  		assert.Equal(inputNLRI.Value, outputNLRI.Value)
  1180  	}
  1181  }
  1182  
  1183  func Test_ExtendedCommunitiesAttribute(t *testing.T) {
  1184  	assert := assert.New(t)
  1185  
  1186  	communities := make([]*any.Any, 0, 19)
  1187  	a, err := ptypes.MarshalAny(&api.TwoOctetAsSpecificExtended{
  1188  		IsTransitive: true,
  1189  		SubType:      0x02, // ROUTE_TARGET
  1190  		As:           65001,
  1191  		LocalAdmin:   100,
  1192  	})
  1193  	assert.Nil(err)
  1194  	communities = append(communities, a)
  1195  	a, err = ptypes.MarshalAny(&api.IPv4AddressSpecificExtended{
  1196  		IsTransitive: true,
  1197  		SubType:      0x02, // ROUTE_TARGET
  1198  		Address:      "2.2.2.2",
  1199  		LocalAdmin:   200,
  1200  	})
  1201  	assert.Nil(err)
  1202  	communities = append(communities, a)
  1203  	a, err = ptypes.MarshalAny(&api.FourOctetAsSpecificExtended{
  1204  		IsTransitive: true,
  1205  		SubType:      0x02, // ROUTE_TARGET
  1206  		As:           65003,
  1207  		LocalAdmin:   300,
  1208  	})
  1209  	assert.Nil(err)
  1210  	communities = append(communities, a)
  1211  	a, err = ptypes.MarshalAny(&api.ValidationExtended{
  1212  		State: 0, // VALID
  1213  	})
  1214  	assert.Nil(err)
  1215  	communities = append(communities, a)
  1216  	a, err = ptypes.MarshalAny(&api.ColorExtended{
  1217  		Color: 400,
  1218  	})
  1219  	assert.Nil(err)
  1220  	communities = append(communities, a)
  1221  	a, err = ptypes.MarshalAny(&api.EncapExtended{
  1222  		TunnelType: 8, // VXLAN
  1223  	})
  1224  	assert.Nil(err)
  1225  	communities = append(communities, a)
  1226  	a, err = ptypes.MarshalAny(&api.DefaultGatewayExtended{
  1227  		// No value
  1228  	})
  1229  	assert.Nil(err)
  1230  	communities = append(communities, a)
  1231  	a, err = ptypes.MarshalAny(&api.OpaqueExtended{
  1232  		IsTransitive: true,
  1233  		Value:        []byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},
  1234  	})
  1235  	assert.Nil(err)
  1236  	communities = append(communities, a)
  1237  	a, err = ptypes.MarshalAny(&api.ESILabelExtended{
  1238  		IsSingleActive: true,
  1239  		Label:          500,
  1240  	})
  1241  	assert.Nil(err)
  1242  	communities = append(communities, a)
  1243  	a, err = ptypes.MarshalAny(&api.ESImportRouteTarget{
  1244  		EsImport: "aa:bb:cc:dd:ee:ff",
  1245  	})
  1246  	assert.Nil(err)
  1247  	communities = append(communities, a)
  1248  	a, err = ptypes.MarshalAny(&api.MacMobilityExtended{
  1249  		IsSticky:    true,
  1250  		SequenceNum: 1,
  1251  	})
  1252  	assert.Nil(err)
  1253  	communities = append(communities, a)
  1254  	a, err = ptypes.MarshalAny(&api.RouterMacExtended{
  1255  		Mac: "ff:ee:dd:cc:bb:aa",
  1256  	})
  1257  	assert.Nil(err)
  1258  	communities = append(communities, a)
  1259  	a, err = ptypes.MarshalAny(&api.TrafficRateExtended{
  1260  		As:   65004,
  1261  		Rate: 100.0,
  1262  	})
  1263  	assert.Nil(err)
  1264  	communities = append(communities, a)
  1265  	a, err = ptypes.MarshalAny(&api.TrafficActionExtended{
  1266  		Terminal: true,
  1267  		Sample:   false,
  1268  	})
  1269  	assert.Nil(err)
  1270  	communities = append(communities, a)
  1271  	a, err = ptypes.MarshalAny(&api.RedirectTwoOctetAsSpecificExtended{
  1272  		As:         65005,
  1273  		LocalAdmin: 500,
  1274  	})
  1275  	assert.Nil(err)
  1276  	communities = append(communities, a)
  1277  	a, err = ptypes.MarshalAny(&api.RedirectIPv4AddressSpecificExtended{
  1278  		Address:    "6.6.6.6",
  1279  		LocalAdmin: 600,
  1280  	})
  1281  	assert.Nil(err)
  1282  	communities = append(communities, a)
  1283  	a, err = ptypes.MarshalAny(&api.RedirectFourOctetAsSpecificExtended{
  1284  		As:         65007,
  1285  		LocalAdmin: 700,
  1286  	})
  1287  	assert.Nil(err)
  1288  	communities = append(communities, a)
  1289  	a, err = ptypes.MarshalAny(&api.TrafficRemarkExtended{
  1290  		Dscp: 0x0a, // AF11
  1291  	})
  1292  	assert.Nil(err)
  1293  	communities = append(communities, a)
  1294  	a, err = ptypes.MarshalAny(&api.UnknownExtended{
  1295  		Type:  0xff, // Max of uint8
  1296  		Value: []byte{1, 2, 3, 4, 5, 6, 7},
  1297  	})
  1298  	assert.Nil(err)
  1299  	communities = append(communities, a)
  1300  
  1301  	input := &api.ExtendedCommunitiesAttribute{
  1302  		Communities: communities,
  1303  	}
  1304  
  1305  	a, err = ptypes.MarshalAny(input)
  1306  	assert.Nil(err)
  1307  	n, err := unmarshalAttribute(a)
  1308  	assert.Nil(err)
  1309  
  1310  	output := NewExtendedCommunitiesAttributeFromNative(n.(*bgp.PathAttributeExtendedCommunities))
  1311  	assert.Equal(19, len(output.Communities))
  1312  	for idx, inputCommunity := range input.Communities {
  1313  		outputCommunity := output.Communities[idx]
  1314  		assert.Equal(inputCommunity.TypeUrl, outputCommunity.TypeUrl)
  1315  		assert.Equal(inputCommunity.Value, outputCommunity.Value)
  1316  	}
  1317  }
  1318  
  1319  func Test_As4PathAttribute(t *testing.T) {
  1320  	assert := assert.New(t)
  1321  
  1322  	input := &api.As4PathAttribute{
  1323  		Segments: []*api.AsSegment{
  1324  			{
  1325  				Type:    1, // SET
  1326  				Numbers: []uint32{100, 200},
  1327  			},
  1328  			{
  1329  				Type:    2, // SEQ
  1330  				Numbers: []uint32{300, 400},
  1331  			},
  1332  		},
  1333  	}
  1334  
  1335  	a, err := ptypes.MarshalAny(input)
  1336  	assert.Nil(err)
  1337  	n, err := unmarshalAttribute(a)
  1338  	assert.Nil(err)
  1339  
  1340  	output := NewAs4PathAttributeFromNative(n.(*bgp.PathAttributeAs4Path))
  1341  	assert.Equal(2, len(output.Segments))
  1342  	assert.Equal(input.Segments, output.Segments)
  1343  }
  1344  
  1345  func Test_As4AggregatorAttribute(t *testing.T) {
  1346  	assert := assert.New(t)
  1347  
  1348  	input := &api.As4AggregatorAttribute{
  1349  		As:      65000,
  1350  		Address: "1.1.1.1",
  1351  	}
  1352  
  1353  	a, err := ptypes.MarshalAny(input)
  1354  	assert.Nil(err)
  1355  	n, err := unmarshalAttribute(a)
  1356  	assert.Nil(err)
  1357  
  1358  	output := NewAs4AggregatorAttributeFromNative(n.(*bgp.PathAttributeAs4Aggregator))
  1359  	assert.Equal(input.As, output.As)
  1360  	assert.Equal(input.Address, output.Address)
  1361  }
  1362  
  1363  func Test_PmsiTunnelAttribute(t *testing.T) {
  1364  	assert := assert.New(t)
  1365  
  1366  	input := &api.PmsiTunnelAttribute{
  1367  		Flags: 0x01, // IsLeafInfoRequired = true
  1368  		Type:  6,    // INGRESS_REPL
  1369  		Label: 100,
  1370  		Id:    net.ParseIP("1.1.1.1").To4(), // IngressReplTunnelID with IPv4
  1371  	}
  1372  
  1373  	a, err := ptypes.MarshalAny(input)
  1374  	assert.Nil(err)
  1375  	n, err := unmarshalAttribute(a)
  1376  	assert.Nil(err)
  1377  
  1378  	output := NewPmsiTunnelAttributeFromNative(n.(*bgp.PathAttributePmsiTunnel))
  1379  	assert.Equal(input.Flags, output.Flags)
  1380  	assert.Equal(input.Type, output.Type)
  1381  	assert.Equal(input.Label, output.Label)
  1382  	assert.Equal(input.Id, output.Id)
  1383  }
  1384  
  1385  func Test_TunnelEncapAttribute(t *testing.T) {
  1386  	assert := assert.New(t)
  1387  
  1388  	subTlvs := make([]*any.Any, 0, 4)
  1389  	a, err := ptypes.MarshalAny(&api.TunnelEncapSubTLVEncapsulation{
  1390  		Key:    100,
  1391  		Cookie: []byte{0x11, 0x22, 0x33, 0x44},
  1392  	})
  1393  	assert.Nil(err)
  1394  	subTlvs = append(subTlvs, a)
  1395  	a, err = ptypes.MarshalAny(&api.TunnelEncapSubTLVProtocol{
  1396  		Protocol: 200,
  1397  	})
  1398  	assert.Nil(err)
  1399  	subTlvs = append(subTlvs, a)
  1400  	a, err = ptypes.MarshalAny(&api.TunnelEncapSubTLVColor{
  1401  		Color: 300,
  1402  	})
  1403  	assert.Nil(err)
  1404  	subTlvs = append(subTlvs, a)
  1405  	a, err = ptypes.MarshalAny(&api.TunnelEncapSubTLVUnknown{
  1406  		Type:  0xff, // Max of uint8
  1407  		Value: []byte{0x55, 0x66, 0x77, 0x88},
  1408  	})
  1409  	assert.Nil(err)
  1410  	subTlvs = append(subTlvs, a)
  1411  
  1412  	input := &api.TunnelEncapAttribute{
  1413  		Tlvs: []*api.TunnelEncapTLV{
  1414  			{
  1415  				Type: 8, // VXLAN
  1416  				Tlvs: subTlvs,
  1417  			},
  1418  		},
  1419  	}
  1420  
  1421  	a, err = ptypes.MarshalAny(input)
  1422  	assert.Nil(err)
  1423  	n, err := unmarshalAttribute(a)
  1424  	assert.Nil(err)
  1425  
  1426  	output := NewTunnelEncapAttributeFromNative(n.(*bgp.PathAttributeTunnelEncap))
  1427  	assert.Equal(1, len(output.Tlvs))
  1428  	assert.Equal(input.Tlvs[0].Type, output.Tlvs[0].Type)
  1429  	assert.Equal(len(output.Tlvs[0].Tlvs), len(output.Tlvs[0].Tlvs))
  1430  	for idx, inputSubTlv := range input.Tlvs[0].Tlvs {
  1431  		outputSubTlv := output.Tlvs[0].Tlvs[idx]
  1432  		assert.Equal(inputSubTlv.TypeUrl, outputSubTlv.TypeUrl)
  1433  		assert.Equal(inputSubTlv.Value, outputSubTlv.Value)
  1434  	}
  1435  }
  1436  
  1437  func Test_IP6ExtendedCommunitiesAttribute(t *testing.T) {
  1438  	assert := assert.New(t)
  1439  
  1440  	communities := make([]*any.Any, 0, 2)
  1441  	a, err := ptypes.MarshalAny(&api.IPv6AddressSpecificExtended{
  1442  		IsTransitive: true,
  1443  		SubType:      0xff, // Max of uint8
  1444  		Address:      "2001:db8:1::1",
  1445  		LocalAdmin:   100,
  1446  	})
  1447  	assert.Nil(err)
  1448  	communities = append(communities, a)
  1449  	a, err = ptypes.MarshalAny(&api.RedirectIPv6AddressSpecificExtended{
  1450  		Address:    "2001:db8:2::1",
  1451  		LocalAdmin: 200,
  1452  	})
  1453  	assert.Nil(err)
  1454  	communities = append(communities, a)
  1455  
  1456  	input := &api.IP6ExtendedCommunitiesAttribute{
  1457  		Communities: communities,
  1458  	}
  1459  
  1460  	a, err = ptypes.MarshalAny(input)
  1461  	assert.Nil(err)
  1462  	n, err := unmarshalAttribute(a)
  1463  	assert.Nil(err)
  1464  
  1465  	output := NewIP6ExtendedCommunitiesAttributeFromNative(n.(*bgp.PathAttributeIP6ExtendedCommunities))
  1466  	assert.Equal(2, len(output.Communities))
  1467  	for idx, inputCommunity := range input.Communities {
  1468  		outputCommunity := output.Communities[idx]
  1469  		assert.Equal(inputCommunity.TypeUrl, outputCommunity.TypeUrl)
  1470  		assert.Equal(inputCommunity.Value, outputCommunity.Value)
  1471  	}
  1472  }
  1473  
  1474  func Test_AigpAttribute(t *testing.T) {
  1475  	assert := assert.New(t)
  1476  
  1477  	tlvs := make([]*any.Any, 0, 2)
  1478  	a, err := ptypes.MarshalAny(&api.AigpTLVIGPMetric{
  1479  		Metric: 50,
  1480  	})
  1481  	assert.Nil(err)
  1482  	tlvs = append(tlvs, a)
  1483  	a, err = ptypes.MarshalAny(&api.AigpTLVUnknown{
  1484  		Type:  0xff, // Max of uint8
  1485  		Value: []byte{0x11, 0x22, 0x33, 0x44},
  1486  	})
  1487  	assert.Nil(err)
  1488  	tlvs = append(tlvs, a)
  1489  
  1490  	input := &api.AigpAttribute{
  1491  		Tlvs: tlvs,
  1492  	}
  1493  
  1494  	a, err = ptypes.MarshalAny(input)
  1495  	assert.Nil(err)
  1496  	n, err := unmarshalAttribute(a)
  1497  	assert.Nil(err)
  1498  
  1499  	output := NewAigpAttributeFromNative(n.(*bgp.PathAttributeAigp))
  1500  	assert.Equal(2, len(output.Tlvs))
  1501  	for idx, inputTlv := range input.Tlvs {
  1502  		outputTlv := output.Tlvs[idx]
  1503  		assert.Equal(inputTlv.TypeUrl, outputTlv.TypeUrl)
  1504  		assert.Equal(inputTlv.Value, outputTlv.Value)
  1505  	}
  1506  }
  1507  
  1508  func Test_LargeCommunitiesAttribute(t *testing.T) {
  1509  	assert := assert.New(t)
  1510  
  1511  	input := &api.LargeCommunitiesAttribute{
  1512  		Communities: []*api.LargeCommunity{
  1513  			{
  1514  				GlobalAdmin: 65001,
  1515  				LocalData1:  100,
  1516  				LocalData2:  200,
  1517  			},
  1518  			{
  1519  				GlobalAdmin: 65002,
  1520  				LocalData1:  300,
  1521  				LocalData2:  400,
  1522  			},
  1523  		},
  1524  	}
  1525  
  1526  	a, err := ptypes.MarshalAny(input)
  1527  	assert.Nil(err)
  1528  	n, err := unmarshalAttribute(a)
  1529  	assert.Nil(err)
  1530  
  1531  	output := NewLargeCommunitiesAttributeFromNative(n.(*bgp.PathAttributeLargeCommunities))
  1532  	assert.Equal(2, len(output.Communities))
  1533  	assert.Equal(input.Communities, output.Communities)
  1534  }
  1535  
  1536  func Test_UnknownAttribute(t *testing.T) {
  1537  	assert := assert.New(t)
  1538  
  1539  	input := &api.UnknownAttribute{
  1540  		Flags: (1 << 6) | (1 << 7), // OPTIONAL and TRANSITIVE
  1541  		Type:  0xff,
  1542  		Value: []byte{0x11, 0x22, 0x33, 0x44},
  1543  	}
  1544  
  1545  	a, err := ptypes.MarshalAny(input)
  1546  	assert.Nil(err)
  1547  	n, err := unmarshalAttribute(a)
  1548  	assert.Nil(err)
  1549  
  1550  	output := NewUnknownAttributeFromNative(n.(*bgp.PathAttributeUnknown))
  1551  	assert.Equal(input.Flags, output.Flags)
  1552  	assert.Equal(input.Type, output.Type)
  1553  	assert.Equal(input.Value, output.Value)
  1554  }