github.com/opentelekomcloud/gophertelekomcloud@v0.9.3/acceptance/openstack/cce/v3/addons_test.go (about)

     1  package v3
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/suite"
     8  
     9  	"github.com/opentelekomcloud/gophertelekomcloud/acceptance/clients"
    10  	"github.com/opentelekomcloud/gophertelekomcloud/openstack/cce/v3/addons"
    11  	th "github.com/opentelekomcloud/gophertelekomcloud/testhelper"
    12  )
    13  
    14  type testAddons struct {
    15  	suite.Suite
    16  
    17  	vpcID     string
    18  	subnetID  string
    19  	clusterID string
    20  }
    21  
    22  func TestAddons(t *testing.T) {
    23  	suite.Run(t, new(testAddons))
    24  }
    25  
    26  func (a *testAddons) SetupSuite() {
    27  	t := a.T()
    28  	a.vpcID = clients.EnvOS.GetEnv("VPC_ID")
    29  	a.subnetID = clients.EnvOS.GetEnv("NETWORK_ID")
    30  	a.clusterID = clients.EnvOS.GetEnv("CLUSTER_ID")
    31  	if a.vpcID == "" || a.subnetID == "" {
    32  		t.Skip("OS_VPC_ID, OS_NETWORK_ID, and OS_CLUSTER_ID are required for this test")
    33  	}
    34  }
    35  
    36  func (a *testAddons) TestAddonsLifecycle() {
    37  	t := a.T()
    38  
    39  	client, err := clients.NewCceV3AddonClient()
    40  	th.AssertNoErr(t, err)
    41  
    42  	custom := map[string]interface{}{
    43  		"coresTotal":                     32000,
    44  		"maxEmptyBulkDeleteFlag":         10,
    45  		"maxNodesTotal":                  1000,
    46  		"memoryTotal":                    128000,
    47  		"scaleDownDelayAfterAdd":         10,
    48  		"scaleDownDelayAfterDelete":      10,
    49  		"scaleDownDelayAfterFailure":     3,
    50  		"scaleDownEnabled":               true,
    51  		"scaleDownUnneededTime":          10,
    52  		"scaleDownUtilizationThreshold":  0.25,
    53  		"scaleUpCpuUtilizationThreshold": 0.8,
    54  		"scaleUpMemUtilizationThreshold": 0.8,
    55  		"scaleUpUnscheduledPodEnabled":   true,
    56  		"scaleUpUtilizationEnabled":      true,
    57  		"unremovableNodeRecheckTimeout":  5,
    58  	}
    59  	cOpts := addons.CreateOpts{
    60  		Kind:       "Addon",
    61  		ApiVersion: "v3",
    62  		Metadata: addons.CreateMetadata{
    63  			Annotations: addons.CreateAnnotations{
    64  				AddonInstallType: "install",
    65  			},
    66  		},
    67  		Spec: addons.RequestSpec{
    68  			Version:           "1.17.2",
    69  			ClusterID:         a.clusterID,
    70  			AddonTemplateName: "autoscaler",
    71  			Values: addons.Values{
    72  				Basic: map[string]interface{}{
    73  					"cceEndpoint":     "https://cce.eu-de.otc.t-systems.com",
    74  					"ecsEndpoint":     "https://ecs.eu-de.otc.t-systems.com",
    75  					"euleros_version": "2.5",
    76  					"region":          "eu-de",
    77  					"swr_addr":        "100.125.7.25:20202",
    78  					"swr_user":        "hwofficial",
    79  				},
    80  				Advanced: custom,
    81  			},
    82  		},
    83  	}
    84  
    85  	addon, err := addons.Create(client, cOpts, a.clusterID).Extract()
    86  	th.AssertNoErr(t, err)
    87  
    88  	addonID := addon.Metadata.Id
    89  
    90  	defer func() {
    91  		err := addons.Delete(client, addonID, a.clusterID).ExtractErr()
    92  		th.AssertNoErr(t, err)
    93  
    94  		th.AssertNoErr(t, addons.WaitForAddonDeleted(client, addonID, a.clusterID, 600))
    95  	}()
    96  
    97  	getAddon, err := addons.Get(client, addonID, a.clusterID).Extract()
    98  	th.AssertNoErr(t, err)
    99  	th.AssertEquals(t, "autoscaler", getAddon.Spec.AddonTemplateName)
   100  	th.AssertEquals(t, "1.17.2", getAddon.Spec.Version)
   101  	th.AssertEquals(t, true, getAddon.Spec.Values.Advanced["scaleDownEnabled"])
   102  
   103  	waitErr := addons.WaitForAddonRunning(client, addonID, a.clusterID, 600)
   104  	th.AssertNoErr(t, waitErr)
   105  
   106  	uOpts := addons.UpdateOpts{
   107  		Kind:       "Addon",
   108  		ApiVersion: "v3",
   109  		Metadata: addons.UpdateMetadata{
   110  			Annotations: addons.UpdateAnnotations{
   111  				AddonUpdateType: "upgrade",
   112  			},
   113  		},
   114  		Spec: addons.RequestSpec{
   115  			Version:           cOpts.Spec.Version,
   116  			ClusterID:         cOpts.Spec.ClusterID,
   117  			AddonTemplateName: cOpts.Spec.AddonTemplateName,
   118  			Values: addons.Values{
   119  				Basic:    cOpts.Spec.Values.Basic,
   120  				Advanced: cOpts.Spec.Values.Advanced,
   121  			},
   122  		},
   123  	}
   124  	uOpts.Spec.Values.Advanced["scaleDownEnabled"] = false
   125  	uOpts.Spec.Values.Advanced["scaleDownDelayAfterAdd"] = 11
   126  
   127  	_, err = addons.Update(client, addonID, a.clusterID, uOpts).Extract()
   128  	th.AssertNoErr(t, err)
   129  
   130  	getAddon2, err := addons.Get(client, addonID, a.clusterID).Extract()
   131  	th.AssertNoErr(t, err)
   132  	th.AssertEquals(t, false, getAddon2.Spec.Values.Advanced["scaleDownEnabled"])
   133  	th.AssertEquals(t, 11.0, getAddon2.Spec.Values.Advanced["scaleDownDelayAfterAdd"])
   134  }
   135  
   136  func (a *testAddons) TestListAddonTemplates() {
   137  	t := a.T()
   138  
   139  	client, err := clients.NewCceV3AddonClient()
   140  	th.AssertNoErr(t, err)
   141  
   142  	list, err := addons.ListTemplates(client, a.clusterID, nil).Extract()
   143  	th.AssertNoErr(t, err)
   144  
   145  	if len(list.Items) == 0 {
   146  		t.Fatal("empty addon template list")
   147  	}
   148  
   149  	jsonList, _ := json.MarshalIndent(list.Items, "", "  ")
   150  
   151  	t.Logf("existing addon templates:\n%s", string(jsonList))
   152  }
   153  
   154  func (a *testAddons) TestListAddonInstances() {
   155  	t := a.T()
   156  
   157  	client, err := clients.NewCceV3AddonClient()
   158  	th.AssertNoErr(t, err)
   159  
   160  	list, err := addons.ListAddonInstances(client, a.clusterID).Extract()
   161  	th.AssertNoErr(t, err)
   162  
   163  	th.AssertEquals(t, len(list.Items), 3)
   164  	// check if listed addon exists
   165  	_, err = addons.Get(client, list.Items[0].Metadata.ID, a.clusterID).Extract()
   166  	th.AssertNoErr(t, err)
   167  }
   168  
   169  func (a *testAddons) TestGetAddonTemplates() {
   170  	t := a.T()
   171  
   172  	client, err := clients.NewCceV3AddonClient()
   173  	th.AssertNoErr(t, err)
   174  
   175  	templates, err := addons.GetTemplates(client).Extract()
   176  	th.AssertNoErr(t, err)
   177  	if len(templates.Items) == 0 {
   178  		t.Fatal("empty addon templates list")
   179  	}
   180  }