delete command ready (#18679)

* delete command for resource management
stepbui1-patch-1
wangxinyi7 1 year ago committed by GitHub
parent 09fffd4b1e
commit 426c906ee1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -5,6 +5,7 @@ package api
import ( import (
"fmt" "fmt"
"net/http"
"strings" "strings"
"github.com/hashicorp/consul/proto-public/pbresource" "github.com/hashicorp/consul/proto-public/pbresource"
@ -65,6 +66,20 @@ func (resource *Resource) Read(gvk *GVK, resourceName string, q *QueryOptions) (
return out, nil return out, nil
} }
func (resource *Resource) Delete(gvk *GVK, resourceName string, q *QueryOptions) error {
r := resource.c.newRequest("DELETE", strings.ToLower(fmt.Sprintf("/api/%s/%s/%s/%s", gvk.Group, gvk.Version, gvk.Kind, resourceName)))
r.setQueryOptions(q)
_, resp, err := resource.c.doRequest(r)
if err != nil {
return err
}
defer closeResponseBody(resp)
if err := requireHttpCodes(resp, http.StatusNoContent); err != nil {
return err
}
return nil
}
func (resource *Resource) Apply(gvk *GVK, resourceName string, q *QueryOptions, payload *WriteRequest) (*WriteResponse, *WriteMeta, error) { func (resource *Resource) Apply(gvk *GVK, resourceName string, q *QueryOptions, payload *WriteRequest) (*WriteResponse, *WriteMeta, error) {
url := strings.ToLower(fmt.Sprintf("/api/%s/%s/%s/%s", gvk.Group, gvk.Version, gvk.Kind, resourceName)) url := strings.ToLower(fmt.Sprintf("/api/%s/%s/%s/%s", gvk.Group, gvk.Version, gvk.Kind, resourceName))

@ -110,6 +110,7 @@ import (
"github.com/hashicorp/consul/command/reload" "github.com/hashicorp/consul/command/reload"
"github.com/hashicorp/consul/command/resource" "github.com/hashicorp/consul/command/resource"
resourceapply "github.com/hashicorp/consul/command/resource/apply" resourceapply "github.com/hashicorp/consul/command/resource/apply"
resourcedelete "github.com/hashicorp/consul/command/resource/delete"
resourcelist "github.com/hashicorp/consul/command/resource/list" resourcelist "github.com/hashicorp/consul/command/resource/list"
resourceread "github.com/hashicorp/consul/command/resource/read" resourceread "github.com/hashicorp/consul/command/resource/read"
"github.com/hashicorp/consul/command/rtt" "github.com/hashicorp/consul/command/rtt"
@ -244,6 +245,7 @@ func RegisteredCommands(ui cli.Ui) map[string]mcli.CommandFactory {
entry{"reload", func(ui cli.Ui) (cli.Command, error) { return reload.New(ui), nil }}, entry{"reload", func(ui cli.Ui) (cli.Command, error) { return reload.New(ui), nil }},
entry{"resource", func(cli.Ui) (cli.Command, error) { return resource.New(), nil }}, entry{"resource", func(cli.Ui) (cli.Command, error) { return resource.New(), nil }},
entry{"resource read", func(ui cli.Ui) (cli.Command, error) { return resourceread.New(ui), nil }}, entry{"resource read", func(ui cli.Ui) (cli.Command, error) { return resourceread.New(ui), nil }},
entry{"resource delete", func(ui cli.Ui) (cli.Command, error) { return resourcedelete.New(ui), nil }},
entry{"resource apply", func(ui cli.Ui) (cli.Command, error) { return resourceapply.New(ui), nil }}, entry{"resource apply", func(ui cli.Ui) (cli.Command, error) { return resourceapply.New(ui), nil }},
entry{"resource list", func(ui cli.Ui) (cli.Command, error) { return resourcelist.New(ui), nil }}, entry{"resource list", func(ui cli.Ui) (cli.Command, error) { return resourcelist.New(ui), nil }},
entry{"rtt", func(ui cli.Ui) (cli.Command, error) { return rtt.New(ui), nil }}, entry{"rtt", func(ui cli.Ui) (cli.Command, error) { return rtt.New(ui), nil }},

@ -0,0 +1,162 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
package delete
import (
"errors"
"flag"
"fmt"
"github.com/mitchellh/cli"
"github.com/hashicorp/consul/api"
"github.com/hashicorp/consul/command/flags"
"github.com/hashicorp/consul/command/resource"
)
func New(ui cli.Ui) *cmd {
c := &cmd{UI: ui}
c.init()
return c
}
type cmd struct {
UI cli.Ui
flags *flag.FlagSet
http *flags.HTTPFlags
help string
filePath string
}
func (c *cmd) init() {
c.flags = flag.NewFlagSet("", flag.ContinueOnError)
c.http = &flags.HTTPFlags{}
c.flags.StringVar(&c.filePath, "f", "", "File path with resource definition")
flags.Merge(c.flags, c.http.ClientFlags())
flags.Merge(c.flags, c.http.ServerFlags())
flags.Merge(c.flags, c.http.MultiTenancyFlags())
flags.Merge(c.flags, c.http.AddPeerName())
c.help = flags.Usage(help, c.flags)
}
func (c *cmd) Run(args []string) int {
var gvk *api.GVK
var resourceName string
var opts *api.QueryOptions
if err := c.flags.Parse(args); err != nil {
if !errors.Is(err, flag.ErrHelp) {
c.UI.Error(fmt.Sprintf("Failed to parse args: %v", err))
return 1
}
}
if c.flags.Lookup("f").Value.String() != "" {
if c.filePath != "" {
parsedResource, err := resource.ParseResourceFromFile(c.filePath)
if err != nil {
c.UI.Error(fmt.Sprintf("Failed to decode resource from input file: %v", err))
return 1
}
if parsedResource == nil {
c.UI.Error("Unable to parse the file argument")
return 1
}
gvk = &api.GVK{
Group: parsedResource.Id.Type.GetGroup(),
Version: parsedResource.Id.Type.GetGroupVersion(),
Kind: parsedResource.Id.Type.GetKind(),
}
resourceName = parsedResource.Id.GetName()
opts = &api.QueryOptions{
Namespace: parsedResource.Id.Tenancy.GetNamespace(),
Partition: parsedResource.Id.Tenancy.GetPartition(),
Peer: parsedResource.Id.Tenancy.GetPeerName(),
Token: c.http.Token(),
}
} else {
c.UI.Error(fmt.Sprintf("Please provide an input file with resource definition"))
return 1
}
} else {
if len(args) < 2 {
c.UI.Error("Your argument format is incorrect: Must specify two arguments: resource type and resource name")
return 1
}
var err error
gvk, resourceName, err = resource.GetTypeAndResourceName(args)
if err != nil {
c.UI.Error(fmt.Sprintf("Your argument format is incorrect: %s", err))
return 1
}
inputArgs := args[2:]
err = resource.ParseInputParams(inputArgs, c.flags)
if err != nil {
c.UI.Error(fmt.Sprintf("Error parsing input arguments: %v", err))
return 1
}
if c.filePath != "" {
c.UI.Warn("We ignored the -f flag if you provide gvk and resource name")
}
opts = &api.QueryOptions{
Namespace: c.http.Namespace(),
Partition: c.http.Partition(),
Peer: c.http.PeerName(),
Token: c.http.Token(),
}
}
client, err := c.http.APIClient()
if err != nil {
c.UI.Error(fmt.Sprintf("Error connect to Consul agent: %s", err))
return 1
}
if err := client.Resource().Delete(gvk, resourceName, opts); err != nil {
c.UI.Error(fmt.Sprintf("Error deleting resource %s.%s.%s/%s: %v", gvk.Group, gvk.Version, gvk.Kind, resourceName, err))
return 1
}
c.UI.Info(fmt.Sprintf("%s.%s.%s/%s deleted", gvk.Group, gvk.Version, gvk.Kind, resourceName))
return 0
}
func (c *cmd) Synopsis() string {
return synopsis
}
func (c *cmd) Help() string {
return flags.Usage(c.help, nil)
}
const synopsis = "Delete resource information"
const help = `
Usage: You have two options to delete the resource specified by the given
type, name, partition, namespace and peer and outputs its JSON representation.
consul resource delete [type] [name] -partition=<default> -namespace=<default> -peer=<local>
consul resource delete -f [resource_file_path]
But you could only use one of the approaches.
Example:
$ consul resource delete catalog.v1alpha1.Service card-processor -partition=billing -namespace=payments -peer=eu
$ consul resource delete -f resource.hcl
In resource.hcl, it could be:
ID {
Type = gvk("catalog.v1alpha1.Service")
Name = "card-processor"
Tenancy {
Namespace = "payments"
Partition = "billing"
PeerName = "eu"
}
}
`

@ -0,0 +1,158 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
package delete
import (
"errors"
"testing"
"github.com/mitchellh/cli"
"github.com/stretchr/testify/require"
"github.com/hashicorp/consul/agent"
"github.com/hashicorp/consul/command/resource/apply"
"github.com/hashicorp/consul/testrpc"
)
func TestResourceDeleteInvalidArgs(t *testing.T) {
t.Parallel()
type tc struct {
args []string
expectedCode int
expectedErr error
}
cases := map[string]tc{
"nil args": {
args: nil,
expectedCode: 1,
expectedErr: errors.New("Your argument format is incorrect: Must specify two arguments: resource type and resource name"),
},
"empty args": {
args: []string{},
expectedCode: 1,
expectedErr: errors.New("Your argument format is incorrect: Must specify two arguments: resource type and resource name"),
},
"missing file path": {
args: []string{"-f"},
expectedCode: 1,
expectedErr: errors.New("Failed to parse args: flag needs an argument: -f"),
},
"file not found": {
args: []string{"-f=../testdata/test.hcl"},
expectedCode: 1,
expectedErr: errors.New("Failed to load data: Failed to read file: open ../testdata/test.hcl: no such file or directory"),
},
"provide type and name": {
args: []string{"a.b.c"},
expectedCode: 1,
expectedErr: errors.New("Your argument format is incorrect: Must specify two arguments: resource type and resource name"),
},
"provide type and name with -f": {
args: []string{"a.b.c", "name", "-f", "test.hcl"},
expectedCode: 1,
expectedErr: errors.New("We ignored the -f flag if you provide gvk and resource name"),
},
"provide type and name with -f and other flags": {
args: []string{"a.b.c", "name", "-f", "test.hcl", "-namespace", "default"},
expectedCode: 1,
expectedErr: errors.New("We ignored the -f flag if you provide gvk and resource name"),
},
"does not provide resource name after type": {
args: []string{"a.b.c", "-namespace", "default"},
expectedCode: 1,
expectedErr: errors.New("Your argument format is incorrect: Must provide resource name right after type"),
},
"invalid resource type format": {
args: []string{"a.", "name", "-namespace", "default"},
expectedCode: 1,
expectedErr: errors.New("Your argument format is incorrect: Must include resource type argument in group.verion.kind format"),
},
}
for desc, tc := range cases {
t.Run(desc, func(t *testing.T) {
ui := cli.NewMockUi()
c := New(ui)
code := c.Run(tc.args)
require.Equal(t, tc.expectedCode, code)
require.Contains(t, ui.ErrorWriter.String(), tc.expectedErr.Error())
})
}
}
func createResource(t *testing.T, a *agent.TestAgent) {
applyUi := cli.NewMockUi()
applyCmd := apply.New(applyUi)
args := []string{
"-http-addr=" + a.HTTPAddr(),
"-token=root",
}
args = append(args, []string{"-f=../testdata/demo.hcl"}...)
code := applyCmd.Run(args)
require.Equal(t, 0, code)
require.Empty(t, applyUi.ErrorWriter.String())
}
func TestResourceDelete(t *testing.T) {
if testing.Short() {
t.Skip("too slow for testing.Short")
}
t.Parallel()
a := agent.NewTestAgent(t, ``)
defer a.Shutdown()
testrpc.WaitForTestAgent(t, a.RPC, "dc1")
defaultCmdArgs := []string{
"-http-addr=" + a.HTTPAddr(),
"-token=root",
}
cases := []struct {
name string
args []string
expectedCode int
createResource bool
}{
{
name: "delete resource in hcl format",
args: []string{"-f=../testdata/demo.hcl"},
expectedCode: 0,
createResource: true,
},
{
name: "delete resource in command line format",
args: []string{"demo.v2.Artist", "korn", "-partition=default", "-namespace=default", "-peer=local"},
expectedCode: 0,
createResource: true,
},
{
name: "delete resource that doesn't exist in command line format",
args: []string{"demo.v2.Artist", "korn", "-partition=default", "-namespace=default", "-peer=local"},
expectedCode: 0,
createResource: false,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
ui := cli.NewMockUi()
c := New(ui)
cliArgs := append(tc.args, defaultCmdArgs...)
if tc.createResource {
createResource(t, a)
}
code := c.Run(cliArgs)
require.Empty(t, ui.ErrorWriter.String())
require.Equal(t, tc.expectedCode, code)
require.Contains(t, ui.OutputWriter.String(), "deleted")
})
}
}

@ -7,8 +7,10 @@ import (
"errors" "errors"
"flag" "flag"
"fmt" "fmt"
"strings"
"github.com/hashicorp/consul/agent/consul" "github.com/hashicorp/consul/agent/consul"
"github.com/hashicorp/consul/api"
"github.com/hashicorp/consul/command/helpers" "github.com/hashicorp/consul/command/helpers"
"github.com/hashicorp/consul/internal/resourcehcl" "github.com/hashicorp/consul/internal/resourcehcl"
"github.com/hashicorp/consul/proto-public/pbresource" "github.com/hashicorp/consul/proto-public/pbresource"
@ -35,3 +37,24 @@ func ParseInputParams(inputArgs []string, flags *flag.FlagSet) error {
} }
return nil return nil
} }
func GetTypeAndResourceName(args []string) (gvk *api.GVK, resourceName string, e error) {
// it has to be resource name after the type
if strings.HasPrefix(args[1], "-") {
return nil, "", fmt.Errorf("Must provide resource name right after type")
}
s := strings.Split(args[0], ".")
if len(s) != 3 {
return nil, "", fmt.Errorf("Must include resource type argument in group.verion.kind format")
}
gvk = &api.GVK{
Group: s[0],
Version: s[1],
Kind: s[2],
}
resourceName = args[1]
return
}

@ -8,15 +8,12 @@ import (
"errors" "errors"
"flag" "flag"
"fmt" "fmt"
"strings"
"github.com/mitchellh/cli" "github.com/mitchellh/cli"
"github.com/hashicorp/consul/agent/consul"
"github.com/hashicorp/consul/api" "github.com/hashicorp/consul/api"
"github.com/hashicorp/consul/command/flags" "github.com/hashicorp/consul/command/flags"
"github.com/hashicorp/consul/command/helpers" "github.com/hashicorp/consul/command/resource"
"github.com/hashicorp/consul/internal/resourcehcl"
) )
func New(ui cli.Ui) *cmd { func New(ui cli.Ui) *cmd {
@ -50,11 +47,6 @@ func (c *cmd) Run(args []string) int {
var resourceName string var resourceName string
var opts *api.QueryOptions var opts *api.QueryOptions
if len(args) == 0 {
c.UI.Error("Please provide required arguments")
return 1
}
if err := c.flags.Parse(args); err != nil { if err := c.flags.Parse(args); err != nil {
if !errors.Is(err, flag.ErrHelp) { if !errors.Is(err, flag.ErrHelp) {
c.UI.Error(fmt.Sprintf("Failed to parse args: %v", err)) c.UI.Error(fmt.Sprintf("Failed to parse args: %v", err))
@ -64,14 +56,14 @@ func (c *cmd) Run(args []string) int {
if c.flags.Lookup("f").Value.String() != "" { if c.flags.Lookup("f").Value.String() != "" {
if c.filePath != "" { if c.filePath != "" {
data, err := helpers.LoadDataSourceNoRaw(c.filePath, nil) parsedResource, err := resource.ParseResourceFromFile(c.filePath)
if err != nil { if err != nil {
c.UI.Error(fmt.Sprintf("Failed to load data: %v", err)) c.UI.Error(fmt.Sprintf("Failed to decode resource from input file: %v", err))
return 1 return 1
} }
parsedResource, err := resourcehcl.Unmarshal([]byte(data), consul.NewTypeRegistry())
if err != nil { if parsedResource == nil {
c.UI.Error(fmt.Sprintf("Failed to decode resource from input file: %v", err)) c.UI.Error("Unable to parse the file argument")
return 1 return 1
} }
@ -94,27 +86,24 @@ func (c *cmd) Run(args []string) int {
} }
} else { } else {
if len(args) < 2 { if len(args) < 2 {
c.UI.Error("Must specify two arguments: resource type and resource name") c.UI.Error("Your argument format is incorrect: Must specify two arguments: resource type and resource name")
return 1 return 1
} }
var err error var err error
gvk, resourceName, err = getTypeAndResourceName(args) gvk, resourceName, err = resource.GetTypeAndResourceName(args)
if err != nil { if err != nil {
c.UI.Error(fmt.Sprintf("Your argument format is incorrect: %s", err)) c.UI.Error(fmt.Sprintf("Your argument format is incorrect: %s", err))
return 1 return 1
} }
inputArgs := args[2:] inputArgs := args[2:]
if err := c.flags.Parse(inputArgs); err != nil { err = resource.ParseInputParams(inputArgs, c.flags)
if errors.Is(err, flag.ErrHelp) { if err != nil {
return 0 c.UI.Error(fmt.Sprintf("Error parsing input arguments: %v", err))
}
c.UI.Error(fmt.Sprintf("Failed to parse args: %v", err))
return 1 return 1
} }
if c.filePath != "" { if c.filePath != "" {
c.UI.Error("You need to provide all information in the HCL file if provide its file path") c.UI.Warn("We ignored the -f flag if you provide gvk and resource name")
return 1
} }
opts = &api.QueryOptions{ opts = &api.QueryOptions{
Namespace: c.http.Namespace(), Namespace: c.http.Namespace(),
@ -147,22 +136,6 @@ func (c *cmd) Run(args []string) int {
return 0 return 0
} }
func getTypeAndResourceName(args []string) (gvk *api.GVK, resourceName string, e error) {
if strings.HasPrefix(args[1], "-") {
return nil, "", fmt.Errorf("Must provide resource name right after type")
}
s := strings.Split(args[0], ".")
gvk = &api.GVK{
Group: s[0],
Version: s[1],
Kind: s[2],
}
resourceName = args[1]
return
}
func (c *cmd) Synopsis() string { func (c *cmd) Synopsis() string {
return synopsis return synopsis
} }

@ -3,56 +3,71 @@
package read package read
import ( import (
"errors"
"testing" "testing"
"github.com/mitchellh/cli" "github.com/mitchellh/cli"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/hashicorp/consul/agent"
"github.com/hashicorp/consul/command/resource/apply"
"github.com/hashicorp/consul/testrpc"
) )
func TestResourceReadInvalidArgs(t *testing.T) { func TestResourceReadInvalidArgs(t *testing.T) {
t.Parallel() t.Parallel()
type tc struct { type tc struct {
args []string args []string
expectedCode int expectedCode int
expectedErrMsg string expectedErr error
} }
cases := map[string]tc{ cases := map[string]tc{
"nil args": { "nil args": {
args: nil, args: nil,
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "Please provide required arguments", expectedErr: errors.New("Your argument format is incorrect: Must specify two arguments: resource type and resource name"),
}, },
"empty args": { "empty args": {
args: []string{}, args: []string{},
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "Please provide required arguments", expectedErr: errors.New("Your argument format is incorrect: Must specify two arguments: resource type and resource name"),
}, },
"missing file path": { "missing file path": {
args: []string{"-f"}, args: []string{"-f"},
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "Please input file path", expectedErr: errors.New("Failed to parse args: flag needs an argument: -f"),
},
"file not found": {
args: []string{"-f=../testdata/test.hcl"},
expectedCode: 1,
expectedErr: errors.New("Failed to load data: Failed to read file: open ../testdata/test.hcl: no such file or directory"),
}, },
"provide type and name": { "provide type and name": {
args: []string{"a.b.c"}, args: []string{"a.b.c"},
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "Must specify two arguments: resource type and resource name", expectedErr: errors.New("Your argument format is incorrect: Must specify two arguments: resource type and resource name"),
}, },
"provide type and name with -f": { "provide type and name with -f": {
args: []string{"a.b.c", "name", "-f", "test.hcl"}, args: []string{"a.b.c", "name", "-f", "test.hcl"},
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "You need to provide all information in the HCL file if provide its file path", expectedErr: errors.New("We ignored the -f flag if you provide gvk and resource name"),
}, },
"provide type and name with -f and other flags": { "provide type and name with -f and other flags": {
args: []string{"a.b.c", "name", "-f", "test.hcl", "-namespace", "default"}, args: []string{"a.b.c", "name", "-f", "test.hcl", "-namespace", "default"},
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "You need to provide all information in the HCL file if provide its file path", expectedErr: errors.New("We ignored the -f flag if you provide gvk and resource name"),
}, },
"does not provide resource name after type": { "does not provide resource name after type": {
args: []string{"a.b.c", "-namespace", "default"}, args: []string{"a.b.c", "-namespace", "default"},
expectedCode: 1, expectedCode: 1,
expectedErrMsg: "Must provide resource name right after type", expectedErr: errors.New("Your argument format is incorrect: Must provide resource name right after type"),
},
"invalid resource type format": {
args: []string{"a.", "name", "-namespace", "default"},
expectedCode: 1,
expectedErr: errors.New("Your argument format is incorrect: Must include resource type argument in group.verion.kind format"),
}, },
} }
@ -61,32 +76,81 @@ func TestResourceReadInvalidArgs(t *testing.T) {
ui := cli.NewMockUi() ui := cli.NewMockUi()
c := New(ui) c := New(ui)
require.Equal(t, tc.expectedCode, c.Run(tc.args)) code := c.Run(tc.args)
require.NotEmpty(t, ui.ErrorWriter.String())
require.Equal(t, tc.expectedCode, code)
require.Contains(t, ui.ErrorWriter.String(), tc.expectedErr.Error())
}) })
} }
} }
func createResource(t *testing.T, a *agent.TestAgent) {
applyUi := cli.NewMockUi()
applyCmd := apply.New(applyUi)
args := []string{
"-http-addr=" + a.HTTPAddr(),
"-token=root",
}
args = append(args, []string{"-f=../testdata/demo.hcl"}...)
code := applyCmd.Run(args)
require.Equal(t, 0, code)
require.Empty(t, applyUi.ErrorWriter.String())
}
func TestResourceRead(t *testing.T) { func TestResourceRead(t *testing.T) {
// TODO: add read test after apply checked in if testing.Short() {
//if testing.Short() { t.Skip("too slow for testing.Short")
// t.Skip("too slow for testing.Short") }
//}
// t.Parallel()
//t.Parallel()
// a := agent.NewTestAgent(t, ``)
//a := agent.NewTestAgent(t, ``) defer a.Shutdown()
//defer a.Shutdown() testrpc.WaitForTestAgent(t, a.RPC, "dc1")
//client := a.Client()
// defaultCmdArgs := []string{
//ui := cli.NewMockUi() "-http-addr=" + a.HTTPAddr(),
//c := New(ui) "-token=root",
}
//_, _, err := client.Resource().Apply()
//require.NoError(t, err) createResource(t, a)
// cases := []struct {
//args := []string{} name string
// args []string
//code := c.Run(args) expectedCode int
//require.Equal(t, 0, code) errMsg string
}{
{
name: "read resource in hcl format",
args: []string{"-f=../testdata/demo.hcl"},
expectedCode: 0,
errMsg: "",
},
{
name: "read resource in command line format",
args: []string{"demo.v2.Artist", "korn", "-partition=default", "-namespace=default", "-peer=local"},
expectedCode: 0,
errMsg: "",
},
{
name: "read resource that doesn't exist",
args: []string{"demo.v2.Artist", "fake-korn", "-partition=default", "-namespace=default", "-peer=local"},
expectedCode: 1,
errMsg: "Error reading resource &{demo v2 Artist}/fake-korn: Unexpected response code: 404 (rpc error: code = NotFound desc = resource not found)\n",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
ui := cli.NewMockUi()
c := New(ui)
cliArgs := append(tc.args, defaultCmdArgs...)
code := c.Run(cliArgs)
require.Equal(t, ui.ErrorWriter.String(), tc.errMsg)
require.Equal(t, tc.expectedCode, code)
})
}
} }

Loading…
Cancel
Save