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

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package api
     5  
     6  import (
     7  	"errors"
     8  	"net/http"
     9  	"testing"
    10  
    11  	"github.com/hashicorp/nomad/api/internal/testutil"
    12  	"github.com/shoenig/test/must"
    13  )
    14  
    15  func TestNamespaces_Register(t *testing.T) {
    16  	testutil.Parallel(t)
    17  
    18  	c, s := makeClient(t, nil, nil)
    19  	defer s.Stop()
    20  	namespaces := c.Namespaces()
    21  
    22  	// Create a namespace and register it
    23  	ns := testNamespace()
    24  	wm, err := namespaces.Register(ns, nil)
    25  	must.NoError(t, err)
    26  	assertWriteMeta(t, wm)
    27  
    28  	// Query the jobs back out again
    29  	resp, qm, err := namespaces.List(nil)
    30  	must.NoError(t, err)
    31  	assertQueryMeta(t, qm)
    32  	must.Len(t, 2, resp)
    33  	must.Eq(t, ns.Name, resp[0].Name)
    34  	must.Eq(t, "default", resp[1].Name)
    35  }
    36  
    37  func TestNamespaces_Register_Invalid(t *testing.T) {
    38  	testutil.Parallel(t)
    39  
    40  	c, s := makeClient(t, nil, nil)
    41  	defer s.Stop()
    42  	namespaces := c.Namespaces()
    43  
    44  	// Create an invalid namespace and register it
    45  	ns := testNamespace()
    46  	ns.Name = "*"
    47  	_, err := namespaces.Register(ns, nil)
    48  	must.ErrorContains(t, err, `invalid name "*".`)
    49  }
    50  
    51  func TestNamespaces_Info(t *testing.T) {
    52  	testutil.Parallel(t)
    53  
    54  	c, s := makeClient(t, nil, nil)
    55  	defer s.Stop()
    56  	namespaces := c.Namespaces()
    57  
    58  	// Trying to retrieve a namespace before it exists returns an error
    59  	_, _, err := namespaces.Info("foo", nil)
    60  	must.NotNil(t, err)
    61  	must.ErrorContains(t, err, "not found")
    62  
    63  	// Register the namespace
    64  	ns := testNamespace()
    65  	wm, err := namespaces.Register(ns, nil)
    66  	must.NoError(t, err)
    67  	assertWriteMeta(t, wm)
    68  
    69  	// Query the namespace again and ensure it exists
    70  	result, qm, err := namespaces.Info(ns.Name, nil)
    71  	must.NoError(t, err)
    72  	assertQueryMeta(t, qm)
    73  	must.NotNil(t, result)
    74  	must.Eq(t, ns.Name, result.Name)
    75  }
    76  
    77  func TestNamespaces_Delete(t *testing.T) {
    78  	testutil.Parallel(t)
    79  
    80  	c, s := makeClient(t, nil, nil)
    81  	defer s.Stop()
    82  	namespaces := c.Namespaces()
    83  
    84  	// Create a namespace and register it
    85  	ns := testNamespace()
    86  	wm, err := namespaces.Register(ns, nil)
    87  	must.NoError(t, err)
    88  	assertWriteMeta(t, wm)
    89  
    90  	// Query the namespace back out again
    91  	resp, qm, err := namespaces.List(nil)
    92  	must.NoError(t, err)
    93  	assertQueryMeta(t, qm)
    94  	must.Len(t, 2, resp)
    95  	must.Eq(t, ns.Name, resp[0].Name)
    96  	must.Eq(t, "default", resp[1].Name)
    97  
    98  	// Delete the namespace
    99  	wm, err = namespaces.Delete(ns.Name, nil)
   100  	must.NoError(t, err)
   101  	assertWriteMeta(t, wm)
   102  
   103  	// Query the namespaces back out again
   104  	resp, qm, err = namespaces.List(nil)
   105  	must.NoError(t, err)
   106  	assertQueryMeta(t, qm)
   107  	must.Len(t, 1, resp)
   108  	must.Eq(t, "default", resp[0].Name)
   109  }
   110  
   111  func TestNamespaces_List(t *testing.T) {
   112  	testutil.Parallel(t)
   113  
   114  	c, s := makeClient(t, nil, nil)
   115  	defer s.Stop()
   116  	namespaces := c.Namespaces()
   117  
   118  	// Create two namespaces and register them
   119  	ns1 := testNamespace()
   120  	ns2 := testNamespace()
   121  	ns1.Name = "fooaaa"
   122  	ns2.Name = "foobbb"
   123  	wm, err := namespaces.Register(ns1, nil)
   124  	must.NoError(t, err)
   125  	assertWriteMeta(t, wm)
   126  
   127  	wm, err = namespaces.Register(ns2, nil)
   128  	must.NoError(t, err)
   129  	assertWriteMeta(t, wm)
   130  
   131  	// Query the namespaces
   132  	resp, qm, err := namespaces.List(nil)
   133  	must.NoError(t, err)
   134  	assertQueryMeta(t, qm)
   135  	must.Len(t, 3, resp)
   136  
   137  	// Query the namespaces using a prefix
   138  	resp, qm, err = namespaces.PrefixList("foo", nil)
   139  	must.NoError(t, err)
   140  	assertQueryMeta(t, qm)
   141  	must.Len(t, 2, resp)
   142  
   143  	// Query the namespaces using a prefix
   144  	resp, qm, err = namespaces.PrefixList("foob", nil)
   145  	must.NoError(t, err)
   146  	assertQueryMeta(t, qm)
   147  	must.Len(t, 1, resp)
   148  	must.Eq(t, ns2.Name, resp[0].Name)
   149  }
   150  
   151  func TestNamespace_NotFound(t *testing.T) {
   152  	testutil.Parallel(t)
   153  
   154  	c, s := makeClient(t, nil, nil)
   155  	defer s.Stop()
   156  	namespaces := c.Namespaces()
   157  
   158  	var ure UnexpectedResponseError
   159  	_, _, e := namespaces.Info("dummy", nil)
   160  
   161  	ok := errors.As(e, &ure)
   162  	must.True(t, ok)
   163  	must.Eq(t, http.StatusNotFound, ure.StatusCode())
   164  }