github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/compute/v2/aggregates_test.go (about)

     1  //go:build acceptance || compute || aggregates
     2  // +build acceptance compute aggregates
     3  
     4  package v2
     5  
     6  import (
     7  	"fmt"
     8  	"strings"
     9  	"testing"
    10  
    11  	"github.com/gophercloud/gophercloud"
    12  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    13  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    14  	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/aggregates"
    15  	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/hypervisors"
    16  	th "github.com/gophercloud/gophercloud/testhelper"
    17  )
    18  
    19  func TestAggregatesList(t *testing.T) {
    20  	clients.RequireAdmin(t)
    21  
    22  	client, err := clients.NewComputeV2Client()
    23  	th.AssertNoErr(t, err)
    24  
    25  	allPages, err := aggregates.List(client).AllPages()
    26  	th.AssertNoErr(t, err)
    27  
    28  	allAggregates, err := aggregates.ExtractAggregates(allPages)
    29  	th.AssertNoErr(t, err)
    30  
    31  	for _, v := range allAggregates {
    32  		tools.PrintResource(t, v)
    33  	}
    34  }
    35  
    36  func TestAggregatesCRUD(t *testing.T) {
    37  	clients.RequireAdmin(t)
    38  
    39  	client, err := clients.NewComputeV2Client()
    40  	th.AssertNoErr(t, err)
    41  
    42  	aggregate, err := CreateAggregate(t, client)
    43  	th.AssertNoErr(t, err)
    44  
    45  	defer DeleteAggregate(t, client, aggregate)
    46  
    47  	tools.PrintResource(t, aggregate)
    48  
    49  	updateOpts := aggregates.UpdateOpts{
    50  		Name:             "new_aggregate_name",
    51  		AvailabilityZone: "new_azone",
    52  	}
    53  
    54  	updatedAggregate, err := aggregates.Update(client, aggregate.ID, updateOpts).Extract()
    55  	th.AssertNoErr(t, err)
    56  
    57  	tools.PrintResource(t, aggregate)
    58  
    59  	th.AssertEquals(t, updatedAggregate.Name, "new_aggregate_name")
    60  	th.AssertEquals(t, updatedAggregate.AvailabilityZone, "new_azone")
    61  }
    62  
    63  func TestAggregatesAddRemoveHost(t *testing.T) {
    64  	clients.RequireAdmin(t)
    65  
    66  	client, err := clients.NewComputeV2Client()
    67  	th.AssertNoErr(t, err)
    68  
    69  	hostToAdd, err := getHypervisor(t, client)
    70  	th.AssertNoErr(t, err)
    71  
    72  	aggregate, err := CreateAggregate(t, client)
    73  	th.AssertNoErr(t, err)
    74  	defer DeleteAggregate(t, client, aggregate)
    75  
    76  	addHostOpts := aggregates.AddHostOpts{
    77  		Host: hostToAdd,
    78  	}
    79  
    80  	aggregateWithNewHost, err := aggregates.AddHost(client, aggregate.ID, addHostOpts).Extract()
    81  	th.AssertNoErr(t, err)
    82  
    83  	tools.PrintResource(t, aggregateWithNewHost)
    84  
    85  	th.AssertEquals(t, aggregateWithNewHost.Hosts[0], hostToAdd)
    86  
    87  	removeHostOpts := aggregates.RemoveHostOpts{
    88  		Host: hostToAdd,
    89  	}
    90  
    91  	aggregateWithRemovedHost, err := aggregates.RemoveHost(client, aggregate.ID, removeHostOpts).Extract()
    92  	th.AssertNoErr(t, err)
    93  
    94  	tools.PrintResource(t, aggregateWithRemovedHost)
    95  
    96  	th.AssertEquals(t, len(aggregateWithRemovedHost.Hosts), 0)
    97  }
    98  
    99  func TestAggregatesSetRemoveMetadata(t *testing.T) {
   100  	clients.RequireAdmin(t)
   101  
   102  	client, err := clients.NewComputeV2Client()
   103  	th.AssertNoErr(t, err)
   104  
   105  	aggregate, err := CreateAggregate(t, client)
   106  	th.AssertNoErr(t, err)
   107  	defer DeleteAggregate(t, client, aggregate)
   108  
   109  	opts := aggregates.SetMetadataOpts{
   110  		Metadata: map[string]interface{}{"key": "value"},
   111  	}
   112  
   113  	aggregateWithMetadata, err := aggregates.SetMetadata(client, aggregate.ID, opts).Extract()
   114  	th.AssertNoErr(t, err)
   115  
   116  	tools.PrintResource(t, aggregateWithMetadata)
   117  
   118  	if _, ok := aggregateWithMetadata.Metadata["key"]; !ok {
   119  		t.Fatalf("aggregate %s did not contain metadata", aggregateWithMetadata.Name)
   120  	}
   121  
   122  	optsToRemove := aggregates.SetMetadataOpts{
   123  		Metadata: map[string]interface{}{"key": nil},
   124  	}
   125  
   126  	aggregateWithRemovedKey, err := aggregates.SetMetadata(client, aggregate.ID, optsToRemove).Extract()
   127  	th.AssertNoErr(t, err)
   128  
   129  	tools.PrintResource(t, aggregateWithRemovedKey)
   130  
   131  	if _, ok := aggregateWithRemovedKey.Metadata["key"]; ok {
   132  		t.Fatalf("aggregate %s still contains metadata", aggregateWithRemovedKey.Name)
   133  	}
   134  }
   135  
   136  func getHypervisor(t *testing.T, client *gophercloud.ServiceClient) (string, error) {
   137  	allPages, err := hypervisors.List(client, nil).AllPages()
   138  	th.AssertNoErr(t, err)
   139  
   140  	allHypervisors, err := hypervisors.ExtractHypervisors(allPages)
   141  	th.AssertNoErr(t, err)
   142  
   143  	for _, h := range allHypervisors {
   144  		// Nova API takes Hostnames, not FQDNs, so we need to strip the domain.
   145  		host := strings.Split(h.HypervisorHostname, ".")[0]
   146  		return host, nil
   147  	}
   148  
   149  	return "", fmt.Errorf("Unable to get hypervisor")
   150  }