github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/identity/v3/limits_test.go (about)

     1  //go:build acceptance
     2  // +build acceptance
     3  
     4  package v3
     5  
     6  import (
     7  	"os"
     8  	"testing"
     9  
    10  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    11  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    12  	"github.com/gophercloud/gophercloud/openstack/identity/v3/limits"
    13  	"github.com/gophercloud/gophercloud/openstack/identity/v3/registeredlimits"
    14  	"github.com/gophercloud/gophercloud/openstack/identity/v3/services"
    15  	th "github.com/gophercloud/gophercloud/testhelper"
    16  )
    17  
    18  func TestGetEnforcementModel(t *testing.T) {
    19  	clients.RequireAdmin(t)
    20  
    21  	client, err := clients.NewIdentityV3Client()
    22  	th.AssertNoErr(t, err)
    23  
    24  	model, err := limits.GetEnforcementModel(client).Extract()
    25  	th.AssertNoErr(t, err)
    26  
    27  	tools.PrintResource(t, model)
    28  }
    29  
    30  func TestLimitsList(t *testing.T) {
    31  	clients.RequireAdmin(t)
    32  
    33  	client, err := clients.NewIdentityV3Client()
    34  	th.AssertNoErr(t, err)
    35  
    36  	listOpts := limits.ListOpts{}
    37  
    38  	allPages, err := limits.List(client, listOpts).AllPages()
    39  	th.AssertNoErr(t, err)
    40  
    41  	_, err = limits.ExtractLimits(allPages)
    42  	th.AssertNoErr(t, err)
    43  }
    44  
    45  func TestLimitsCRUD(t *testing.T) {
    46  	err := os.Setenv("OS_SYSTEM_SCOPE", "all")
    47  	th.AssertNoErr(t, err)
    48  	defer os.Unsetenv("OS_SYSTEM_SCOPE")
    49  
    50  	clients.RequireAdmin(t)
    51  
    52  	client, err := clients.NewIdentityV3Client()
    53  	th.AssertNoErr(t, err)
    54  
    55  	project, err := CreateProject(t, client, nil)
    56  	th.AssertNoErr(t, err)
    57  
    58  	// Get the service to register the limit against.
    59  	allPages, err := services.List(client, nil).AllPages()
    60  	th.AssertNoErr(t, err)
    61  
    62  	svList, err := services.ExtractServices(allPages)
    63  	serviceID := ""
    64  	for _, service := range svList {
    65  		serviceID = service.ID
    66  		break
    67  	}
    68  	th.AssertIntGreaterOrEqual(t, len(serviceID), 1)
    69  
    70  	// Create global registered limit
    71  	description := tools.RandomString("GLOBALLIMIT-DESC-", 8)
    72  	defaultLimit := tools.RandomInt(1, 100)
    73  	globalResourceName := tools.RandomString("GLOBALLIMIT-", 8)
    74  
    75  	createRegisteredLimitsOpts := registeredlimits.BatchCreateOpts{
    76  		registeredlimits.CreateOpts{
    77  			ServiceID:    serviceID,
    78  			ResourceName: globalResourceName,
    79  			DefaultLimit: defaultLimit,
    80  			Description:  description,
    81  			RegionID:     "RegionOne",
    82  		},
    83  	}
    84  
    85  	createdRegisteredLimits, err := registeredlimits.BatchCreate(client, createRegisteredLimitsOpts).Extract()
    86  	th.AssertNoErr(t, err)
    87  	tools.PrintResource(t, createdRegisteredLimits[0])
    88  	th.AssertIntGreaterOrEqual(t, 1, len(createdRegisteredLimits))
    89  
    90  	// Override global limit in specific project
    91  	limitDescription := tools.RandomString("TESTLIMITS-DESC-", 8)
    92  	resourceLimit := tools.RandomInt(1, 1000)
    93  
    94  	createOpts := limits.BatchCreateOpts{
    95  		limits.CreateOpts{
    96  			ServiceID:     serviceID,
    97  			ProjectID:     project.ID,
    98  			ResourceName:  globalResourceName,
    99  			ResourceLimit: resourceLimit,
   100  			Description:   limitDescription,
   101  			RegionID:      "RegionOne",
   102  		},
   103  	}
   104  
   105  	createdLimits, err := limits.BatchCreate(client, createOpts).Extract()
   106  	th.AssertNoErr(t, err)
   107  	th.AssertIntGreaterOrEqual(t, 1, len(createdLimits))
   108  	th.AssertEquals(t, limitDescription, createdLimits[0].Description)
   109  	th.AssertEquals(t, resourceLimit, createdLimits[0].ResourceLimit)
   110  	th.AssertEquals(t, globalResourceName, createdLimits[0].ResourceName)
   111  	th.AssertEquals(t, serviceID, createdLimits[0].ServiceID)
   112  	th.AssertEquals(t, project.ID, createdLimits[0].ProjectID)
   113  
   114  	limitID := createdLimits[0].ID
   115  
   116  	limit, err := limits.Get(client, limitID).Extract()
   117  	th.AssertNoErr(t, err)
   118  	th.AssertDeepEquals(t, createdLimits[0], *limit)
   119  
   120  	newLimitDescription := tools.RandomString("TESTLIMITS-DESC-CHNGD-", 8)
   121  	newResourceLimit := tools.RandomInt(1, 100)
   122  	updateOpts := limits.UpdateOpts{
   123  		Description:   &newLimitDescription,
   124  		ResourceLimit: &newResourceLimit,
   125  	}
   126  
   127  	updatedLimit, err := limits.Update(client, limitID, updateOpts).Extract()
   128  	th.AssertNoErr(t, err)
   129  	th.AssertEquals(t, newLimitDescription, updatedLimit.Description)
   130  	th.AssertEquals(t, newResourceLimit, updatedLimit.ResourceLimit)
   131  
   132  	// Verify Deleting registered limit fails as it has project specific limit associated with it
   133  	del_err := registeredlimits.Delete(client, createdRegisteredLimits[0].ID).ExtractErr()
   134  	th.AssertErr(t, del_err)
   135  
   136  	// Delete project specific limit
   137  	err = limits.Delete(client, limitID).ExtractErr()
   138  	th.AssertNoErr(t, err)
   139  
   140  	_, err = limits.Get(client, limitID).Extract()
   141  	th.AssertErr(t, err)
   142  
   143  	// Delete registered limit
   144  	err = registeredlimits.Delete(client, createdRegisteredLimits[0].ID).ExtractErr()
   145  	th.AssertNoErr(t, err)
   146  }