fix: resource command group

resource command group was broken in a previous
refactor.

Author: toumorokoshi

internal/service/resource_definition.go

@@ -40,7 +40,7 @@ type ListMethod struct {
 type DeleteMethod struct {
 }
 
-func (r *Resource) ExecuteCommand(args []string) (*http.Request, error) {
+func (r *Resource) ExecuteCommand(args []string) (*http.Request, error, string) {
 	c := cobra.Command{Use: r.Singular}
 	var err error
 	var req *http.Request
@@ -157,12 +157,15 @@ func (r *Resource) ExecuteCommand(args []string) (*http.Request, error) {
 		}
 		c.AddCommand(listCmd)
 	}
-
+	var stderr strings.Builder
+	var stdout strings.Builder
+	c.SetOut(&stdout)
+	c.SetErr(&stderr)
 	c.SetArgs(args)
 	if err := c.Execute(); err != nil {
-		return nil, err
+		return nil, err, stdout.String() + stderr.String()
 	}
-	return req, err
+	return req, err, stdout.String() + stderr.String()
 }
 
 func addSchemaFlags(c *cobra.Command, schema openapi.Schema, args map[string]interface{}) error {

internal/service/resource_definition_test.go

@@ -109,7 +109,7 @@ func TestExecuteCommand(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			req, err := tt.resource.ExecuteCommand(tt.args)
+			req, err, _ := tt.resource.ExecuteCommand(tt.args)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ExecuteCommand() error = %v, wantErr %v", err, tt.wantErr)
 				return

internal/service/service.go

@@ -35,19 +35,23 @@ func (s *Service) ExecuteCommand(args []string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("%v\n%v", err, s.PrintHelp())
 	}
-	req, err := r.ExecuteCommand(args)
+	req, err, output := r.ExecuteCommand(args[1:])
 	if err != nil {
 		return "", fmt.Errorf("unable to execute command: %v", err)
 	}
 	if req == nil {
-		return "", nil
+		return output, nil
 	}
 	url, err := url.Parse(fmt.Sprintf("%s/%s", s.ServerURL, req.URL.String()))
 	if err != nil {
 		return "", fmt.Errorf("unable to create url: %v", err)
 	}
 	req.URL = url
-	return s.doRequest(req)
+	reqOutput, err := s.doRequest(req)
+	if err != nil {
+		return "", fmt.Errorf("unable to execute request: %v", err)
+	}
+	return strings.Join([]string{output, reqOutput}, "\n"), nil
 }
 
 func (s *Service) doRequest(r *http.Request) (string, error) {

internal/service/service_definition.go

@@ -131,7 +131,7 @@ func GetServiceDefinition(api *openapi.OpenAPI, serverURL, pathPrefix string) (*
 func (s *ServiceDefinition) GetResource(resource string) (*Resource, error) {
 	r, ok := (*s).Resources[resource]
 	if !ok {
-		return nil, fmt.Errorf("Resource %s not found", resource)
+		return nil, fmt.Errorf("Resource %q not found", resource)
 	}
 	return r, nil
 }

internal/service/service_test.go

@@ -10,37 +10,58 @@ func TestService_ExecuteCommand_ListResources(t *testing.T) {
 	svc := NewService(ServiceDefinition{
 		ServerURL: "http://test.com",
 		Resources: map[string]*Resource{
+			"project": &projectResource,
 			"user":    {},
 			"post":    {},
 			"comment": {},
 		},
 	}, nil)
 
 	tests := []struct {
-		name     string
-		args     []string
-		expected string
+		name          string
+		args          []string
+		expectAsError bool
+		expected      string
 	}{
 		{
 			name:     "no arguments",
 			args:     []string{},
-			expected: "Available resources:\n  - comment\n  - post\n  - user\n",
+			expected: "Available resources:\n  - comment\n  - post\n  - project\n  - user\n",
 		},
 		{
 			name:     "help flag",
 			args:     []string{"--help"},
-			expected: "Available resources:\n  - comment\n  - post\n  - user\n",
+			expected: "Available resources:\n  - comment\n  - post\n  - project\n  - user\n",
+		},
+		{
+			name:          "unknown resource",
+			args:          []string{"users"},
+			expectAsError: true,
+			expected:      "Resource \"users\" not found",
+		},
+		{
+			name:     "help for project",
+			args:     []string{"project", "--help"},
+			expected: "Available Commands:",
+		},
+		{
+			name:     "help for project",
+			args:     []string{"project"},
+			expected: "Available Commands:",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result, err := svc.ExecuteCommand(tt.args)
 			if err != nil {
-				t.Errorf("ExecuteCommand() error = %v, expected no error", err)
-			}
-			if !strings.Contains(result, tt.expected) {
-				t.Errorf("ExecuteCommand() = %v, expected it to contain %v", result, tt.expected)
+				if !tt.expectAsError {
+					t.Errorf("ExecuteCommand() error = %v, expected no error", err)
+				} else if !strings.Contains(err.Error(), tt.expected) {
+					t.Errorf("ExecuteCommand() error = %v, expected it to contain %v", err, tt.expected)
+				}
+			} else if !strings.Contains(result, tt.expected) {
+				t.Errorf("ExecuteCommand() = %q, expected it to contain %q", result, tt.expected)
 			}
 		})
 	}