github.com/blixtra/nomad@v0.7.2-0.20171221000451-da9a1d7bb050/api/quota_test.go (about)

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