github.com/vnpaycloud-console/gophercloud/v2@v2.0.5/openstack/compute/v2/aggregates/testing/requests_test.go (about)

     1  package testing
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/vnpaycloud-console/gophercloud/v2/openstack/compute/v2/aggregates"
     8  	"github.com/vnpaycloud-console/gophercloud/v2/pagination"
     9  	th "github.com/vnpaycloud-console/gophercloud/v2/testhelper"
    10  	"github.com/vnpaycloud-console/gophercloud/v2/testhelper/client"
    11  )
    12  
    13  func TestListAggregates(t *testing.T) {
    14  	th.SetupHTTP()
    15  	defer th.TeardownHTTP()
    16  	HandleListSuccessfully(t)
    17  
    18  	pages := 0
    19  	err := aggregates.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
    20  		pages++
    21  
    22  		actual, err := aggregates.ExtractAggregates(page)
    23  		if err != nil {
    24  			return false, err
    25  		}
    26  
    27  		if len(actual) != 2 {
    28  			t.Fatalf("Expected 2 aggregates, got %d", len(actual))
    29  		}
    30  		th.CheckDeepEquals(t, FirstFakeAggregate, actual[0])
    31  		th.CheckDeepEquals(t, SecondFakeAggregate, actual[1])
    32  
    33  		return true, nil
    34  	})
    35  
    36  	th.AssertNoErr(t, err)
    37  
    38  	if pages != 1 {
    39  		t.Errorf("Expected 1 page, saw %d", pages)
    40  	}
    41  }
    42  
    43  func TestCreateAggregates(t *testing.T) {
    44  	th.SetupHTTP()
    45  	defer th.TeardownHTTP()
    46  	HandleCreateSuccessfully(t)
    47  
    48  	expected := CreatedAggregate
    49  
    50  	opts := aggregates.CreateOpts{
    51  		Name:             "name",
    52  		AvailabilityZone: "london",
    53  	}
    54  
    55  	actual, err := aggregates.Create(context.TODO(), client.ServiceClient(), opts).Extract()
    56  	th.AssertNoErr(t, err)
    57  
    58  	th.AssertDeepEquals(t, &expected, actual)
    59  }
    60  
    61  func TestDeleteAggregates(t *testing.T) {
    62  	th.SetupHTTP()
    63  	defer th.TeardownHTTP()
    64  	HandleDeleteSuccessfully(t)
    65  
    66  	err := aggregates.Delete(context.TODO(), client.ServiceClient(), AggregateIDtoDelete).ExtractErr()
    67  	th.AssertNoErr(t, err)
    68  }
    69  
    70  func TestGetAggregates(t *testing.T) {
    71  	th.SetupHTTP()
    72  	defer th.TeardownHTTP()
    73  	HandleGetSuccessfully(t)
    74  
    75  	expected := SecondFakeAggregate
    76  
    77  	actual, err := aggregates.Get(context.TODO(), client.ServiceClient(), AggregateIDtoGet).Extract()
    78  	th.AssertNoErr(t, err)
    79  
    80  	th.AssertDeepEquals(t, &expected, actual)
    81  }
    82  
    83  func TestUpdateAggregate(t *testing.T) {
    84  	th.SetupHTTP()
    85  	defer th.TeardownHTTP()
    86  	HandleUpdateSuccessfully(t)
    87  
    88  	expected := UpdatedAggregate
    89  
    90  	opts := aggregates.UpdateOpts{
    91  		Name:             "test-aggregates2",
    92  		AvailabilityZone: "nova2",
    93  	}
    94  
    95  	actual, err := aggregates.Update(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
    96  	th.AssertNoErr(t, err)
    97  
    98  	th.AssertDeepEquals(t, &expected, actual)
    99  }
   100  
   101  func TestAddHostAggregate(t *testing.T) {
   102  	th.SetupHTTP()
   103  	defer th.TeardownHTTP()
   104  	HandleAddHostSuccessfully(t)
   105  
   106  	expected := AggregateWithAddedHost
   107  
   108  	opts := aggregates.AddHostOpts{
   109  		Host: "cmp1",
   110  	}
   111  
   112  	actual, err := aggregates.AddHost(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
   113  	th.AssertNoErr(t, err)
   114  
   115  	th.AssertDeepEquals(t, &expected, actual)
   116  }
   117  
   118  func TestRemoveHostAggregate(t *testing.T) {
   119  	th.SetupHTTP()
   120  	defer th.TeardownHTTP()
   121  	HandleRemoveHostSuccessfully(t)
   122  
   123  	expected := AggregateWithRemovedHost
   124  
   125  	opts := aggregates.RemoveHostOpts{
   126  		Host: "cmp1",
   127  	}
   128  
   129  	actual, err := aggregates.RemoveHost(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
   130  	th.AssertNoErr(t, err)
   131  
   132  	th.AssertDeepEquals(t, &expected, actual)
   133  }
   134  
   135  func TestSetMetadataAggregate(t *testing.T) {
   136  	th.SetupHTTP()
   137  	defer th.TeardownHTTP()
   138  	HandleSetMetadataSuccessfully(t)
   139  
   140  	expected := AggregateWithUpdatedMetadata
   141  
   142  	opts := aggregates.SetMetadataOpts{
   143  		Metadata: map[string]any{"key": "value"},
   144  	}
   145  
   146  	actual, err := aggregates.SetMetadata(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
   147  	th.AssertNoErr(t, err)
   148  
   149  	th.AssertDeepEquals(t, &expected, actual)
   150  }