github.com/hashicorp/nomad/api@v0.0.0-20240306165712-3193ac204f65/quota_test.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  //go:build ent
     5  
     6  package api
     7  
     8  import (
     9  	"testing"
    10  
    11  	"github.com/hashicorp/nomad/api/internal/testutil"
    12  	"github.com/shoenig/test/must"
    13  )
    14  
    15  func TestQuotas_Register(t *testing.T) {
    16  	testutil.Parallel(t)
    17  
    18  	c, s := makeClient(t, nil, nil)
    19  	defer s.Stop()
    20  	quotas := c.Quotas()
    21  
    22  	// Create a quota spec and register it
    23  	qs := testQuotaSpec()
    24  	wm, err := quotas.Register(qs, nil)
    25  	must.NoError(t, err)
    26  	assertWriteMeta(t, wm)
    27  
    28  	// Query the specs back out again
    29  	resp, qm, err := quotas.List(nil)
    30  	must.NoError(t, err)
    31  	assertQueryMeta(t, qm)
    32  	must.Len(t, 1, resp)
    33  	must.Eq(t, qs.Name, resp[0].Name)
    34  }
    35  
    36  func TestQuotas_Register_Invalid(t *testing.T) {
    37  	testutil.Parallel(t)
    38  
    39  	c, s := makeClient(t, nil, nil)
    40  	defer s.Stop()
    41  	quotas := c.Quotas()
    42  
    43  	// Create an invalid namespace and register it
    44  	qs := testQuotaSpec()
    45  	qs.Name = "*"
    46  	_, err := quotas.Register(qs, nil)
    47  	must.Error(t, err)
    48  }
    49  
    50  func TestQuotas_Info(t *testing.T) {
    51  	testutil.Parallel(t)
    52  
    53  	c, s := makeClient(t, nil, nil)
    54  	defer s.Stop()
    55  	quotas := c.Quotas()
    56  
    57  	// Trying to retrieve a quota spec before it exists returns an error
    58  	_, _, err := quotas.Info("foo", nil)
    59  	must.ErrorContains(t, err, "not found")
    60  
    61  	// Register the quota
    62  	qs := testQuotaSpec()
    63  	wm, err := quotas.Register(qs, nil)
    64  	must.NoError(t, err)
    65  	assertWriteMeta(t, wm)
    66  
    67  	// Query the quota again and ensure it exists
    68  	result, qm, err := quotas.Info(qs.Name, nil)
    69  	must.NoError(t, err)
    70  	assertQueryMeta(t, qm)
    71  	must.NotNil(t, result)
    72  	must.Eq(t, qs.Name, result.Name)
    73  }
    74  
    75  func TestQuotas_Usage(t *testing.T) {
    76  	testutil.Parallel(t)
    77  
    78  	c, s := makeClient(t, nil, nil)
    79  	defer s.Stop()
    80  	quotas := c.Quotas()
    81  
    82  	// Trying to retrieve a quota spec before it exists returns an error
    83  	_, _, err := quotas.Usage("foo", nil)
    84  	must.ErrorContains(t, err, "not found")
    85  
    86  	// Register the quota
    87  	qs := testQuotaSpec()
    88  	wm, err := quotas.Register(qs, nil)
    89  	must.NoError(t, err)
    90  	assertWriteMeta(t, wm)
    91  
    92  	// Query the quota usage and ensure it exists
    93  	result, qm, err := quotas.Usage(qs.Name, nil)
    94  	must.NoError(t, err)
    95  	assertQueryMeta(t, qm)
    96  	must.NotNil(t, result)
    97  	must.Eq(t, qs.Name, result.Name)
    98  }
    99  
   100  func TestQuotas_Delete(t *testing.T) {
   101  	testutil.Parallel(t)
   102  
   103  	c, s := makeClient(t, nil, nil)
   104  	defer s.Stop()
   105  	quotas := c.Quotas()
   106  
   107  	// Create a quota and register it
   108  	qs := testQuotaSpec()
   109  	wm, err := quotas.Register(qs, nil)
   110  	must.NoError(t, err)
   111  	assertWriteMeta(t, wm)
   112  
   113  	// Query the quota back out again
   114  	resp, qm, err := quotas.List(nil)
   115  	must.NoError(t, err)
   116  	assertQueryMeta(t, qm)
   117  	must.Len(t, 1, resp)
   118  	must.Eq(t, qs.Name, resp[0].Name)
   119  
   120  	// Delete the quota
   121  	wm, err = quotas.Delete(qs.Name, nil)
   122  	must.NoError(t, err)
   123  	assertWriteMeta(t, wm)
   124  
   125  	// Query the quotas back out again
   126  	resp, qm, err = quotas.List(nil)
   127  	must.NoError(t, err)
   128  	assertQueryMeta(t, qm)
   129  	must.SliceEmpty(t, resp)
   130  }
   131  
   132  func TestQuotas_List(t *testing.T) {
   133  	testutil.Parallel(t)
   134  
   135  	c, s := makeClient(t, nil, nil)
   136  	defer s.Stop()
   137  	quotas := c.Quotas()
   138  
   139  	// Create two quotas and register them
   140  	qs1 := testQuotaSpec()
   141  	qs2 := testQuotaSpec()
   142  	qs1.Name = "fooaaa"
   143  	qs2.Name = "foobbb"
   144  	wm, err := quotas.Register(qs1, nil)
   145  	must.NoError(t, err)
   146  	assertWriteMeta(t, wm)
   147  
   148  	wm, err = quotas.Register(qs2, nil)
   149  	must.NoError(t, err)
   150  	assertWriteMeta(t, wm)
   151  
   152  	// Query the quotas
   153  	resp, qm, err := quotas.List(nil)
   154  	must.NoError(t, err)
   155  	assertQueryMeta(t, qm)
   156  	must.Len(t, 2, resp)
   157  
   158  	// Query the quotas using a prefix
   159  	resp, qm, err = quotas.PrefixList("foo", nil)
   160  	must.NoError(t, err)
   161  	assertQueryMeta(t, qm)
   162  	must.Len(t, 2, resp)
   163  
   164  	// Query the quotas using a prefix
   165  	resp, qm, err = quotas.PrefixList("foob", nil)
   166  	must.NoError(t, err)
   167  	assertQueryMeta(t, qm)
   168  	must.Len(t, 1, resp)
   169  	must.Eq(t, qs2.Name, resp[0].Name)
   170  }
   171  
   172  func TestQuotas_ListUsages(t *testing.T) {
   173  	testutil.Parallel(t)
   174  
   175  	c, s := makeClient(t, nil, nil)
   176  	defer s.Stop()
   177  	quotas := c.Quotas()
   178  
   179  	// Create two quotas and register them
   180  	qs1 := testQuotaSpec()
   181  	qs2 := testQuotaSpec()
   182  	qs1.Name = "fooaaa"
   183  	qs2.Name = "foobbb"
   184  	wm, err := quotas.Register(qs1, nil)
   185  	must.NoError(t, err)
   186  	assertWriteMeta(t, wm)
   187  
   188  	wm, err = quotas.Register(qs2, nil)
   189  	must.NoError(t, err)
   190  	assertWriteMeta(t, wm)
   191  
   192  	// Query the quotas
   193  	resp, qm, err := quotas.ListUsage(nil)
   194  	must.NoError(t, err)
   195  	assertQueryMeta(t, qm)
   196  	must.Len(t, 2, resp)
   197  
   198  	// Query the quotas using a prefix
   199  	resp, qm, err = quotas.PrefixListUsage("foo", nil)
   200  	must.NoError(t, err)
   201  	assertQueryMeta(t, qm)
   202  	must.Len(t, 2, resp)
   203  
   204  	// Query the quotas using a prefix
   205  	resp, qm, err = quotas.PrefixListUsage("foob", nil)
   206  	must.NoError(t, err)
   207  	assertQueryMeta(t, qm)
   208  	must.Len(t, 1, resp)
   209  	must.Eq(t, qs2.Name, resp[0].Name)
   210  }