github.com/gophercloud/gophercloud@v1.14.1/internal/acceptance/openstack/networking/v2/extensions/bgpvpns/bgpvpns_test.go (about)

     1  //go:build acceptance || networking || bgp || bgpvpns
     2  
     3  package bgpvpns
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
     9  	networking "github.com/gophercloud/gophercloud/internal/acceptance/openstack/networking/v2"
    10  	"github.com/gophercloud/gophercloud/internal/acceptance/openstack/networking/v2/extensions/layer3"
    11  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    12  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/bgpvpns"
    13  	th "github.com/gophercloud/gophercloud/testhelper"
    14  )
    15  
    16  func TestBGPVPNCRUD(t *testing.T) {
    17  	clients.RequireAdmin(t)
    18  
    19  	client, err := clients.NewNetworkV2Client()
    20  	th.AssertNoErr(t, err)
    21  
    22  	// Create a BGP VPN
    23  	bgpVpnCreated, err := CreateBGPVPN(t, client)
    24  	th.AssertNoErr(t, err)
    25  
    26  	// Get a BGP VPN
    27  	bgpVpnGot, err := bgpvpns.Get(client, bgpVpnCreated.ID).Extract()
    28  	th.AssertNoErr(t, err)
    29  	th.AssertEquals(t, bgpVpnCreated.ID, bgpVpnGot.ID)
    30  	th.AssertEquals(t, bgpVpnCreated.Name, bgpVpnGot.Name)
    31  
    32  	// Update a BGP VPN
    33  	newBGPVPNName := tools.RandomString("TESTACC-BGPVPN-", 10)
    34  	updateBGPOpts := bgpvpns.UpdateOpts{
    35  		Name: &newBGPVPNName,
    36  	}
    37  	bgpVpnUpdated, err := bgpvpns.Update(client, bgpVpnGot.ID, updateBGPOpts).Extract()
    38  	th.AssertNoErr(t, err)
    39  	th.AssertEquals(t, newBGPVPNName, bgpVpnUpdated.Name)
    40  	t.Logf("Update BGP VPN, renamed from %s to %s", bgpVpnGot.Name, bgpVpnUpdated.Name)
    41  
    42  	// List all BGP VPNs
    43  	allPages, err := bgpvpns.List(client, bgpvpns.ListOpts{}).AllPages()
    44  	th.AssertNoErr(t, err)
    45  	allVPNs, err := bgpvpns.ExtractBGPVPNs(allPages)
    46  	th.AssertNoErr(t, err)
    47  
    48  	t.Logf("Retrieved BGP VPNs")
    49  	tools.PrintResource(t, allVPNs)
    50  	th.AssertIntGreaterOrEqual(t, len(allVPNs), 1)
    51  
    52  	// Delete a BGP VPN
    53  	t.Logf("Attempting to delete BGP VPN: %s", bgpVpnUpdated.Name)
    54  	err = bgpvpns.Delete(client, bgpVpnUpdated.ID).ExtractErr()
    55  	th.AssertNoErr(t, err)
    56  
    57  	_, err = bgpvpns.Get(client, bgpVpnGot.ID).Extract()
    58  	th.AssertErr(t, err)
    59  	t.Logf("BGP VPN %s deleted", bgpVpnUpdated.Name)
    60  }
    61  
    62  func TestBGPVPNNetworkAssociationCRD(t *testing.T) {
    63  	clients.RequireAdmin(t)
    64  
    65  	client, err := clients.NewNetworkV2Client()
    66  	th.AssertNoErr(t, err)
    67  
    68  	// Create a BGP VPN
    69  	bgpVpnCreated, err := CreateBGPVPN(t, client)
    70  	th.AssertNoErr(t, err)
    71  	defer func() {
    72  		err = bgpvpns.Delete(client, bgpVpnCreated.ID).ExtractErr()
    73  		th.AssertNoErr(t, err)
    74  	}()
    75  
    76  	// Create a Network
    77  	network, err := networking.CreateNetwork(t, client)
    78  	th.AssertNoErr(t, err)
    79  	defer networking.DeleteNetwork(t, client, network.ID)
    80  
    81  	// Associate a Network with a BGP VPN
    82  	assocOpts := bgpvpns.CreateNetworkAssociationOpts{
    83  		NetworkID: network.ID,
    84  	}
    85  	assoc, err := bgpvpns.CreateNetworkAssociation(client, bgpVpnCreated.ID, assocOpts).Extract()
    86  	th.AssertNoErr(t, err)
    87  	defer func() {
    88  		err = bgpvpns.DeleteNetworkAssociation(client, bgpVpnCreated.ID, assoc.ID).ExtractErr()
    89  		th.AssertNoErr(t, err)
    90  	}()
    91  	th.AssertEquals(t, network.ID, assoc.NetworkID)
    92  
    93  	// Get a Network Association
    94  	assocGot, err := bgpvpns.GetNetworkAssociation(client, bgpVpnCreated.ID, assoc.ID).Extract()
    95  	th.AssertNoErr(t, err)
    96  	th.AssertEquals(t, network.ID, assocGot.NetworkID)
    97  
    98  	// List all Network Associations
    99  	allPages, err := bgpvpns.ListNetworkAssociations(client, bgpVpnCreated.ID, bgpvpns.ListNetworkAssociationsOpts{}).AllPages()
   100  	th.AssertNoErr(t, err)
   101  	allAssocs, err := bgpvpns.ExtractNetworkAssociations(allPages)
   102  	th.AssertNoErr(t, err)
   103  	t.Logf("Retrieved Network Associations")
   104  	tools.PrintResource(t, allAssocs)
   105  	th.AssertIntGreaterOrEqual(t, len(allAssocs), 1)
   106  
   107  	// Get BGP VPN with associations
   108  	getBgpVpn, err := bgpvpns.Get(client, bgpVpnCreated.ID).Extract()
   109  	th.AssertNoErr(t, err)
   110  	tools.PrintResource(t, getBgpVpn)
   111  }
   112  
   113  func TestBGPVPNRouterAssociationCRUD(t *testing.T) {
   114  	clients.RequireAdmin(t)
   115  
   116  	client, err := clients.NewNetworkV2Client()
   117  	th.AssertNoErr(t, err)
   118  
   119  	// Create a BGP VPN
   120  	bgpVpnCreated, err := CreateBGPVPN(t, client)
   121  	th.AssertNoErr(t, err)
   122  	defer func() {
   123  		err = bgpvpns.Delete(client, bgpVpnCreated.ID).ExtractErr()
   124  		th.AssertNoErr(t, err)
   125  	}()
   126  
   127  	// Create a Network
   128  	network, err := networking.CreateNetwork(t, client)
   129  	th.AssertNoErr(t, err)
   130  	defer networking.DeleteNetwork(t, client, network.ID)
   131  
   132  	// Create a Router
   133  	routerCreated, err := layer3.CreateRouter(t, client, network.ID)
   134  	th.AssertNoErr(t, err)
   135  	defer layer3.DeleteRouter(t, client, routerCreated.ID)
   136  
   137  	// Associate a Router with a BGP VPN
   138  	assocOpts := bgpvpns.CreateRouterAssociationOpts{
   139  		RouterID: routerCreated.ID,
   140  	}
   141  	assoc, err := bgpvpns.CreateRouterAssociation(client, bgpVpnCreated.ID, assocOpts).Extract()
   142  	th.AssertNoErr(t, err)
   143  	defer func() {
   144  		err = bgpvpns.DeleteRouterAssociation(client, bgpVpnCreated.ID, assoc.ID).ExtractErr()
   145  		th.AssertNoErr(t, err)
   146  	}()
   147  	th.AssertEquals(t, routerCreated.ID, assoc.RouterID)
   148  
   149  	// Get a Router Association
   150  	assocGot, err := bgpvpns.GetRouterAssociation(client, bgpVpnCreated.ID, assoc.ID).Extract()
   151  	th.AssertNoErr(t, err)
   152  	th.AssertEquals(t, routerCreated.ID, assocGot.RouterID)
   153  
   154  	// Update a Router Association
   155  	assocUpdOpts := bgpvpns.UpdateRouterAssociationOpts{
   156  		AdvertiseExtraRoutes: new(bool),
   157  	}
   158  	assocUpdate, err := bgpvpns.UpdateRouterAssociation(client, bgpVpnCreated.ID, assoc.ID, assocUpdOpts).Extract()
   159  	th.AssertNoErr(t, err)
   160  	th.AssertEquals(t, routerCreated.ID, assocUpdate.RouterID)
   161  	th.AssertEquals(t, false, assocUpdate.AdvertiseExtraRoutes)
   162  
   163  	// List all Router Associations
   164  	allPages, err := bgpvpns.ListRouterAssociations(client, bgpVpnCreated.ID, bgpvpns.ListRouterAssociationsOpts{}).AllPages()
   165  	th.AssertNoErr(t, err)
   166  	allAssocs, err := bgpvpns.ExtractRouterAssociations(allPages)
   167  	th.AssertNoErr(t, err)
   168  	t.Logf("Retrieved Router Associations")
   169  	tools.PrintResource(t, allAssocs)
   170  	th.AssertIntGreaterOrEqual(t, len(allAssocs), 1)
   171  
   172  	// Get BGP VPN with associations
   173  	getBgpVpn, err := bgpvpns.Get(client, bgpVpnCreated.ID).Extract()
   174  	th.AssertNoErr(t, err)
   175  	tools.PrintResource(t, getBgpVpn)
   176  }
   177  
   178  func TestBGPVPNPortAssociationCRUD(t *testing.T) {
   179  	clients.RequireAdmin(t)
   180  
   181  	client, err := clients.NewNetworkV2Client()
   182  	th.AssertNoErr(t, err)
   183  
   184  	// Create a BGP VPN
   185  	bgpVpnCreated, err := CreateBGPVPN(t, client)
   186  	th.AssertNoErr(t, err)
   187  	defer func() {
   188  		err = bgpvpns.Delete(client, bgpVpnCreated.ID).ExtractErr()
   189  		th.AssertNoErr(t, err)
   190  	}()
   191  
   192  	// Create a Network
   193  	network, err := networking.CreateNetwork(t, client)
   194  	th.AssertNoErr(t, err)
   195  	defer networking.DeleteNetwork(t, client, network.ID)
   196  
   197  	// Create Subnet
   198  	subnet, err := networking.CreateSubnet(t, client, network.ID)
   199  	th.AssertNoErr(t, err)
   200  	defer networking.DeleteSubnet(t, client, subnet.ID)
   201  
   202  	// Create port
   203  	port, err := networking.CreatePort(t, client, network.ID, subnet.ID)
   204  	th.AssertNoErr(t, err)
   205  	defer networking.DeletePort(t, client, port.ID)
   206  
   207  	// Associate a Port with a BGP VPN
   208  	assocOpts := bgpvpns.CreatePortAssociationOpts{
   209  		PortID: port.ID,
   210  	}
   211  	assoc, err := bgpvpns.CreatePortAssociation(client, bgpVpnCreated.ID, assocOpts).Extract()
   212  	th.AssertNoErr(t, err)
   213  	defer func() {
   214  		err = bgpvpns.DeletePortAssociation(client, bgpVpnCreated.ID, assoc.ID).ExtractErr()
   215  		th.AssertNoErr(t, err)
   216  	}()
   217  	th.AssertEquals(t, port.ID, assoc.PortID)
   218  
   219  	// Get a Port Association
   220  	assocGot, err := bgpvpns.GetPortAssociation(client, bgpVpnCreated.ID, assoc.ID).Extract()
   221  	th.AssertNoErr(t, err)
   222  	th.AssertEquals(t, port.ID, assocGot.PortID)
   223  
   224  	// Update a Port Association
   225  	assocUpdOpts := bgpvpns.UpdatePortAssociationOpts{
   226  		AdvertiseFixedIPs: new(bool),
   227  	}
   228  	assocUpdate, err := bgpvpns.UpdatePortAssociation(client, bgpVpnCreated.ID, assoc.ID, assocUpdOpts).Extract()
   229  	th.AssertNoErr(t, err)
   230  	th.AssertEquals(t, port.ID, assocUpdate.PortID)
   231  	th.AssertEquals(t, false, assocUpdate.AdvertiseFixedIPs)
   232  
   233  	// List all Port Associations
   234  	allPages, err := bgpvpns.ListPortAssociations(client, bgpVpnCreated.ID, bgpvpns.ListPortAssociationsOpts{}).AllPages()
   235  	th.AssertNoErr(t, err)
   236  	allAssocs, err := bgpvpns.ExtractPortAssociations(allPages)
   237  	th.AssertNoErr(t, err)
   238  	t.Logf("Retrieved Port Associations")
   239  	tools.PrintResource(t, allAssocs)
   240  	th.AssertIntGreaterOrEqual(t, len(allAssocs), 1)
   241  
   242  	// Get BGP VPN with associations
   243  	getBgpVpn, err := bgpvpns.Get(client, bgpVpnCreated.ID).Extract()
   244  	th.AssertNoErr(t, err)
   245  	tools.PrintResource(t, getBgpVpn)
   246  }