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

     1  // +build pro ent
     2  
     3  package api
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestNamespaces_Register(t *testing.T) {
    12  	t.Parallel()
    13  	assert := assert.New(t)
    14  	c, s := makeClient(t, nil, nil)
    15  	defer s.Stop()
    16  	namespaces := c.Namespaces()
    17  
    18  	// Create a namespace and register it
    19  	ns := testNamespace()
    20  	wm, err := namespaces.Register(ns, nil)
    21  	assert.Nil(err)
    22  	assertWriteMeta(t, wm)
    23  
    24  	// Query the jobs back out again
    25  	resp, qm, err := namespaces.List(nil)
    26  	assert.Nil(err)
    27  	assertQueryMeta(t, qm)
    28  	assert.Len(resp, 2)
    29  	assert.Equal(ns.Name, resp[0].Name)
    30  	assert.Equal("default", resp[1].Name)
    31  }
    32  
    33  func TestNamespaces_Register_Invalid(t *testing.T) {
    34  	t.Parallel()
    35  	assert := assert.New(t)
    36  	c, s := makeClient(t, nil, nil)
    37  	defer s.Stop()
    38  	namespaces := c.Namespaces()
    39  
    40  	// Create an invalid namespace and register it
    41  	ns := testNamespace()
    42  	ns.Name = "*"
    43  	_, err := namespaces.Register(ns, nil)
    44  	assert.NotNil(err)
    45  }
    46  
    47  func TestNamespace_Info(t *testing.T) {
    48  	t.Parallel()
    49  	assert := assert.New(t)
    50  	c, s := makeClient(t, nil, nil)
    51  	defer s.Stop()
    52  	namespaces := c.Namespaces()
    53  
    54  	// Trying to retrieve a namespace before it exists returns an error
    55  	_, _, err := namespaces.Info("foo", nil)
    56  	assert.NotNil(err)
    57  	assert.Contains(err.Error(), "not found")
    58  
    59  	// Register the namespace
    60  	ns := testNamespace()
    61  	wm, err := namespaces.Register(ns, nil)
    62  	assert.Nil(err)
    63  	assertWriteMeta(t, wm)
    64  
    65  	// Query the namespace again and ensure it exists
    66  	result, qm, err := namespaces.Info(ns.Name, nil)
    67  	assert.Nil(err)
    68  	assertQueryMeta(t, qm)
    69  	assert.NotNil(result)
    70  	assert.Equal(ns.Name, result.Name)
    71  }
    72  
    73  func TestNamespaces_Delete(t *testing.T) {
    74  	t.Parallel()
    75  	assert := assert.New(t)
    76  	c, s := makeClient(t, nil, nil)
    77  	defer s.Stop()
    78  	namespaces := c.Namespaces()
    79  
    80  	// Create a namespace and register it
    81  	ns := testNamespace()
    82  	wm, err := namespaces.Register(ns, nil)
    83  	assert.Nil(err)
    84  	assertWriteMeta(t, wm)
    85  
    86  	// Query the namespace back out again
    87  	resp, qm, err := namespaces.List(nil)
    88  	assert.Nil(err)
    89  	assertQueryMeta(t, qm)
    90  	assert.Len(resp, 2)
    91  	assert.Equal(ns.Name, resp[0].Name)
    92  	assert.Equal("default", resp[1].Name)
    93  
    94  	// Delete the namespace
    95  	wm, err = namespaces.Delete(ns.Name, nil)
    96  	assert.Nil(err)
    97  	assertWriteMeta(t, wm)
    98  
    99  	// Query the namespaces back out again
   100  	resp, qm, err = namespaces.List(nil)
   101  	assert.Nil(err)
   102  	assertQueryMeta(t, qm)
   103  	assert.Len(resp, 1)
   104  	assert.Equal("default", resp[0].Name)
   105  }
   106  
   107  func TestNamespaces_List(t *testing.T) {
   108  	t.Parallel()
   109  	assert := assert.New(t)
   110  	c, s := makeClient(t, nil, nil)
   111  	defer s.Stop()
   112  	namespaces := c.Namespaces()
   113  
   114  	// Create two namespaces and register them
   115  	ns1 := testNamespace()
   116  	ns2 := testNamespace()
   117  	ns1.Name = "fooaaa"
   118  	ns2.Name = "foobbb"
   119  	wm, err := namespaces.Register(ns1, nil)
   120  	assert.Nil(err)
   121  	assertWriteMeta(t, wm)
   122  
   123  	wm, err = namespaces.Register(ns2, nil)
   124  	assert.Nil(err)
   125  	assertWriteMeta(t, wm)
   126  
   127  	// Query the namespaces
   128  	resp, qm, err := namespaces.List(nil)
   129  	assert.Nil(err)
   130  	assertQueryMeta(t, qm)
   131  	assert.Len(resp, 3)
   132  
   133  	// Query the namespaces using a prefix
   134  	resp, qm, err = namespaces.PrefixList("foo", nil)
   135  	assert.Nil(err)
   136  	assertQueryMeta(t, qm)
   137  	assert.Len(resp, 2)
   138  
   139  	// Query the namespaces using a prefix
   140  	resp, qm, err = namespaces.PrefixList("foob", nil)
   141  	assert.Nil(err)
   142  	assertQueryMeta(t, qm)
   143  	assert.Len(resp, 1)
   144  	assert.Equal(ns2.Name, resp[0].Name)
   145  }