fizzy-cli 0.6.1 → 0.8.0

package/cmd/column_show_test.go

@@ -0,0 +1,111 @@
+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 TestColumnShowCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123/columns/col-456" {
+			t.Errorf("expected /boards/board-123/columns/col-456, 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.Column{
+			ID:        "col-456",
+			Name:      "In Progress",
+			CreatedAt: "2025-01-01T00:00:00Z",
+			Color: api.ColorObject{
+				Name:  "Lime",
+				Value: api.Lime,
+			},
+		}
+		json.NewEncoder(w).Encode(response)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	if err := handleShowColumnDetails(cmd, "col-456"); err != nil {
+		t.Fatalf("handleShowColumnDetails failed: %v", err)
+	}
+}
+
+func TestColumnShowCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Column not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowColumnDetails(cmd, "nonexistent-col")
+	if err == nil {
+		t.Errorf("expected error for column not found")
+	}
+	if err.Error() != "fetching column: unexpected status code 404: Column not found" {
+		t.Errorf("expected column not found error, got %v", err)
+	}
+}
+
+func TestColumnShowCommandAPIError(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, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := columnShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowColumnDetails(cmd, "col-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "fetching column: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestColumnShowCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := columnShowCmd
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleShowColumnDetails(cmd, "col-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)
+	}
+}

package/cmd/column_update.go

@@ -0,0 +1,67 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rogeriopvl/fizzy/internal/api"
+	"github.com/rogeriopvl/fizzy/internal/app"
+	"github.com/spf13/cobra"
+)
+
+var columnUpdateCmd = &cobra.Command{
+	Use:   "update <column_id>",
+	Short: "Update a column",
+	Long:  `Update column settings such as name and color`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		if err := handleUpdateColumn(cmd, args[0]); err != nil {
+			fmt.Fprintf(cmd.OutOrStderr(), "Error: %v\n", err)
+		}
+	},
+}
+
+func handleUpdateColumn(cmd *cobra.Command, columnID string) error {
+	// Check that at least one flag was explicitly set
+	if !cmd.Flags().Changed("name") && !cmd.Flags().Changed("color") {
+		return fmt.Errorf("at least one flag must be provided (--name or --color)")
+	}
+
+	a := app.FromContext(cmd.Context())
+	if a == nil || a.Client == nil {
+		return fmt.Errorf("API client not available")
+	}
+
+	// Build payload only with flags that were explicitly set
+	payload := api.UpdateColumnPayload{}
+
+	if cmd.Flags().Changed("name") {
+		name, _ := cmd.Flags().GetString("name")
+		payload.Name = name
+	}
+
+	if cmd.Flags().Changed("color") {
+		colorStr, _ := cmd.Flags().GetString("color")
+		colorAliases := buildColorAliases()
+		color, ok := colorAliases[colorStr]
+		if !ok {
+			return fmt.Errorf("invalid color '%s'. Available colors: %s", colorStr, getAvailableColors())
+		}
+		payload.Color = &color
+	}
+
+	err := a.Client.PutColumn(context.Background(), columnID, payload)
+	if err != nil {
+		return fmt.Errorf("updating column: %w", err)
+	}
+
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Column '%s' updated successfully\n", columnID)
+	return nil
+}
+
+func init() {
+	columnUpdateCmd.Flags().StringP("name", "n", "", "Column name")
+	columnUpdateCmd.Flags().String("color", "", fmt.Sprintf("Column color (optional). Available: %s", getAvailableColors()))
+
+	columnCmd.AddCommand(columnUpdateCmd)
+}

package/cmd/column_update_test.go

@@ -0,0 +1,198 @@
+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 newTestUpdateColumnCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:  "update <column_id>",
+		Args: cobra.ExactArgs(1),
+	}
+	cmd.Flags().StringP("name", "n", "", "Column name")
+	cmd.Flags().String("color", "", "Column color")
+	return cmd
+}
+
+func TestColumnUpdateCommandSuccess(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/boards/board-123/columns/col-456" {
+			t.Errorf("expected /boards/board-123/columns/col-456, 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.UpdateColumnPayload
+		if err := json.Unmarshal(body, &payload); err != nil {
+			t.Fatalf("failed to unmarshal request body: %v", err)
+		}
+
+		columnPayload := payload["column"]
+		if columnPayload.Name != "Updated Column" {
+			t.Errorf("expected name 'Updated Column', got %s", columnPayload.Name)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Column"})
+
+	if err := handleUpdateColumn(cmd, "col-456"); err != nil {
+		t.Fatalf("handleUpdateColumn failed: %v", err)
+	}
+}
+
+func TestColumnUpdateCommandWithColor(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.UpdateColumnPayload
+		json.Unmarshal(body, &payload)
+
+		columnPayload := payload["column"]
+		if columnPayload.Name != "Progress" {
+			t.Errorf("expected name 'Progress', got %s", columnPayload.Name)
+		}
+		if columnPayload.Color == nil {
+			t.Error("expected Color to be set")
+		} else if *columnPayload.Color != api.Lime {
+			t.Errorf("expected color Lime, got %s", *columnPayload.Color)
+		}
+
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Progress", "--color", "lime"})
+
+	if err := handleUpdateColumn(cmd, "col-456"); err != nil {
+		t.Fatalf("handleUpdateColumn failed: %v", err)
+	}
+}
+
+func TestColumnUpdateCommandInvalidColor(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--color", "invalid-color"})
+
+	err := handleUpdateColumn(cmd, "col-456")
+	if err == nil {
+		t.Errorf("expected error for invalid color")
+	}
+	errMsg := err.Error()
+	if errMsg != "invalid color 'invalid-color'. Available colors: blue, gray, tan, yellow, lime, aqua, violet, purple, pink" {
+		t.Errorf("expected invalid color error, got %v", err)
+	}
+}
+
+func TestColumnUpdateCommandNoFlags(t *testing.T) {
+	client := testutil.NewTestClient("http://localhost", "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+
+	err := handleUpdateColumn(cmd, "col-456")
+	if err == nil {
+		t.Errorf("expected error when no flags provided")
+	}
+	if err.Error() != "at least one flag must be provided (--name or --color)" {
+		t.Errorf("expected flag requirement error, got %v", err)
+	}
+}
+
+func TestColumnUpdateCommandNotFound(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte("Column not found"))
+	}))
+	defer server.Close()
+
+	client := testutil.NewTestClient(server.URL, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Column"})
+
+	err := handleUpdateColumn(cmd, "nonexistent-col")
+	if err == nil {
+		t.Errorf("expected error for column not found")
+	}
+	if err.Error() != "updating column: unexpected status code 404: Column not found" {
+		t.Errorf("expected column not found error, got %v", err)
+	}
+}
+
+func TestColumnUpdateCommandAPIError(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, "", "board-123", "test-token")
+	testApp := &app.App{Client: client}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Column"})
+
+	err := handleUpdateColumn(cmd, "col-456")
+	if err == nil {
+		t.Errorf("expected error for API failure")
+	}
+	if err.Error() != "updating column: unexpected status code 500: Internal Server Error" {
+		t.Errorf("expected API error, got %v", err)
+	}
+}
+
+func TestColumnUpdateCommandNoClient(t *testing.T) {
+	testApp := &app.App{}
+
+	cmd := newTestUpdateColumnCmd()
+	cmd.SetContext(testApp.ToContext(context.Background()))
+	cmd.ParseFlags([]string{"--name", "Updated Column"})
+
+	err := handleUpdateColumn(cmd, "col-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)
+	}
+}

package/cmd/comment_create.go

@@ -39,7 +39,7 @@ func handleCreateComment(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("creating comment: %w", err)
 	}
 
-	fmt.Printf("✓ Comment created successfully\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Comment created successfully\n")
 	return nil
 }
 

package/cmd/comment_delete.go

@@ -37,7 +37,7 @@ func handleDeleteComment(cmd *cobra.Command, cardNumber, commentID string) error
 		return fmt.Errorf("deleting comment: %w", err)
 	}
 
-	fmt.Printf("✓ Comment deleted successfully\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Comment deleted successfully\n")
 	return nil
 }
 

package/cmd/comment_update.go

@@ -39,7 +39,7 @@ func handleUpdateComment(cmd *cobra.Command, cardNumber, commentID string) error
 		return fmt.Errorf("updating comment: %w", err)
 	}
 
-	fmt.Printf("✓ Comment updated successfully (id: %s)\n", comment.ID)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Comment updated successfully (id: %s)\n", comment.ID)
 	return nil
 }
 

package/cmd/login.go

@@ -25,10 +25,10 @@ var loginCmd = &cobra.Command{
 func handleLogin(cmd *cobra.Command) error {
 	token, isSet := os.LookupEnv("FIZZY_ACCESS_TOKEN")
 	if !isSet || token == "" {
-		return printAuthInstructions()
+		return printAuthInstructions(cmd)
 	}
 
-	fmt.Printf("✓ Authenticated with access token: %s\n", token[:6]+"...")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Authenticated with access token: %s\n", token[:6]+"...")
 
 	a := app.FromContext(cmd.Context())
 	if a == nil || a.Client == nil {
@@ -40,12 +40,12 @@ func handleLogin(cmd *cobra.Command) error {
 		return fmt.Errorf("fetching identity: %w", err)
 	}
 
-	selected, err := chooseAccount(identity.Accounts)
+	selected, err := chooseAccount(cmd, identity.Accounts)
 	if err != nil {
 		return err
 	}
 
-	fmt.Printf("\nSelected account: %s (%s)\n", selected.Name, selected.Slug)
+	fmt.Fprintf(cmd.OutOrStdout(), "\nSelected account: %s (%s)\n", selected.Name, selected.Slug)
 
 	// Save the selected account and current user ID to config
 	a.Config.SelectedAccount = selected.Slug
@@ -57,22 +57,22 @@ func handleLogin(cmd *cobra.Command) error {
 	return nil
 }
 
-func chooseAccount(accounts []api.Account) (api.Account, error) {
+func chooseAccount(cmd *cobra.Command, accounts []api.Account) (api.Account, error) {
 	if len(accounts) == 1 {
 		selected := accounts[0]
 		return selected, nil
 	}
 
-	fmt.Println("\nAvailable accounts:")
+	fmt.Fprintf(cmd.OutOrStdout(), "\nAvailable accounts:\n")
 	return ui.SelectAccount(accounts)
 }
 
-func printAuthInstructions() error {
-	fmt.Println("To authenticate with Fizzy's API you need an access token.")
-	fmt.Printf("\nGo to https://app.fizzy.do/<account_slug>/my/access_tokens and follow the instructions...\n")
-	fmt.Println("(Replace <account_slug> with your account slug)")
-	fmt.Printf("\nThen export it as an environment variable in your shell, with the name FIZZY_ACCESS_TOKEN\n")
-	fmt.Println("And re-run this command.")
+func printAuthInstructions(cmd *cobra.Command) error {
+	fmt.Fprintf(cmd.OutOrStdout(), "To authenticate with Fizzy's API you need an access token.\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "\nGo to https://app.fizzy.do/<account_slug>/my/access_tokens and follow the instructions...\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "(Replace <account_slug> with your account slug)\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "\nThen export it as an environment variable in your shell, with the name FIZZY_ACCESS_TOKEN\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "And re-run this command.\n")
 	return nil
 }
 

package/cmd/notification_unread.go

@@ -35,7 +35,7 @@ func handleUnreadNotification(cmd *cobra.Command, notificationID string) error {
 		return fmt.Errorf("marking notification as unread: %w", err)
 	}
 
-	fmt.Printf("✓ Notification marked as unread successfully\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Notification marked as unread successfully\n")
 	return nil
 }
 

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/reaction_create.go

@@ -37,7 +37,7 @@ func handleCreateReaction(cmd *cobra.Command, cardNumber, commentID, emoji strin
 		return fmt.Errorf("creating reaction: %w", err)
 	}
 
-	fmt.Printf("✓ Reaction %s created successfully\n", emoji)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Reaction %s created successfully\n", emoji)
 	return nil
 }
 

package/cmd/reaction_delete.go

@@ -37,7 +37,7 @@ func handleDeleteReaction(cmd *cobra.Command, cardNumber, commentID, reactionID
 		return fmt.Errorf("deleting reaction: %w", err)
 	}
 
-	fmt.Printf("✓ Reaction deleted successfully\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Reaction deleted successfully\n")
 	return nil
 }
 

package/cmd/step_create.go

@@ -40,7 +40,7 @@ func handleCreateStep(cmd *cobra.Command, cardNumber string) error {
 		return fmt.Errorf("creating step: %w", err)
 	}
 
-	fmt.Printf("✓ Step created successfully\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Step created successfully\n")
 	return nil
 }
 

package/cmd/step_delete.go

@@ -37,7 +37,7 @@ func handleDeleteStep(cmd *cobra.Command, cardNumber, stepID string) error {
 		return fmt.Errorf("deleting step: %w", err)
 	}
 
-	fmt.Printf("✓ Step deleted successfully\n")
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Step deleted successfully\n")
 	return nil
 }
 

package/cmd/step_update.go

@@ -54,7 +54,7 @@ func handleUpdateStep(cmd *cobra.Command, cardNumber, stepID string) error {
 		return fmt.Errorf("updating step: %w", err)
 	}
 
-	fmt.Printf("✓ Step updated successfully (id: %s)\n", step.ID)
+	fmt.Fprintf(cmd.OutOrStdout(), "✓ Step updated successfully (id: %s)\n", step.ID)
 	return nil
 }
 

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