github.com/anth0d/nomad@v0.0.0-20221214183521-ae3a0a2cad06/command/namespace_status_test.go (about) 1 package command 2 3 import ( 4 "strings" 5 "testing" 6 7 "github.com/hashicorp/nomad/api" 8 "github.com/hashicorp/nomad/ci" 9 "github.com/mitchellh/cli" 10 "github.com/posener/complete" 11 "github.com/stretchr/testify/assert" 12 ) 13 14 func TestNamespaceStatusCommand_Implements(t *testing.T) { 15 ci.Parallel(t) 16 var _ cli.Command = &NamespaceStatusCommand{} 17 } 18 19 func TestNamespaceStatusCommand_Fails(t *testing.T) { 20 ci.Parallel(t) 21 ui := cli.NewMockUi() 22 cmd := &NamespaceStatusCommand{Meta: Meta{Ui: ui}} 23 24 // Fails on misuse 25 if code := cmd.Run([]string{"some", "bad", "args"}); code != 1 { 26 t.Fatalf("expected exit code 1, got: %d", code) 27 } 28 if out := ui.ErrorWriter.String(); !strings.Contains(out, commandErrorText(cmd)) { 29 t.Fatalf("expected help output, got: %s", out) 30 } 31 ui.ErrorWriter.Reset() 32 33 if code := cmd.Run([]string{"-address=nope", "foo"}); code != 1 { 34 t.Fatalf("expected exit code 1, got: %d", code) 35 } 36 if out := ui.ErrorWriter.String(); !strings.Contains(out, "retrieving namespace") { 37 t.Fatalf("connection error, got: %s", out) 38 } 39 ui.ErrorWriter.Reset() 40 } 41 42 func TestNamespaceStatusCommand_Good(t *testing.T) { 43 ci.Parallel(t) 44 45 // Create a server 46 srv, client, url := testServer(t, true, nil) 47 defer srv.Shutdown() 48 49 ui := cli.NewMockUi() 50 cmd := &NamespaceStatusCommand{Meta: Meta{Ui: ui}} 51 52 // Create a namespace 53 ns := &api.Namespace{ 54 Name: "foo", 55 } 56 _, err := client.Namespaces().Register(ns, nil) 57 assert.Nil(t, err) 58 59 // Check status on namespace 60 if code := cmd.Run([]string{"-address=" + url, ns.Name}); code != 0 { 61 t.Fatalf("expected exit 0, got: %d; %v", code, ui.ErrorWriter.String()) 62 } 63 64 // Check for basic spec 65 out := ui.OutputWriter.String() 66 if !strings.Contains(out, "= foo") { 67 t.Fatalf("expected quota, got: %s", out) 68 } 69 } 70 71 func TestNamespaceStatusCommand_Good_Quota(t *testing.T) { 72 ci.Parallel(t) 73 74 // Create a server 75 srv, client, url := testServer(t, true, nil) 76 defer srv.Shutdown() 77 78 if !srv.Enterprise { 79 t.Skip("Skipping enterprise-only quota test") 80 } 81 82 ui := cli.NewMockUi() 83 cmd := &NamespaceStatusCommand{Meta: Meta{Ui: ui}} 84 85 // Create a quota to delete 86 qs := testQuotaSpec() 87 _, err := client.Quotas().Register(qs, nil) 88 assert.Nil(t, err) 89 90 // Create a namespace 91 ns := &api.Namespace{ 92 Name: "foo", 93 Quota: qs.Name, 94 } 95 _, err = client.Namespaces().Register(ns, nil) 96 assert.Nil(t, err) 97 98 // Check status on namespace 99 if code := cmd.Run([]string{"-address=" + url, ns.Name}); code != 0 { 100 t.Fatalf("expected exit 0, got: %d; %v", code, ui.ErrorWriter.String()) 101 } 102 103 // Check for basic spec 104 out := ui.OutputWriter.String() 105 if !strings.Contains(out, "= foo") { 106 t.Fatalf("expected quota, got: %s", out) 107 } 108 109 // Check for usage 110 if !strings.Contains(out, "0 / 100") { 111 t.Fatalf("expected quota, got: %s", out) 112 } 113 } 114 115 func TestNamespaceStatusCommand_AutocompleteArgs(t *testing.T) { 116 ci.Parallel(t) 117 assert := assert.New(t) 118 119 srv, client, url := testServer(t, true, nil) 120 defer srv.Shutdown() 121 122 ui := cli.NewMockUi() 123 cmd := &NamespaceStatusCommand{Meta: Meta{Ui: ui, flagAddress: url}} 124 125 // Create a namespace 126 ns := &api.Namespace{ 127 Name: "foo", 128 } 129 _, err := client.Namespaces().Register(ns, nil) 130 assert.Nil(err) 131 132 args := complete.Args{Last: "f"} 133 predictor := cmd.AutocompleteArgs() 134 135 res := predictor.Predict(args) 136 assert.Equal(1, len(res)) 137 assert.Equal(ns.Name, res[0]) 138 } 139 140 // This test should demonstrate the behavior of a namespace 141 // and prefix collision. In that case, the Namespace status 142 // command should pull the matching namespace rather than 143 // displaying the multiple match error 144 func TestNamespaceStatusCommand_NamespaceMatchesPrefix(t *testing.T) { 145 ci.Parallel(t) 146 147 // Create a server 148 srv, client, url := testServer(t, true, nil) 149 defer srv.Shutdown() 150 151 ui := cli.NewMockUi() 152 cmd := &NamespaceStatusCommand{Meta: Meta{Ui: ui}} 153 154 // Create a namespace that uses foo as a prefix 155 ns := &api.Namespace{Name: "fooBar"} 156 _, err := client.Namespaces().Register(ns, nil) 157 assert.Nil(t, err) 158 159 // Create a foo namespace 160 ns2 := &api.Namespace{Name: "foo"} 161 _, err = client.Namespaces().Register(ns2, nil) 162 assert.Nil(t, err) 163 164 // Adding a NS after to prevent sort from creating 165 // false successes 166 ns = &api.Namespace{Name: "fooBaz"} 167 _, err = client.Namespaces().Register(ns, nil) 168 assert.Nil(t, err) 169 170 // Check status on namespace 171 code := cmd.Run([]string{"-address=" + url, ns2.Name}) 172 if code != 0 { 173 t.Fatalf("expected exit 0, got: %d; %v", code, ui.ErrorWriter.String()) 174 } 175 // Check to ensure we got the proper foo 176 out := ui.OutputWriter.String() 177 if !strings.Contains(out, "= foo\n") { 178 t.Fatalf("expected namespace foo, got: %s", out) 179 } 180 }