github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/openstack/networking/v2/extensions/bgp/speakers/testing/requests_test.go (about)

     1  package testing
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"net/http"
     7  	"testing"
     8  
     9  	fake "github.com/vnpaycloud-console/gophercloud/v2/openstack/networking/v2/common"
    10  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/networking/v2/extensions/bgp/speakers"
    11  	"github.com/vnpaycloud-console/gophercloud/v2/pagination"
    12  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    13  )
    14  
    15  func TestList(t *testing.T) {
    16  	th.SetupHTTP()
    17  	defer th.TeardownHTTP()
    18  
    19  	th.Mux.HandleFunc("/v2.0/bgp-speakers",
    20  		func(w http.ResponseWriter, r *http.Request) {
    21  			th.TestMethod(t, r, "GET")
    22  			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
    23  
    24  			w.Header().Add("Content-Type", "application/json")
    25  			w.WriteHeader(http.StatusOK)
    26  			fmt.Fprint(w, ListBGPSpeakerResult)
    27  		})
    28  	count := 0
    29  
    30  	err := speakers.List(fake.ServiceClient()).EachPage(
    31  		context.TODO(),
    32  		func(_ context.Context, page pagination.Page) (bool, error) {
    33  			count++
    34  			actual, err := speakers.ExtractBGPSpeakers(page)
    35  
    36  			if err != nil {
    37  				t.Errorf("Failed to extract BGP speakers: %v", err)
    38  				return false, nil
    39  			}
    40  			expected := []speakers.BGPSpeaker{BGPSpeaker1}
    41  			th.CheckDeepEquals(t, expected, actual)
    42  			return true, nil
    43  		})
    44  	th.AssertNoErr(t, err)
    45  }
    46  
    47  func TestGet(t *testing.T) {
    48  	th.SetupHTTP()
    49  	defer th.TeardownHTTP()
    50  
    51  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
    52  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
    53  		th.TestMethod(t, r, "GET")
    54  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
    55  		w.Header().Add("Content-Type", "application/json")
    56  		w.WriteHeader(http.StatusOK)
    57  		fmt.Fprint(w, GetBGPSpeakerResult)
    58  	})
    59  
    60  	s, err := speakers.Get(context.TODO(), fake.ServiceClient(), bgpSpeakerID).Extract()
    61  	th.AssertNoErr(t, err)
    62  	th.CheckDeepEquals(t, *s, BGPSpeaker1)
    63  }
    64  
    65  func TestCreate(t *testing.T) {
    66  	th.SetupHTTP()
    67  	defer th.TeardownHTTP()
    68  
    69  	th.Mux.HandleFunc("/v2.0/bgp-speakers", func(w http.ResponseWriter, r *http.Request) {
    70  		th.TestMethod(t, r, "POST")
    71  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
    72  		th.TestHeader(t, r, "Content-Type", "application/json")
    73  		th.TestHeader(t, r, "Accept", "application/json")
    74  		th.TestJSONRequest(t, r, CreateRequest)
    75  		w.Header().Add("Content-Type", "application/json")
    76  		w.WriteHeader(http.StatusCreated)
    77  		fmt.Fprint(w, CreateResponse)
    78  	})
    79  
    80  	opts := speakers.CreateOpts{
    81  		IPVersion:                     6,
    82  		AdvertiseFloatingIPHostRoutes: false,
    83  		AdvertiseTenantNetworks:       true,
    84  		Name:                          "gophercloud-testing-bgp-speaker",
    85  		LocalAS:                       "2000",
    86  		Networks:                      []string{},
    87  	}
    88  	r, err := speakers.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
    89  	th.AssertNoErr(t, err)
    90  	th.AssertEquals(t, r.Name, opts.Name)
    91  	th.AssertEquals(t, r.LocalAS, 2000)
    92  	th.AssertEquals(t, len(r.Networks), 0)
    93  	th.AssertEquals(t, r.IPVersion, opts.IPVersion)
    94  	th.AssertEquals(t, r.AdvertiseFloatingIPHostRoutes, opts.AdvertiseFloatingIPHostRoutes)
    95  	th.AssertEquals(t, r.AdvertiseTenantNetworks, opts.AdvertiseTenantNetworks)
    96  }
    97  
    98  func TestDelete(t *testing.T) {
    99  	th.SetupHTTP()
   100  	defer th.TeardownHTTP()
   101  
   102  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   103  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
   104  		th.TestMethod(t, r, "DELETE")
   105  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   106  		th.TestHeader(t, r, "Accept", "application/json")
   107  
   108  		w.Header().Add("Content-Type", "application/json")
   109  		w.WriteHeader(http.StatusNoContent)
   110  	})
   111  
   112  	err := speakers.Delete(context.TODO(), fake.ServiceClient(), bgpSpeakerID).ExtractErr()
   113  	th.AssertNoErr(t, err)
   114  }
   115  
   116  func TestUpdate(t *testing.T) {
   117  	th.SetupHTTP()
   118  	defer th.TeardownHTTP()
   119  
   120  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   121  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
   122  		if r.Method == "GET" {
   123  			th.TestMethod(t, r, "GET")
   124  			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   125  			w.Header().Add("Content-Type", "application/json")
   126  			w.WriteHeader(http.StatusOK)
   127  			fmt.Fprint(w, GetBGPSpeakerResult)
   128  		} else if r.Method == "PUT" {
   129  			th.TestMethod(t, r, "PUT")
   130  			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   131  			th.TestHeader(t, r, "Content-Type", "application/json")
   132  			th.TestHeader(t, r, "Accept", "application/json")
   133  			th.TestJSONRequest(t, r, UpdateBGPSpeakerRequest)
   134  
   135  			w.Header().Add("Content-Type", "application/json")
   136  			w.WriteHeader(http.StatusOK)
   137  			fmt.Fprint(w, UpdateBGPSpeakerResponse)
   138  		} else {
   139  			panic("Unexpected Request")
   140  		}
   141  	})
   142  
   143  	opts := speakers.UpdateOpts{
   144  		Name:                          "testing-bgp-speaker",
   145  		AdvertiseTenantNetworks:       false,
   146  		AdvertiseFloatingIPHostRoutes: true,
   147  	}
   148  
   149  	r, err := speakers.Update(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).Extract()
   150  	th.AssertNoErr(t, err)
   151  	th.AssertEquals(t, r.Name, opts.Name)
   152  	th.AssertEquals(t, r.AdvertiseTenantNetworks, opts.AdvertiseTenantNetworks)
   153  	th.AssertEquals(t, r.AdvertiseFloatingIPHostRoutes, opts.AdvertiseFloatingIPHostRoutes)
   154  }
   155  
   156  func TestAddBGPPeer(t *testing.T) {
   157  	th.SetupHTTP()
   158  	defer th.TeardownHTTP()
   159  
   160  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   161  	bgpPeerID := "f5884c7c-71d5-43a3-88b4-1742e97674aa"
   162  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/add_bgp_peer", func(w http.ResponseWriter, r *http.Request) {
   163  		th.TestMethod(t, r, "PUT")
   164  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   165  		th.TestHeader(t, r, "Content-Type", "application/json")
   166  		th.TestHeader(t, r, "Accept", "application/json")
   167  		th.TestJSONRequest(t, r, AddRemoveBGPPeerJSON)
   168  
   169  		w.Header().Add("Content-Type", "application/json")
   170  		w.WriteHeader(http.StatusOK)
   171  		fmt.Fprint(w, AddRemoveBGPPeerJSON)
   172  	})
   173  
   174  	opts := speakers.AddBGPPeerOpts{BGPPeerID: bgpPeerID}
   175  	r, err := speakers.AddBGPPeer(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).Extract()
   176  	th.AssertNoErr(t, err)
   177  	th.AssertEquals(t, bgpPeerID, r.BGPPeerID)
   178  }
   179  
   180  func TestRemoveBGPPeer(t *testing.T) {
   181  	th.SetupHTTP()
   182  	defer th.TeardownHTTP()
   183  
   184  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   185  	bgpPeerID := "f5884c7c-71d5-43a3-88b4-1742e97674aa"
   186  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/remove_bgp_peer", func(w http.ResponseWriter, r *http.Request) {
   187  		th.TestMethod(t, r, "PUT")
   188  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   189  		th.TestHeader(t, r, "Content-Type", "application/json")
   190  		th.TestHeader(t, r, "Accept", "application/json")
   191  		th.TestJSONRequest(t, r, AddRemoveBGPPeerJSON)
   192  		w.WriteHeader(http.StatusOK)
   193  	})
   194  
   195  	opts := speakers.RemoveBGPPeerOpts{BGPPeerID: bgpPeerID}
   196  	err := speakers.RemoveBGPPeer(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).ExtractErr()
   197  	th.AssertNoErr(t, err)
   198  }
   199  
   200  func TestGetAdvertisedRoutes(t *testing.T) {
   201  	th.SetupHTTP()
   202  	defer th.TeardownHTTP()
   203  
   204  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   205  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/get_advertised_routes", func(w http.ResponseWriter, r *http.Request) {
   206  		th.TestMethod(t, r, "GET")
   207  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   208  		w.Header().Add("Content-Type", "application/json")
   209  		w.WriteHeader(http.StatusOK)
   210  		fmt.Fprint(w, GetAdvertisedRoutesResult)
   211  	})
   212  
   213  	count := 0
   214  	err := speakers.GetAdvertisedRoutes(fake.ServiceClient(), bgpSpeakerID).EachPage(
   215  		context.TODO(),
   216  		func(_ context.Context, page pagination.Page) (bool, error) {
   217  			count++
   218  			actual, err := speakers.ExtractAdvertisedRoutes(page)
   219  
   220  			if err != nil {
   221  				t.Errorf("Failed to extract Advertised route: %v", err)
   222  				return false, nil
   223  			}
   224  
   225  			expected := []speakers.AdvertisedRoute{
   226  				{NextHop: "172.17.128.212", Destination: "172.17.129.192/27"},
   227  				{NextHop: "172.17.128.218", Destination: "172.17.129.0/27"},
   228  				{NextHop: "172.17.128.231", Destination: "172.17.129.160/27"},
   229  			}
   230  			th.CheckDeepEquals(t, count, 1)
   231  			th.CheckDeepEquals(t, expected, actual)
   232  			return true, nil
   233  		})
   234  	th.AssertNoErr(t, err)
   235  }
   236  
   237  func TestAddGatewayNetwork(t *testing.T) {
   238  	th.SetupHTTP()
   239  	defer th.TeardownHTTP()
   240  
   241  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   242  	networkID := "ac13bb26-6219-49c3-a880-08847f6830b7"
   243  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/add_gateway_network", func(w http.ResponseWriter, r *http.Request) {
   244  		th.TestMethod(t, r, "PUT")
   245  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   246  		th.TestHeader(t, r, "Content-Type", "application/json")
   247  		th.TestHeader(t, r, "Accept", "application/json")
   248  		th.TestJSONRequest(t, r, AddRemoveGatewayNetworkJSON)
   249  
   250  		w.Header().Add("Content-Type", "application/json")
   251  		w.WriteHeader(http.StatusOK)
   252  		fmt.Fprint(w, AddRemoveGatewayNetworkJSON)
   253  	})
   254  
   255  	opts := speakers.AddGatewayNetworkOpts{NetworkID: networkID}
   256  	r, err := speakers.AddGatewayNetwork(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).Extract()
   257  	th.AssertNoErr(t, err)
   258  	th.AssertEquals(t, r.NetworkID, networkID)
   259  }
   260  
   261  func TestRemoveGatewayNetwork(t *testing.T) {
   262  	th.SetupHTTP()
   263  	defer th.TeardownHTTP()
   264  
   265  	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
   266  	networkID := "ac13bb26-6219-49c3-a880-08847f6830b7"
   267  	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/remove_gateway_network", func(w http.ResponseWriter, r *http.Request) {
   268  		th.TestMethod(t, r, "PUT")
   269  		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
   270  		th.TestHeader(t, r, "Content-Type", "application/json")
   271  		th.TestHeader(t, r, "Accept", "application/json")
   272  		th.TestJSONRequest(t, r, AddRemoveGatewayNetworkJSON)
   273  
   274  		w.Header().Add("Content-Type", "application/json")
   275  		w.WriteHeader(http.StatusOK)
   276  		fmt.Fprint(w, "")
   277  	})
   278  
   279  	opts := speakers.RemoveGatewayNetworkOpts{NetworkID: networkID}
   280  	err := speakers.RemoveGatewayNetwork(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).ExtractErr()
   281  	th.AssertNoErr(t, err)
   282  }