github.com/sacloud/iaas-api-go@v1.12.0/test/load_balancer_op_test.go (about)

     1  // Copyright 2022-2023 The sacloud/iaas-api-go Authors
     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 test
    16  
    17  import (
    18  	"testing"
    19  
    20  	"github.com/sacloud/iaas-api-go"
    21  	"github.com/sacloud/iaas-api-go/helper/power"
    22  	"github.com/sacloud/iaas-api-go/testutil"
    23  	"github.com/sacloud/iaas-api-go/types"
    24  )
    25  
    26  func TestLoadBalancerOp_CRUD(t *testing.T) {
    27  	testutil.RunCRUD(t, &testutil.CRUDTestCase{
    28  		Parallel: true,
    29  
    30  		SetupAPICallerFunc: singletonAPICaller,
    31  		Setup: setupSwitchFunc("lb",
    32  			createLoadBalancerParam,
    33  			createLoadBalancerExpected,
    34  			updateLoadBalancerExpected,
    35  			updateLoadBalancerSettingsExpected,
    36  			updateLoadBalancerToMin1Expected,
    37  			updateLoadBalancerToMin2Expected,
    38  		),
    39  		Create: &testutil.CRUDTestFunc{
    40  			Func: testLoadBalancerCreate,
    41  			CheckFunc: testutil.AssertEqualWithExpected(&testutil.CRUDTestExpect{
    42  				ExpectValue:  createLoadBalancerExpected,
    43  				IgnoreFields: ignoreLoadBalancerFields,
    44  			}),
    45  		},
    46  
    47  		Read: &testutil.CRUDTestFunc{
    48  			Func: testLoadBalancerRead,
    49  			CheckFunc: testutil.AssertEqualWithExpected(&testutil.CRUDTestExpect{
    50  				ExpectValue:  createLoadBalancerExpected,
    51  				IgnoreFields: ignoreLoadBalancerFields,
    52  			}),
    53  		},
    54  
    55  		Updates: []*testutil.CRUDTestFunc{
    56  			{
    57  				Func: testLoadBalancerUpdate,
    58  				CheckFunc: testutil.AssertEqualWithExpected(&testutil.CRUDTestExpect{
    59  					ExpectValue:  updateLoadBalancerExpected,
    60  					IgnoreFields: ignoreLoadBalancerFields,
    61  				}),
    62  			},
    63  			{
    64  				Func: testLoadBalancerUpdateSettings,
    65  				CheckFunc: testutil.AssertEqualWithExpected(&testutil.CRUDTestExpect{
    66  					ExpectValue:  updateLoadBalancerSettingsExpected,
    67  					IgnoreFields: ignoreLoadBalancerFields,
    68  				}),
    69  			},
    70  			{
    71  				Func: testLoadBalancerUpdateToMin1,
    72  				CheckFunc: testutil.AssertEqualWithExpected(&testutil.CRUDTestExpect{
    73  					ExpectValue:  updateLoadBalancerToMin1Expected,
    74  					IgnoreFields: ignoreLoadBalancerFields,
    75  				}),
    76  			},
    77  			{
    78  				Func: testLoadBalancerUpdateToMin2,
    79  				CheckFunc: testutil.AssertEqualWithExpected(&testutil.CRUDTestExpect{
    80  					ExpectValue:  updateLoadBalancerToMin2Expected,
    81  					IgnoreFields: ignoreLoadBalancerFields,
    82  				}),
    83  			},
    84  		},
    85  
    86  		Shutdown: func(ctx *testutil.CRUDTestContext, caller iaas.APICaller) error {
    87  			client := iaas.NewLoadBalancerOp(caller)
    88  			return power.ShutdownLoadBalancer(ctx, client, testZone, ctx.ID, true)
    89  		},
    90  
    91  		Delete: &testutil.CRUDTestDeleteFunc{
    92  			Func: testLoadBalancerDelete,
    93  		},
    94  
    95  		Cleanup: cleanupSwitchFunc("lb"),
    96  	})
    97  }
    98  
    99  var (
   100  	ignoreLoadBalancerFields = []string{
   101  		"ID",
   102  		"Class",
   103  		"Availability",
   104  		"InstanceStatus",
   105  		"InstanceHostName",
   106  		"InstanceHostInfoURL",
   107  		"InstanceStatusChangedAt",
   108  		"Interfaces",
   109  		"Switch",
   110  		"ZoneID",
   111  		"CreatedAt",
   112  		"ModifiedAt",
   113  		"SettingsHash",
   114  	}
   115  
   116  	createLoadBalancerParam = &iaas.LoadBalancerCreateRequest{
   117  		PlanID:         types.LoadBalancerPlans.HighSpec,
   118  		VRID:           100,
   119  		IPAddresses:    []string{"192.168.0.11", "192.168.0.12"},
   120  		NetworkMaskLen: 24,
   121  		DefaultRoute:   "192.168.0.1",
   122  		Name:           testutil.ResourceName("lb"),
   123  		Description:    "desc",
   124  		Tags:           []string{"tag1", "tag2"},
   125  		VirtualIPAddresses: []*iaas.LoadBalancerVirtualIPAddress{
   126  			{
   127  				VirtualIPAddress: "192.168.0.101",
   128  				Port:             types.StringNumber(80),
   129  				DelayLoop:        types.StringNumber(10),
   130  				SorryServer:      "192.168.0.2",
   131  				Description:      "vip1 desc",
   132  				Servers: []*iaas.LoadBalancerServer{
   133  					{
   134  						IPAddress: "192.168.0.201",
   135  						Port:      80,
   136  						Enabled:   true,
   137  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   138  							Protocol:       types.LoadBalancerHealthCheckProtocols.HTTP,
   139  							Path:           "/index.html",
   140  							ResponseCode:   200,
   141  							Retry:          2,
   142  							ConnectTimeout: 6,
   143  						},
   144  					},
   145  					{
   146  						IPAddress: "192.168.0.202",
   147  						Port:      80,
   148  						Enabled:   true,
   149  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   150  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTP,
   151  							Path:         "/index.html",
   152  							ResponseCode: 200,
   153  						},
   154  					},
   155  				},
   156  			},
   157  			{
   158  				VirtualIPAddress: "192.168.0.102",
   159  				Port:             80,
   160  				DelayLoop:        10,
   161  				SorryServer:      "192.168.0.2",
   162  				Description:      "vip2 desc",
   163  				Servers: []*iaas.LoadBalancerServer{
   164  					{
   165  						IPAddress: "192.168.0.203",
   166  						Port:      80,
   167  						Enabled:   true,
   168  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   169  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTP,
   170  							Path:         "/index.html",
   171  							ResponseCode: 200,
   172  						},
   173  					},
   174  					{
   175  						IPAddress: "192.168.0.204",
   176  						Port:      80,
   177  						Enabled:   true,
   178  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   179  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTP,
   180  							Path:         "/index.html",
   181  							ResponseCode: 200,
   182  						},
   183  					},
   184  				},
   185  			},
   186  		},
   187  	}
   188  	createLoadBalancerExpected = &iaas.LoadBalancer{
   189  		Name:               createLoadBalancerParam.Name,
   190  		Description:        createLoadBalancerParam.Description,
   191  		Tags:               createLoadBalancerParam.Tags,
   192  		Availability:       types.Availabilities.Available,
   193  		InstanceStatus:     types.ServerInstanceStatuses.Up,
   194  		PlanID:             createLoadBalancerParam.PlanID,
   195  		DefaultRoute:       createLoadBalancerParam.DefaultRoute,
   196  		NetworkMaskLen:     createLoadBalancerParam.NetworkMaskLen,
   197  		IPAddresses:        createLoadBalancerParam.IPAddresses,
   198  		VRID:               createLoadBalancerParam.VRID,
   199  		VirtualIPAddresses: createLoadBalancerParam.VirtualIPAddresses,
   200  	}
   201  	updateLoadBalancerParam = &iaas.LoadBalancerUpdateRequest{
   202  		Name:        testutil.ResourceName("lb-upd"),
   203  		Tags:        []string{"tag1-upd", "tag2-upd"},
   204  		Description: "desc-upd",
   205  		IconID:      testIconID,
   206  		VirtualIPAddresses: []*iaas.LoadBalancerVirtualIPAddress{
   207  			{
   208  				VirtualIPAddress: "192.168.0.111",
   209  				Port:             81,
   210  				DelayLoop:        11,
   211  				SorryServer:      "192.168.0.3",
   212  				Description:      "vip1 desc-upd",
   213  				Servers: []*iaas.LoadBalancerServer{
   214  					{
   215  						IPAddress: "192.168.0.211",
   216  						Port:      81,
   217  						Enabled:   false,
   218  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   219  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   220  							Path:         "/index-upd.html",
   221  							ResponseCode: 201,
   222  						},
   223  					},
   224  					{
   225  						IPAddress: "192.168.0.212",
   226  						Port:      81,
   227  						Enabled:   false,
   228  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   229  							Protocol:       types.LoadBalancerHealthCheckProtocols.HTTPS,
   230  							Path:           "/index-upd.html",
   231  							ResponseCode:   201,
   232  							Retry:          3,
   233  							ConnectTimeout: 12,
   234  						},
   235  					},
   236  				},
   237  			},
   238  			{
   239  				VirtualIPAddress: "192.168.0.112",
   240  				Port:             81,
   241  				DelayLoop:        11,
   242  				SorryServer:      "192.168.0.3",
   243  				Description:      "vip2 desc-upd",
   244  				Servers: []*iaas.LoadBalancerServer{
   245  					{
   246  						IPAddress: "192.168.0.213",
   247  						Port:      81,
   248  						Enabled:   false,
   249  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   250  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   251  							Path:         "/index-upd.html",
   252  							ResponseCode: 201,
   253  						},
   254  					},
   255  					{
   256  						IPAddress: "192.168.0.214",
   257  						Port:      81,
   258  						Enabled:   false,
   259  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   260  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   261  							Path:         "/index-upd.html",
   262  							ResponseCode: 201,
   263  						},
   264  					},
   265  				},
   266  			},
   267  		},
   268  	}
   269  	updateLoadBalancerExpected = &iaas.LoadBalancer{
   270  		Name:               updateLoadBalancerParam.Name,
   271  		Description:        updateLoadBalancerParam.Description,
   272  		Tags:               updateLoadBalancerParam.Tags,
   273  		IconID:             testIconID,
   274  		Availability:       types.Availabilities.Available,
   275  		PlanID:             createLoadBalancerParam.PlanID,
   276  		InstanceStatus:     types.ServerInstanceStatuses.Up,
   277  		DefaultRoute:       createLoadBalancerParam.DefaultRoute,
   278  		NetworkMaskLen:     createLoadBalancerParam.NetworkMaskLen,
   279  		IPAddresses:        createLoadBalancerParam.IPAddresses,
   280  		VRID:               createLoadBalancerParam.VRID,
   281  		VirtualIPAddresses: updateLoadBalancerParam.VirtualIPAddresses,
   282  	}
   283  	updateLoadBalancerSettingsParam = &iaas.LoadBalancerUpdateSettingsRequest{
   284  		VirtualIPAddresses: []*iaas.LoadBalancerVirtualIPAddress{
   285  			{
   286  				VirtualIPAddress: "192.168.0.121",
   287  				Port:             82,
   288  				DelayLoop:        11,
   289  				SorryServer:      "192.168.0.4",
   290  				Description:      "vip1 desc-upd",
   291  				Servers: []*iaas.LoadBalancerServer{
   292  					{
   293  						IPAddress: "192.168.0.221",
   294  						Port:      82,
   295  						Enabled:   false,
   296  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   297  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   298  							Path:         "/index-upd.html",
   299  							ResponseCode: 201,
   300  						},
   301  					},
   302  					{
   303  						IPAddress: "192.168.0.222",
   304  						Port:      82,
   305  						Enabled:   false,
   306  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   307  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   308  							Path:         "/index-upd.html",
   309  							ResponseCode: 201,
   310  						},
   311  					},
   312  				},
   313  			},
   314  			{
   315  				VirtualIPAddress: "192.168.0.122",
   316  				Port:             82,
   317  				DelayLoop:        11,
   318  				SorryServer:      "192.168.0.4",
   319  				Description:      "vip2 desc-upd",
   320  				Servers: []*iaas.LoadBalancerServer{
   321  					{
   322  						IPAddress: "192.168.0.223",
   323  						Port:      82,
   324  						Enabled:   false,
   325  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   326  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   327  							Path:         "/index-upd.html",
   328  							ResponseCode: 201,
   329  						},
   330  					},
   331  					{
   332  						IPAddress: "192.168.0.224",
   333  						Port:      82,
   334  						Enabled:   false,
   335  						HealthCheck: &iaas.LoadBalancerServerHealthCheck{
   336  							Protocol:     types.LoadBalancerHealthCheckProtocols.HTTPS,
   337  							Path:         "/index-upd.html",
   338  							ResponseCode: 201,
   339  						},
   340  					},
   341  				},
   342  			},
   343  		},
   344  	}
   345  	updateLoadBalancerSettingsExpected = &iaas.LoadBalancer{
   346  		Name:               updateLoadBalancerParam.Name,
   347  		Description:        updateLoadBalancerParam.Description,
   348  		Tags:               updateLoadBalancerParam.Tags,
   349  		IconID:             testIconID,
   350  		Availability:       types.Availabilities.Available,
   351  		PlanID:             createLoadBalancerParam.PlanID,
   352  		InstanceStatus:     types.ServerInstanceStatuses.Up,
   353  		DefaultRoute:       createLoadBalancerParam.DefaultRoute,
   354  		NetworkMaskLen:     createLoadBalancerParam.NetworkMaskLen,
   355  		IPAddresses:        createLoadBalancerParam.IPAddresses,
   356  		VRID:               createLoadBalancerParam.VRID,
   357  		VirtualIPAddresses: updateLoadBalancerSettingsParam.VirtualIPAddresses,
   358  	}
   359  	updateLoadBalancerToMin1Param = &iaas.LoadBalancerUpdateRequest{
   360  		Name: testutil.ResourceName("lb-to-min1"),
   361  		VirtualIPAddresses: []*iaas.LoadBalancerVirtualIPAddress{
   362  			{
   363  				VirtualIPAddress: "192.168.0.111",
   364  				Port:             80,
   365  				Servers:          iaas.LoadBalancerServers{},
   366  			},
   367  		},
   368  	}
   369  	updateLoadBalancerToMin1Expected = &iaas.LoadBalancer{
   370  		Name:           updateLoadBalancerToMin1Param.Name,
   371  		Availability:   types.Availabilities.Available,
   372  		PlanID:         createLoadBalancerParam.PlanID,
   373  		InstanceStatus: types.ServerInstanceStatuses.Up,
   374  		DefaultRoute:   createLoadBalancerParam.DefaultRoute,
   375  		NetworkMaskLen: createLoadBalancerParam.NetworkMaskLen,
   376  		IPAddresses:    createLoadBalancerParam.IPAddresses,
   377  		VRID:           createLoadBalancerParam.VRID,
   378  		VirtualIPAddresses: []*iaas.LoadBalancerVirtualIPAddress{
   379  			{
   380  				VirtualIPAddress: "192.168.0.111",
   381  				Port:             80,
   382  				DelayLoop:        10, // default value
   383  				Servers:          []*iaas.LoadBalancerServer{},
   384  			},
   385  		},
   386  	}
   387  	updateLoadBalancerToMin2Param = &iaas.LoadBalancerUpdateRequest{
   388  		Name:               testutil.ResourceName("lb-to-min2"),
   389  		VirtualIPAddresses: iaas.LoadBalancerVirtualIPAddresses{},
   390  	}
   391  	updateLoadBalancerToMin2Expected = &iaas.LoadBalancer{
   392  		Name:               updateLoadBalancerToMin2Param.Name,
   393  		Availability:       types.Availabilities.Available,
   394  		PlanID:             createLoadBalancerParam.PlanID,
   395  		InstanceStatus:     types.ServerInstanceStatuses.Up,
   396  		DefaultRoute:       createLoadBalancerParam.DefaultRoute,
   397  		NetworkMaskLen:     createLoadBalancerParam.NetworkMaskLen,
   398  		IPAddresses:        createLoadBalancerParam.IPAddresses,
   399  		VRID:               createLoadBalancerParam.VRID,
   400  		VirtualIPAddresses: iaas.LoadBalancerVirtualIPAddresses{},
   401  	}
   402  )
   403  
   404  func testLoadBalancerCreate(ctx *testutil.CRUDTestContext, caller iaas.APICaller) (interface{}, error) {
   405  	client := iaas.NewLoadBalancerOp(caller)
   406  	return client.Create(ctx, testZone, createLoadBalancerParam)
   407  }
   408  
   409  func testLoadBalancerRead(ctx *testutil.CRUDTestContext, caller iaas.APICaller) (interface{}, error) {
   410  	client := iaas.NewLoadBalancerOp(caller)
   411  	return client.Read(ctx, testZone, ctx.ID)
   412  }
   413  
   414  func testLoadBalancerUpdate(ctx *testutil.CRUDTestContext, caller iaas.APICaller) (interface{}, error) {
   415  	client := iaas.NewLoadBalancerOp(caller)
   416  	return client.Update(ctx, testZone, ctx.ID, updateLoadBalancerParam)
   417  }
   418  
   419  func testLoadBalancerUpdateSettings(ctx *testutil.CRUDTestContext, caller iaas.APICaller) (interface{}, error) {
   420  	client := iaas.NewLoadBalancerOp(caller)
   421  	return client.UpdateSettings(ctx, testZone, ctx.ID, updateLoadBalancerSettingsParam)
   422  }
   423  
   424  func testLoadBalancerUpdateToMin1(ctx *testutil.CRUDTestContext, caller iaas.APICaller) (interface{}, error) {
   425  	client := iaas.NewLoadBalancerOp(caller)
   426  	return client.Update(ctx, testZone, ctx.ID, updateLoadBalancerToMin1Param)
   427  }
   428  
   429  func testLoadBalancerUpdateToMin2(ctx *testutil.CRUDTestContext, caller iaas.APICaller) (interface{}, error) {
   430  	client := iaas.NewLoadBalancerOp(caller)
   431  	return client.Update(ctx, testZone, ctx.ID, updateLoadBalancerToMin2Param)
   432  }
   433  
   434  func testLoadBalancerDelete(ctx *testutil.CRUDTestContext, caller iaas.APICaller) error {
   435  	client := iaas.NewLoadBalancerOp(caller)
   436  	return client.Delete(ctx, testZone, ctx.ID)
   437  }