fizzy-cli 0.6.1 → 0.8.0

package/cmd/user_deactivate_test.go

@@ -0,0 +1,121 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestUserDeactivateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/users/user-123" {
+			t.Errorf("expected /users/user-123, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodDelete {
+			t.Errorf("expected DELETE, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userDeactivateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeactivateUser(cmd, "user-123"); err != nil {
+		t.Fatalf("handleDeactivateUser failed: %v", err)
+	}
+}
+
+func TestUserDeactivateCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("User not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userDeactivateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeactivateUser(cmd, "nonexistent-user")
+	if err == nil {
+		t.Errorf("expected error for user not found")
+	}
+	if err.Error() != "deactivating user: unexpected status code 404: User not found" {
+		t.Errorf("expected user not found error, got %v", err)
+	}
+}
+
+func TestUserDeactivateCommandForbidden(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusForbidden)
+		w.Write([]byte("You don't have permission to deactivate this user"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userDeactivateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeactivateUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error for forbidden access")
+	}
+	if err.Error() != "deactivating user: unexpected status code 403: You don't have permission to deactivate this user" {
+		t.Errorf("expected permission error, got %v", err)
+	}
+}
+
+func TestUserDeactivateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userDeactivateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeactivateUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "deactivating user: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestUserDeactivateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := userDeactivateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeactivateUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error when client not available")
+	}
+	if err.Error() != "API client not available" {
+		t.Errorf("expected 'client not available' error, got %v", err)
+	}
+}

package/cmd/user_list.go

@@ -0,0 +1,44 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var userListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all users",
+	Long:  `Retrieve and display all users from the current account`,
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListUsers(cmd); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListUsers(cmd *cobra.Command) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	users, err := a.Client.GetUsers(context.Background())
+	if err != nil {
+		return fmt.Errorf("fetching users: %w", err)
+	}
+
+	if len(users) == 0 {
+		fmt.Println("No users found")
+		return nil
+	}
+
+	return ui.DisplayUsers(cmd.OutOrStdout(), users)
+}
+
+func init() {
+	userCmd.AddCommand(userListCmd)
+}

package/cmd/user_list_test.go

@@ -0,0 +1,126 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestUserListCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/users" {
+			t.Errorf("expected /users, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodGet {
+			t.Errorf("expected GET, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth == "" {
+			t.Error("missing Authorization header")
+		}
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := []api.User{
+			{
+				ID:        "user-123",
+				Name:      "John Doe",
+				Email:     "john@example.com",
+				Role:      "admin",
+				Active:    true,
+				CreatedAt: "2025-01-01T00:00:00Z",
+			},
+			{
+				ID:        "user-456",
+				Name:      "Jane Smith",
+				Email:     "jane@example.com",
+				Role:      "member",
+				Active:    false,
+				CreatedAt: "2025-01-02T00:00:00Z",
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.SetOut(&bytes.Buffer{})
+
+	if err := handleListUsers(cmd); err != nil {
+		t.Fatalf("handleListUsers failed: %v", err)
+	}
+}
+
+func TestUserListCommandNoUsers(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode([]api.User{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.SetOut(&bytes.Buffer{})
+
+	if err := handleListUsers(cmd); err != nil {
+		t.Fatalf("handleListUsers failed: %v", err)
+	}
+}
+
+func TestUserListCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cmd.SetOut(&bytes.Buffer{})
+
+	err := handleListUsers(cmd)
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching users: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestUserListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := userListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	cmd.SetOut(&bytes.Buffer{})
+
+	err := handleListUsers(cmd)
+	if err == nil {
+		t.Errorf("expected error when client not available")
+	}
+	if err.Error() != "API client not available" {
+		t.Errorf("expected 'client not available' error, got %v", err)
+	}
+}

package/cmd/user_show.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var userShowCmd = &cobra.Command{
+	Use:   "show <user_id>",
+	Short: "Show user details",
+	Long:  `Retrieve and display detailed information about a specific user`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleShowUser(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleShowUser(cmd *cobra.Command, userID string) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	user, err := a.Client.GetUser(context.Background(), userID)
+	if err != nil {
+		return fmt.Errorf("fetching user: %w", err)
+	}
+
+	return ui.DisplayUser(cmd.OutOrStdout(), user)
+}
+
+func init() {
+	userCmd.AddCommand(userShowCmd)
+}

package/cmd/user_show_test.go

@@ -0,0 +1,110 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestUserShowCommand(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/users/user-123" {
+			t.Errorf("expected /users/user-123, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodGet {
+			t.Errorf("expected GET, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		response := api.User{
+			ID:        "user-123",
+			Name:      "John Doe",
+			Email:     "john@example.com",
+			Role:      "admin",
+			Active:    true,
+			CreatedAt: "2025-01-01T00:00:00Z",
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleShowUser(cmd, "user-123"); err != nil {
+		t.Fatalf("handleShowUser failed: %v", err)
+	}
+}
+
+func TestUserShowCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("User not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowUser(cmd, "nonexistent-user")
+	if err == nil {
+		t.Errorf("expected error for user not found")
+	}
+	if err.Error() != "fetching user: unexpected status code 404: User not found" {
+		t.Errorf("expected user not found error, got %v", err)
+	}
+}
+
+func TestUserShowCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching user: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestUserShowCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := userShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error when client not available")
+	}
+	if err.Error() != "API client not available" {
+		t.Errorf("expected 'client not available' error, got %v", err)
+	}
+}

package/cmd/user_update.go

@@ -0,0 +1,71 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var userUpdateCmd = &cobra.Command{
+	Use:   "update <user_id>",
+	Short: "Update a user",
+	Long: `Update user settings such as name and avatar.
+
+Avatar must be provided as a URL (e.g., https://example.com/avatar.jpg).
+
+Example:
+  fizzy user update user-123 --name "John Doe"
+  fizzy user update user-123 --avatar https://example.com/avatar.jpg`,
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUpdateUser(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUpdateUser(cmd *cobra.Command, userID string) error {
+	if !cmd.Flags().Changed("name") && !cmd.Flags().Changed("avatar") {
+		return fmt.Errorf("at least one flag must be provided (--name or --avatar)")
+	}
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	payload := api.UpdateUserPayload{}
+
+	if cmd.Flags().Changed("name") {
+		name, err := cmd.Flags().GetString("name")
+		if err != nil {
+			return fmt.Errorf("invalid name flag: %w", err)
+		}
+		payload.Name = name
+	}
+	if cmd.Flags().Changed("avatar") {
+		avatar, err := cmd.Flags().GetString("avatar")
+		if err != nil {
+			return fmt.Errorf("invalid avatar flag: %w", err)
+		}
+		payload.Avatar = avatar
+	}
+
+	err := a.Client.PutUser(context.Background(), userID, payload)
+	if err != nil {
+		return fmt.Errorf("updating user: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ User '%s' updated successfully\n", userID)
+	return nil
+}
+
+func init() {
+	userUpdateCmd.Flags().StringP("name", "n", "", "User name")
+	userUpdateCmd.Flags().String("avatar", "", "Avatar URL (e.g., https://example.com/avatar.jpg)")
+
+	userCmd.AddCommand(userUpdateCmd)
+}

package/cmd/user_update_test.go

@@ -0,0 +1,177 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+	"github.com/spf13/cobra"
+)
+
+func TestUserUpdateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/users/user-123" {
+			t.Errorf("expected /users/user-123, got %s", r.URL.Path)
+		}
+		if r.Method != http.MethodPut {
+			t.Errorf("expected PUT, got %s", r.Method)
+		}
+
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-token" {
+			t.Errorf("expected Bearer test-token, got %s", auth)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.UpdateUserPayload
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		userPayload := payload["user"]
+		if userPayload.Name != "Updated Name" {
+			t.Errorf("expected name 'Updated Name', got %s", userPayload.Name)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Name"})
+
+	if err := handleUpdateUser(cmd, "user-123"); err != nil {
+		t.Fatalf("handleUpdateUser failed: %v", err)
+	}
+}
+
+func TestUserUpdateCommandWithAllFlags(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPut {
+			t.Errorf("expected PUT, got %s", r.Method)
+		}
+
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]api.UpdateUserPayload
+		json.Unmarshal(body, &payload)
+
+		userPayload := payload["user"]
+		if userPayload.Name != "Updated Name" {
+			t.Errorf("expected name 'Updated Name', got %s", userPayload.Name)
+		}
+		if userPayload.Avatar != "https://example.com/avatar.png" {
+			t.Errorf("expected avatar 'https://example.com/avatar.png', got %s", userPayload.Avatar)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{
+		"--name", "Updated Name",
+		"--avatar", "https://example.com/avatar.png",
+	})
+
+	if err := handleUpdateUser(cmd, "user-123"); err != nil {
+		t.Fatalf("handleUpdateUser failed: %v", err)
+	}
+}
+
+func TestUserUpdateCommandNoFlags(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := &cobra.Command{
+		Use:  "update <user_id>",
+		Args: cobra.ExactArgs(1),
+	}
+	cmd.Flags().String("name", "", "User name")
+	cmd.Flags().String("avatar", "", "Avatar URL or file path")
+
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUpdateUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error when no flags provided")
+	}
+	if err.Error() != "at least one flag must be provided (--name or --avatar)" {
+		t.Errorf("expected flag requirement error, got %v", err)
+	}
+}
+
+func TestUserUpdateCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("User not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Name"})
+
+	err := handleUpdateUser(cmd, "nonexistent-user")
+	if err == nil {
+		t.Errorf("expected error for user not found")
+	}
+	if err.Error() != "updating user: unexpected status code 404: User not found" {
+		t.Errorf("expected user not found error, got %v", err)
+	}
+}
+
+func TestUserUpdateCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Write([]byte("Internal Server Error"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := userUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Name"})
+
+	err := handleUpdateUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "updating user: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestUserUpdateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := userUpdateCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Name"})
+
+	err := handleUpdateUser(cmd, "user-123")
+	if err == nil {
+		t.Errorf("expected error when client not available")
+	}
+	if err.Error() != "API client not available" {
+		t.Errorf("expected 'client not available' error, got %v", err)
+	}
+}