fizzy-cli 0.7.0 → 0.8.0

package/cmd/card_reaction_delete_test.go

@@ -0,0 +1,112 @@
+package cmd
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/testutil"
+)
+
+func TestCardReactionDeleteCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/reactions/reaction-456" {
+			t.Errorf("expected /cards/123/reactions/reaction-456, 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 := cardReactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeleteCardReaction(cmd, "123", "reaction-456"); err != nil {
+		t.Fatalf("handleDeleteCardReaction failed: %v", err)
+	}
+}
+
+func TestCardReactionDeleteCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteCardReaction(cmd, "not-a-number", "reaction-456")
+	if err == nil {
+		t.Errorf("expected error for invalid card number")
+	}
+	if err.Error() != "invalid card number: strconv.Atoi: parsing \"not-a-number\": invalid syntax" {
+		t.Errorf("expected invalid card number error, got %v", err)
+	}
+}
+
+func TestCardReactionDeleteCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteCardReaction(cmd, "123", "reaction-456")
+	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)
+	}
+}
+
+func TestCardReactionDeleteCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Reaction not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleDeleteCardReaction(cmd, "123", "reaction-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "deleting reaction: unexpected status code 404: Reaction not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestCardReactionDeleteCommandDifferentReactionID(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/456/reactions/reaction-789" {
+			t.Errorf("expected /cards/456/reactions/reaction-789, got %s", r.URL.Path)
+		}
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionDeleteCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleDeleteCardReaction(cmd, "456", "reaction-789"); err != nil {
+		t.Fatalf("handleDeleteCardReaction failed: %v", err)
+	}
+}

package/cmd/card_reaction_list.go

@@ -0,0 +1,51 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/rogeriopvl/fizzy/internal/ui"
+	"github.com/spf13/cobra"
+)
+
+var cardReactionListCmd = &cobra.Command{
+	Use:   "list <card_number>",
+	Short: "List reactions on a card",
+	Long:  `Retrieve and display all reactions (boosts) on a card`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleListCardReactions(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleListCardReactions(cmd *cobra.Command, cardNumber string) error {
+	cardNum, err := strconv.Atoi(cardNumber)
+	if err != nil {
+		return fmt.Errorf("invalid card number: %w", err)
+	}
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	reactions, err := a.Client.GetCardReactions(context.Background(), cardNum)
+	if err != nil {
+		return fmt.Errorf("fetching reactions: %w", err)
+	}
+
+	if len(reactions) == 0 {
+		fmt.Println("No reactions found")
+		return nil
+	}
+
+	return ui.DisplayReactions(reactions)
+}
+
+func init() {
+	cardReactionCmd.AddCommand(cardReactionListCmd)
+}

package/cmd/card_reaction_list_test.go

@@ -0,0 +1,127 @@
+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 TestCardReactionListCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/cards/123/reactions" {
+			t.Errorf("expected /cards/123/reactions, 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")
+		w.WriteHeader(http.StatusOK)
+		reactions := []api.Reaction{
+			{
+				ID:      "reaction-1",
+				Content: "👍",
+				Reacter: api.User{ID: "user-1", Name: "Alice"},
+			},
+			{
+				ID:      "reaction-2",
+				Content: "🎉",
+				Reacter: api.User{ID: "user-2", Name: "Bob"},
+			},
+		}
+		json.NewEncoder(w).Encode(reactions)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListCardReactions(cmd, "123"); err != nil {
+		t.Fatalf("handleListCardReactions failed: %v", err)
+	}
+}
+
+func TestCardReactionListCommandNoReactions(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode([]api.Reaction{})
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleListCardReactions(cmd, "123"); err != nil {
+		t.Fatalf("handleListCardReactions failed: %v", err)
+	}
+}
+
+func TestCardReactionListCommandInvalidCardNumber(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListCardReactions(cmd, "not-a-number")
+	if err == nil {
+		t.Errorf("expected error for invalid card number")
+	}
+	if err.Error() != "invalid card number: strconv.Atoi: parsing \"not-a-number\": invalid syntax" {
+		t.Errorf("expected invalid card number error, got %v", err)
+	}
+}
+
+func TestCardReactionListCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := cardReactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListCardReactions(cmd, "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)
+	}
+}
+
+func TestCardReactionListCommandAPIError(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Card not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := cardReactionListCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleListCardReactions(cmd, "123")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching reactions: unexpected status code 404: Card not found" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}

package/cmd/reaction.go

@@ -4,8 +4,8 @@ import "github.com/spf13/cobra"
 
 var reactionCmd = &cobra.Command{
 	Use:   "reaction",
-	Short: "Manage comment reactions",
-	Long:  `Manage reactions on comments in Fizzy`,
+	Short: "Manage reactions",
+	Long:  `Manage reactions on cards and comments in Fizzy`,
 }
 
 func init() {

package/cmd/user.go

@@ -0,0 +1,22 @@
+// Package cmd
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var userCmd = &cobra.Command{
+	Use:   "user",
+	Short: "Manage users",
+	Long: `Manage users in your account.
+
+Use subcommands to list, view, or manage users:
+  fizzy user list         List all users
+  fizzy user show <id>    Show user details
+  fizzy user update <id>  Update user settings
+  fizzy user deactivate <id>  Deactivate a user`,
+}
+
+func init() {
+	rootCmd.AddCommand(userCmd)
+}

package/cmd/user_deactivate.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var userDeactivateCmd = &cobra.Command{
+	Use:   "deactivate <user_id>",
+	Short: "Deactivate a user",
+	Long:  `Deactivate a user. Only account administrators can deactivate users.`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleDeactivateUser(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleDeactivateUser(cmd *cobra.Command, userID string) error {
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	err := a.Client.DeleteUser(context.Background(), userID)
+	if err != nil {
+		return fmt.Errorf("deactivating user: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ User '%s' deactivated successfully\n", userID)
+	return nil
+}
+
+func init() {
+	userCmd.AddCommand(userDeactivateCmd)
+}

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)
+}